Api-roll 43: 2016-12-13

generated/googleapis/lib/sheets/v4.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.sheets.v4;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
@@ skipping 293 matching lines @@
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [spreadsheetId] - The ID of the spreadsheet to update.
    *
    * [range] - The A1 notation of a range to search for a logical table of data.
    * Values will be appended after the last row of the table.
    *
+   * [responseValueRenderOption] - Determines how values in the response should
+   * be rendered.
+   * The default render option is ValueRenderOption.FORMATTED_VALUE.
+   * Possible string values are:
+   * - "FORMATTED_VALUE" : A FORMATTED_VALUE.
+   * - "UNFORMATTED_VALUE" : A UNFORMATTED_VALUE.
+   * - "FORMULA" : A FORMULA.
+   *
    * [valueInputOption] - How the input data should be interpreted.
    * Possible string values are:
    * - "INPUT_VALUE_OPTION_UNSPECIFIED" : A INPUT_VALUE_OPTION_UNSPECIFIED.
    * - "RAW" : A RAW.
    * - "USER_ENTERED" : A USER_ENTERED.
    *
+   * [responseDateTimeRenderOption] - Determines how dates, times, and durations
+   * in the response should be
+   * rendered. This is ignored if response_value_render_option is
+   * FORMATTED_VALUE.
+   * The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER].
+   * Possible string values are:
+   * - "SERIAL_NUMBER" : A SERIAL_NUMBER.
+   * - "FORMATTED_STRING" : A FORMATTED_STRING.
+   *
+   * [includeValuesInResponse] - Determines if the update response should
+   * include the values
+   * of the cells that were appended. By default, responses
+   * do not include the updated values.
+   *
    * [insertDataOption] - How the input data should be inserted.
    * Possible string values are:
    * - "OVERWRITE" : A OVERWRITE.
    * - "INSERT_ROWS" : A INSERT_ROWS.
    *
    * Completes with a [AppendValuesResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
-  async.Future<AppendValuesResponse> append(ValueRange request, core.String spreadsheetId, core.String range, {core.String valueInputOption, core.String insertDataOption}) {
+  async.Future<AppendValuesResponse> append(ValueRange request, core.String spreadsheetId, core.String range, {core.String responseValueRenderOption, core.String valueInputOption, core.String responseDateTimeRenderOption, core.bool includeValuesInResponse, core.String insertDataOption}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (spreadsheetId == null) {
       throw new core.ArgumentError("Parameter spreadsheetId is required.");
     }
     if (range == null) {
       throw new core.ArgumentError("Parameter range is required.");
     }
+    if (responseValueRenderOption != null) {
+      _queryParams["responseValueRenderOption"] = [responseValueRenderOption];
+    }
     if (valueInputOption != null) {
       _queryParams["valueInputOption"] = [valueInputOption];
     }
+    if (responseDateTimeRenderOption != null) {
+      _queryParams["responseDateTimeRenderOption"] = [responseDateTimeRenderOption];
+    }
+    if (includeValuesInResponse != null) {
+      _queryParams["includeValuesInResponse"] = ["${includeValuesInResponse}"];
+    }
     if (insertDataOption != null) {
       _queryParams["insertDataOption"] = [insertDataOption];
     }
 
     _url = 'v4/spreadsheets/' + commons.Escaper.ecapeVariable('$spreadsheetId') + '/values/' + commons.Escaper.ecapeVariable('$range') + ':append';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 54 matching lines @@
    * Returns one or more ranges of values from a spreadsheet.
    * The caller must specify the spreadsheet ID and one or more ranges.
    *
    * Request parameters:
    *
    * [spreadsheetId] - The ID of the spreadsheet to retrieve data from.
    *
    * [ranges] - The A1 notation of the values to retrieve.
    *
    * [valueRenderOption] - How values should be represented in the output.
+   * The default render option is ValueRenderOption.FORMATTED_VALUE.
    * Possible string values are:
    * - "FORMATTED_VALUE" : A FORMATTED_VALUE.
    * - "UNFORMATTED_VALUE" : A UNFORMATTED_VALUE.
    * - "FORMULA" : A FORMULA.
    *
    * [dateTimeRenderOption] - How dates, times, and durations should be
    * represented in the output.
    * This is ignored if value_render_option is
    * FORMATTED_VALUE.
+   * The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER].
    * Possible string values are:
    * - "SERIAL_NUMBER" : A SERIAL_NUMBER.
    * - "FORMATTED_STRING" : A FORMATTED_STRING.
    *
    * [majorDimension] - The major dimension that results should use.
    *
    * For example, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`,
    * then requesting `range=A1:B2,majorDimension=ROWS` will return
    * `[[1,2],[3,4]]`,
    * whereas requesting `range=A1:B2,majorDimension=COLUMNS` will return
@@ skipping 150 matching lines @@
    * Returns a range of values from a spreadsheet.
    * The caller must specify the spreadsheet ID and a range.
    *
    * Request parameters:
    *
    * [spreadsheetId] - The ID of the spreadsheet to retrieve data from.
    *
    * [range] - The A1 notation of the values to retrieve.
    *
    * [valueRenderOption] - How values should be represented in the output.
+   * The default render option is ValueRenderOption.FORMATTED_VALUE.
    * Possible string values are:
    * - "FORMATTED_VALUE" : A FORMATTED_VALUE.
    * - "UNFORMATTED_VALUE" : A UNFORMATTED_VALUE.
    * - "FORMULA" : A FORMULA.
    *
    * [dateTimeRenderOption] - How dates, times, and durations should be
    * represented in the output.
    * This is ignored if value_render_option is
    * FORMATTED_VALUE.
+   * The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER].
    * Possible string values are:
    * - "SERIAL_NUMBER" : A SERIAL_NUMBER.
    * - "FORMATTED_STRING" : A FORMATTED_STRING.
    *
    * [majorDimension] - The major dimension that results should use.
    *
    * For example, if the spreadsheet data is: `A1=1,B1=2,A2=3,B2=4`,
    * then requesting `range=A1:B2,majorDimension=ROWS` will return
    * `[[1,2],[3,4]]`,
    * whereas requesting `range=A1:B2,majorDimension=COLUMNS` will return
@@ skipping 53 matching lines @@
    * a valueInputOption.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [spreadsheetId] - The ID of the spreadsheet to update.
    *
    * [range] - The A1 notation of the values to update.
    *
+   * [responseValueRenderOption] - Determines how values in the response should
+   * be rendered.
+   * The default render option is ValueRenderOption.FORMATTED_VALUE.
+   * Possible string values are:
+   * - "FORMATTED_VALUE" : A FORMATTED_VALUE.
+   * - "UNFORMATTED_VALUE" : A UNFORMATTED_VALUE.
+   * - "FORMULA" : A FORMULA.
+   *
    * [valueInputOption] - How the input data should be interpreted.
    * Possible string values are:
    * - "INPUT_VALUE_OPTION_UNSPECIFIED" : A INPUT_VALUE_OPTION_UNSPECIFIED.
    * - "RAW" : A RAW.
    * - "USER_ENTERED" : A USER_ENTERED.
    *
+   * [responseDateTimeRenderOption] - Determines how dates, times, and durations
+   * in the response should be
+   * rendered. This is ignored if response_value_render_option is
+   * FORMATTED_VALUE.
+   * The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER].
+   * Possible string values are:
+   * - "SERIAL_NUMBER" : A SERIAL_NUMBER.
+   * - "FORMATTED_STRING" : A FORMATTED_STRING.
+   *
+   * [includeValuesInResponse] - Determines if the update response should
+   * include the values
+   * of the cells that were updated. By default, responses
+   * do not include the updated values.
+   * If the range to write was larger than than the range actually written,
+   * the response will include all values in the requested range (excluding
+   * trailing empty rows and columns).
+   *
    * Completes with a [UpdateValuesResponse].
    *
    * Completes with a [commons.ApiRequestError] if the API endpoint returned an
    * error.
    *
    * If the used [http.Client] completes with an error when making a REST call,
    * this method will complete with the same error.
    */
-  async.Future<UpdateValuesResponse> update(ValueRange request, core.String spreadsheetId, core.String range, {core.String valueInputOption}) {
+  async.Future<UpdateValuesResponse> update(ValueRange request, core.String spreadsheetId, core.String range, {core.String responseValueRenderOption, core.String valueInputOption, core.String responseDateTimeRenderOption, core.bool includeValuesInResponse}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (spreadsheetId == null) {
       throw new core.ArgumentError("Parameter spreadsheetId is required.");
     }
     if (range == null) {
       throw new core.ArgumentError("Parameter range is required.");
     }
+    if (responseValueRenderOption != null) {
+      _queryParams["responseValueRenderOption"] = [responseValueRenderOption];
+    }
     if (valueInputOption != null) {
       _queryParams["valueInputOption"] = [valueInputOption];
     }
+    if (responseDateTimeRenderOption != null) {
+      _queryParams["responseDateTimeRenderOption"] = [responseDateTimeRenderOption];
+    }
+    if (includeValuesInResponse != null) {
+      _queryParams["includeValuesInResponse"] = ["${includeValuesInResponse}"];
+    }
 
     _url = 'v4/spreadsheets/' + commons.Escaper.ecapeVariable('$spreadsheetId') + '/values/' + commons.Escaper.ecapeVariable('$range');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 1074 matching lines @@
     }
     if (valueRanges != null) {
       _json["valueRanges"] = valueRanges.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** The request for updating any aspect of a spreadsheet. */
 class BatchUpdateSpreadsheetRequest {
+  /**
+   * Determines if the update response should include the spreadsheet
+   * resource.
+   */
+  core.bool includeSpreadsheetInResponse;
   /** A list of updates to apply to the spreadsheet. */
   core.List<Request> requests;
+  /**
+   * True if grid data should be returned. Meaningful only if
+   * if include_spreadsheet_response is 'true'.
+   * This parameter is ignored if a field mask was set in the request.
+   */
+  core.bool responseIncludeGridData;
+  /**
+   * Limits the ranges included in the response spreadsheet.
+   * Meaningful only if include_spreadsheet_response is 'true'.
+   */
+  core.List<core.String> responseRanges;
 
   BatchUpdateSpreadsheetRequest();
 
   BatchUpdateSpreadsheetRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("includeSpreadsheetInResponse")) {
+      includeSpreadsheetInResponse = _json["includeSpreadsheetInResponse"];
+    }
     if (_json.containsKey("requests")) {
       requests = _json["requests"].map((value) => new Request.fromJson(value)).toList();
     }
+    if (_json.containsKey("responseIncludeGridData")) {
+      responseIncludeGridData = _json["responseIncludeGridData"];
+    }
+    if (_json.containsKey("responseRanges")) {
+      responseRanges = _json["responseRanges"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (includeSpreadsheetInResponse != null) {
+      _json["includeSpreadsheetInResponse"] = includeSpreadsheetInResponse;
+    }
     if (requests != null) {
       _json["requests"] = requests.map((value) => (value).toJson()).toList();
     }
+    if (responseIncludeGridData != null) {
+      _json["responseIncludeGridData"] = responseIncludeGridData;
+    }
+    if (responseRanges != null) {
+      _json["responseRanges"] = responseRanges;
+    }
     return _json;
   }
 }
 
 /** The reply for batch updating a spreadsheet. */
 class BatchUpdateSpreadsheetResponse {
   /**
    * The reply of the updates.  This maps 1:1 with the updates, although
    * replies to some requests may be empty.
    */
   core.List<Response> replies;
   /** The spreadsheet the updates were applied to. */
   core.String spreadsheetId;
+  /**
+   * The spreadsheet after updates were applied. This is only set if
+   * [BatchUpdateSpreadsheetRequest.include_spreadsheet_in_response] is `true`.
+   */
+  Spreadsheet updatedSpreadsheet;
 
   BatchUpdateSpreadsheetResponse();
 
   BatchUpdateSpreadsheetResponse.fromJson(core.Map _json) {
     if (_json.containsKey("replies")) {
       replies = _json["replies"].map((value) => new Response.fromJson(value)).toList();
     }
     if (_json.containsKey("spreadsheetId")) {
       spreadsheetId = _json["spreadsheetId"];
     }
+    if (_json.containsKey("updatedSpreadsheet")) {
+      updatedSpreadsheet = new Spreadsheet.fromJson(_json["updatedSpreadsheet"]);
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (replies != null) {
       _json["replies"] = replies.map((value) => (value).toJson()).toList();
     }
     if (spreadsheetId != null) {
       _json["spreadsheetId"] = spreadsheetId;
     }
+    if (updatedSpreadsheet != null) {
+      _json["updatedSpreadsheet"] = (updatedSpreadsheet).toJson();
+    }
     return _json;
   }
 }
 
 /** The request for updating more than one range of values in a spreadsheet. */
 class BatchUpdateValuesRequest {
   /** The new values to apply to the spreadsheet. */
   core.List<ValueRange> data;
   /**
+   * Determines if the update response should include the values
+   * of the cells that were updated. By default, responses
+   * do not include the updated values. The `updatedData` field within
+   * each of the BatchUpdateValuesResponse.responses will contain
+   * the updated values. If the range to write was larger than than the range
+   * actually written, the response will include all values in the requested
+   * range (excluding trailing empty rows and columns).
+   */
+  core.bool includeValuesInResponse;
+  /**
+   * Determines how dates, times, and durations in the response should be
+   * rendered. This is ignored if response_value_render_option is
+   * FORMATTED_VALUE.
+   * The default dateTime render option is [DateTimeRenderOption.SERIAL_NUMBER].
+   * Possible string values are:
+   * - "SERIAL_NUMBER" : Instructs date, time, datetime, and duration fields to
+   * be output
+   * as doubles in "serial number" format, as popularized by Lotus 1-2-3.
+   * Days are counted from December 31st 1899 and are incremented by 1,
+   * and times are fractions of a day.  For example, January 1st 1900 at noon
+   * would be 1.5, 1 because it's 1 day offset from December 31st 1899,
+   * and .5 because noon is half a day.  February 1st 1900 at 3pm would
+   * be 32.625. This correctly treats the year 1900 as not a leap year.
+   * - "FORMATTED_STRING" : Instructs date, time, datetime, and duration fields
+   * to be output
+   * as strings in their given number format (which is dependent
+   * on the spreadsheet locale).
+   */
+  core.String responseDateTimeRenderOption;
+  /**
+   * Determines how values in the response should be rendered.
+   * The default render option is ValueRenderOption.FORMATTED_VALUE.
+   * Possible string values are:
+   * - "FORMATTED_VALUE" : Values will be calculated & formatted in the reply
+   * according to the
+   * cell's formatting.  Formatting is based on the spreadsheet's locale,
+   * not the requesting user's locale.
+   * For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency,
+   * then `A2` would return `"$1.23"`.
+   * - "UNFORMATTED_VALUE" : Values will be calculated, but not formatted in the
+   * reply.
+   * For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency,
+   * then `A2` would return the number `1.23`.
+   * - "FORMULA" : Values will not be calculated.  The reply will include the
+   * formulas.
+   * For example, if `A1` is `1.23` and `A2` is `=A1` and formatted as currency,
+   * then A2 would return `"=A1"`.
+   */
+  core.String responseValueRenderOption;
+  /**
    * How the input data should be interpreted.
    * Possible string values are:
    * - "INPUT_VALUE_OPTION_UNSPECIFIED" : Default input value. This value must
    * not be used.
    * - "RAW" : The values the user has entered will not be parsed and will be
    * stored
    * as-is.
    * - "USER_ENTERED" : The values will be parsed as if the user typed them into
    * the UI.
    * Numbers will stay as numbers, but strings may be converted to numbers,
    * dates, etc. following the same rules that are applied when entering
    * text into a cell via the Google Sheets UI.
    */
   core.String valueInputOption;
 
   BatchUpdateValuesRequest();
 
   BatchUpdateValuesRequest.fromJson(core.Map _json) {
     if (_json.containsKey("data")) {
       data = _json["data"].map((value) => new ValueRange.fromJson(value)).toList();
     }
+    if (_json.containsKey("includeValuesInResponse")) {
+      includeValuesInResponse = _json["includeValuesInResponse"];
+    }
+    if (_json.containsKey("responseDateTimeRenderOption")) {
+      responseDateTimeRenderOption = _json["responseDateTimeRenderOption"];
+    }
+    if (_json.containsKey("responseValueRenderOption")) {
+      responseValueRenderOption = _json["responseValueRenderOption"];
+    }
     if (_json.containsKey("valueInputOption")) {
       valueInputOption = _json["valueInputOption"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (data != null) {
       _json["data"] = data.map((value) => (value).toJson()).toList();
     }
+    if (includeValuesInResponse != null) {
+      _json["includeValuesInResponse"] = includeValuesInResponse;
+    }
+    if (responseDateTimeRenderOption != null) {
+      _json["responseDateTimeRenderOption"] = responseDateTimeRenderOption;
+    }
+    if (responseValueRenderOption != null) {
+      _json["responseValueRenderOption"] = responseValueRenderOption;
+    }
     if (valueInputOption != null) {
       _json["valueInputOption"] = valueInputOption;
     }
     return _json;
   }
 }
 
 /** The response when updating a range of values in a spreadsheet. */
 class BatchUpdateValuesResponse {
   /**
@@ skipping 4242 matching lines @@
    * this field will be absent.)
    * When writing it is an error to set any grid properties on non-grid sheets.
    */
   GridProperties gridProperties;
   /** True if the sheet is hidden in the UI, false if it's visible. */
   core.bool hidden;
   /**
    * The index of the sheet within the spreadsheet.
    * When adding or updating sheet properties, if this field
    * is excluded then the sheet will be added or moved to the end
-   * of the sheet list.
+   * of the sheet list. When updating sheet indices or inserting
+   * sheets, movement is considered in "before the move" indexes.
+   * For example, if there were 3 sheets (S1, S2, S3) in order to
+   * move S1 ahead of S2 the index would have to be set to 2. A sheet
+   * index update request will be ignored if the requested index is
+   * identical to the sheets current index or if the requested new
+   * index is equal to the current sheet index + 1.
    */
   core.int index;
   /** True if the sheet is an RTL sheet instead of an LTR sheet. */
   core.bool rightToLeft;
   /**
    * The ID of the sheet. Must be non-negative.
    * This field cannot be changed once set.
    */
   core.int sheetId;
   /**
@@ skipping 194 matching lines @@
   core.List<NamedRange> namedRanges;
   /** Overall properties of a spreadsheet. */
   SpreadsheetProperties properties;
   /** The sheets that are part of a spreadsheet. */
   core.List<Sheet> sheets;
   /**
    * The ID of the spreadsheet.
    * This field is read-only.
    */
   core.String spreadsheetId;
+  /**
+   * The url of the spreadsheet.
+   * This field is read-only.
+   */
+  core.String spreadsheetUrl;
 
   Spreadsheet();
 
   Spreadsheet.fromJson(core.Map _json) {
     if (_json.containsKey("namedRanges")) {
       namedRanges = _json["namedRanges"].map((value) => new NamedRange.fromJson(value)).toList();
     }
     if (_json.containsKey("properties")) {
       properties = new SpreadsheetProperties.fromJson(_json["properties"]);
     }
     if (_json.containsKey("sheets")) {
       sheets = _json["sheets"].map((value) => new Sheet.fromJson(value)).toList();
     }
     if (_json.containsKey("spreadsheetId")) {
       spreadsheetId = _json["spreadsheetId"];
     }
+    if (_json.containsKey("spreadsheetUrl")) {
+      spreadsheetUrl = _json["spreadsheetUrl"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (namedRanges != null) {
       _json["namedRanges"] = namedRanges.map((value) => (value).toJson()).toList();
     }
     if (properties != null) {
       _json["properties"] = (properties).toJson();
     }
     if (sheets != null) {
       _json["sheets"] = sheets.map((value) => (value).toJson()).toList();
     }
     if (spreadsheetId != null) {
       _json["spreadsheetId"] = spreadsheetId;
     }
+    if (spreadsheetUrl != null) {
+      _json["spreadsheetUrl"] = spreadsheetUrl;
+    }
     return _json;
   }
 }
 
 /** Properties of a spreadsheet. */
 class SpreadsheetProperties {
   /**
    * The amount of time to wait before volatile functions are recalculated.
    * Possible string values are:
    * - "RECALCULATION_INTERVAL_UNSPECIFIED" : Default value. This value must not
@@ skipping 878 matching lines @@
 /** The response when updating a range of values in a spreadsheet. */
 class UpdateValuesResponse {
   /** The spreadsheet the updates were applied to. */
   core.String spreadsheetId;
   /** The number of cells updated. */
   core.int updatedCells;
   /**
    * The number of columns where at least one cell in the column was updated.
    */
   core.int updatedColumns;
+  /**
+   * The values of the cells after updates were applied.
+   * This is only included if the request's `includeValuesInResponse` field
+   * was `true`.
+   */
+  ValueRange updatedData;
   /** The range (in A1 notation) that updates were applied to. */
   core.String updatedRange;
   /** The number of rows where at least one cell in the row was updated. */
   core.int updatedRows;
 
   UpdateValuesResponse();
 
   UpdateValuesResponse.fromJson(core.Map _json) {
     if (_json.containsKey("spreadsheetId")) {
       spreadsheetId = _json["spreadsheetId"];
     }
     if (_json.containsKey("updatedCells")) {
       updatedCells = _json["updatedCells"];
     }
     if (_json.containsKey("updatedColumns")) {
       updatedColumns = _json["updatedColumns"];
     }
+    if (_json.containsKey("updatedData")) {
+      updatedData = new ValueRange.fromJson(_json["updatedData"]);
+    }
     if (_json.containsKey("updatedRange")) {
       updatedRange = _json["updatedRange"];
     }
     if (_json.containsKey("updatedRows")) {
       updatedRows = _json["updatedRows"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (spreadsheetId != null) {
       _json["spreadsheetId"] = spreadsheetId;
     }
     if (updatedCells != null) {
       _json["updatedCells"] = updatedCells;
     }
     if (updatedColumns != null) {
       _json["updatedColumns"] = updatedColumns;
     }
+    if (updatedData != null) {
+      _json["updatedData"] = (updatedData).toJson();
+    }
     if (updatedRange != null) {
       _json["updatedRange"] = updatedRange;
     }
     if (updatedRows != null) {
       _json["updatedRows"] = updatedRows;
     }
     return _json;
   }
 }
 
@@ skipping 65 matching lines @@
     }
     if (range != null) {
       _json["range"] = range;
     }
     if (values != null) {
       _json["values"] = values;
     }
     return _json;
   }
 }