Api-roll 42: 2016-11-08

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 349 matching lines @@
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AppendValuesResponse.fromJson(data));
   }
 
   /**
+   * Clears one or more ranges of values from a spreadsheet.
+   * The caller must specify the spreadsheet ID and one or more ranges.
+   * Only values are cleared -- all other properties of the cell (such as
+   * formatting, data validation, etc..) are kept.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [spreadsheetId] - The ID of the spreadsheet to update.
+   *
+   * Completes with a [BatchClearValuesResponse].
+   *
+   * 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<BatchClearValuesResponse> batchClear(BatchClearValuesRequest request, core.String spreadsheetId) {
+    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.");
+    }
+
+    _url = 'v4/spreadsheets/' + commons.Escaper.ecapeVariable('$spreadsheetId') + '/values:batchClear';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new BatchClearValuesResponse.fromJson(data));
+  }
+
+  /**
    * 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.
@@ skipping 107 matching lines @@
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new BatchUpdateValuesResponse.fromJson(data));
   }
 
   /**
+   * Clears values from a spreadsheet.
+   * The caller must specify the spreadsheet ID and range.
+   * Only values are cleared -- all other properties of the cell (such as
+   * formatting, data validation, etc..) are kept.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [spreadsheetId] - The ID of the spreadsheet to update.
+   *
+   * [range] - The A1 notation of the values to clear.
+   *
+   * Completes with a [ClearValuesResponse].
+   *
+   * 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<ClearValuesResponse> clear(ClearValuesRequest request, core.String spreadsheetId, core.String range) {
+    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.");
+    }
+
+    _url = 'v4/spreadsheets/' + commons.Escaper.ecapeVariable('$spreadsheetId') + '/values/' + commons.Escaper.ecapeVariable('$range') + ':clear';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new ClearValuesResponse.fromJson(data));
+  }
+
+  /**
    * 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.
@@ skipping 123 matching lines @@
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new UpdateValuesResponse.fromJson(data));
   }
 
 }
 
 
 
+/** Adds a new banded range to the spreadsheet. */
+class AddBandingRequest {
+  /**
+   * The banded range to add. The bandedRangeId
+   * field is optional; if one is not set, an id will be randomly generated. (It
+   * is an error to specify the ID of a range that already exists.)
+   */
+  BandedRange bandedRange;
+
+  AddBandingRequest();
+
+  AddBandingRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("bandedRange")) {
+      bandedRange = new BandedRange.fromJson(_json["bandedRange"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (bandedRange != null) {
+      _json["bandedRange"] = (bandedRange).toJson();
+    }
+    return _json;
+  }
+}
+
+/** The result of adding a banded range. */
+class AddBandingResponse {
+  /** The banded range that was added. */
+  BandedRange bandedRange;
+
+  AddBandingResponse();
+
+  AddBandingResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("bandedRange")) {
+      bandedRange = new BandedRange.fromJson(_json["bandedRange"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (bandedRange != null) {
+      _json["bandedRange"] = (bandedRange).toJson();
+    }
+    return _json;
+  }
+}
+
 /** Adds a chart to a sheet in the spreadsheet. */
 class AddChartRequest {
   /**
    * The chart that should be added to the spreadsheet, including the position
    * where it should be placed. The chartId
    * field is optional; if one is not set, an id will be randomly generated. (It
    * is an error to specify the ID of a chart that already exists.)
    */
   EmbeddedChart chart;
 
@@ skipping 473 matching lines @@
 
   core.Map toJson() {
     var _json = new core.Map();
     if (dimensions != null) {
       _json["dimensions"] = (dimensions).toJson();
     }
     return _json;
   }
 }
 
+/** A banded (alternating colors) range in a sheet. */
+class BandedRange {
+  /** The id of the banded range. */
+  core.int bandedRangeId;
+  /**
+   * Properties for column bands. These properties will be applied on a column-
+   * by-column basis throughout all the columns in the range. At least one of
+   * row_properties or column_properties must be specified.
+   */
+  BandingProperties columnProperties;
+  /** The range over which these properties are applied. */
+  GridRange range;
+  /**
+   * Properties for row bands. These properties will be applied on a row-by-row
+   * basis throughout all the rows in the range. At least one of
+   * row_properties or column_properties must be specified.
+   */
+  BandingProperties rowProperties;
+
+  BandedRange();
+
+  BandedRange.fromJson(core.Map _json) {
+    if (_json.containsKey("bandedRangeId")) {
+      bandedRangeId = _json["bandedRangeId"];
+    }
+    if (_json.containsKey("columnProperties")) {
+      columnProperties = new BandingProperties.fromJson(_json["columnProperties"]);
+    }
+    if (_json.containsKey("range")) {
+      range = new GridRange.fromJson(_json["range"]);
+    }
+    if (_json.containsKey("rowProperties")) {
+      rowProperties = new BandingProperties.fromJson(_json["rowProperties"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (bandedRangeId != null) {
+      _json["bandedRangeId"] = bandedRangeId;
+    }
+    if (columnProperties != null) {
+      _json["columnProperties"] = (columnProperties).toJson();
+    }
+    if (range != null) {
+      _json["range"] = (range).toJson();
+    }
+    if (rowProperties != null) {
+      _json["rowProperties"] = (rowProperties).toJson();
+    }
+    return _json;
+  }
+}
+
+/**
+ * Properties referring a single dimension (either row or column). If both
+ * BandedRange.row_properties and BandedRange.column_properties are
+ * set, the fill colors are applied to cells according to the following rules:
+ *
+ * * header_color and footer_color take priority over band colors.
+ * * first_band_color takes priority over second_band_color.
+ * * row_properties takes priority over column_properties.
+ *
+ * For example, the first row color takes priority over the first column
+ * color, but the first column color takes priority over the second row color.
+ * Similarly, the row header takes priority over the column header in the
+ * top left cell, but the column header takes priority over the first row
+ * color if the row header is not set.
+ */
+class BandingProperties {
+  /** The first color that is alternating. (Required) */
+  Color firstBandColor;
+  /**
+   * The color of the last row or column. If this field is not set, the last
+   * row or column will be filled with either first_row_color or
+   * second_row_color, depending on the color of the previous row or
+   * column.
+   */
+  Color footerColor;
+  /**
+   * The color of the first row or column. If this field is set, the first
+   * row or column will be filled with this color and the colors will
+   * alternate between first_band_color and [second_band_color[] starting
+   * from the second row or column. Otherwise, the first row or column will be
+   * filled with first_band_color and the colors will proceed to alternate
+   * as they normally would.
+   */
+  Color headerColor;
+  /** The second color that is alternating. (Required) */
+  Color secondBandColor;
+
+  BandingProperties();
+
+  BandingProperties.fromJson(core.Map _json) {
+    if (_json.containsKey("firstBandColor")) {
+      firstBandColor = new Color.fromJson(_json["firstBandColor"]);
+    }
+    if (_json.containsKey("footerColor")) {
+      footerColor = new Color.fromJson(_json["footerColor"]);
+    }
+    if (_json.containsKey("headerColor")) {
+      headerColor = new Color.fromJson(_json["headerColor"]);
+    }
+    if (_json.containsKey("secondBandColor")) {
+      secondBandColor = new Color.fromJson(_json["secondBandColor"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (firstBandColor != null) {
+      _json["firstBandColor"] = (firstBandColor).toJson();
+    }
+    if (footerColor != null) {
+      _json["footerColor"] = (footerColor).toJson();
+    }
+    if (headerColor != null) {
+      _json["headerColor"] = (headerColor).toJson();
+    }
+    if (secondBandColor != null) {
+      _json["secondBandColor"] = (secondBandColor).toJson();
+    }
+    return _json;
+  }
+}
+
 /**
  * An axis of the chart.
  * A chart may not have more than one axis per
  * axis position.
  */
 class BasicChartAxis {
   /**
    * The format of the title.
    * Only valid if the axis is not associated with the domain.
    */
@@ skipping 296 matching lines @@
     if (range != null) {
       _json["range"] = (range).toJson();
     }
     if (sortSpecs != null) {
       _json["sortSpecs"] = sortSpecs.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
+/** The request for clearing more than one range of values in a spreadsheet. */
+class BatchClearValuesRequest {
+  /** The ranges to clear, in A1 notation. */
+  core.List<core.String> ranges;
+
+  BatchClearValuesRequest();
+
+  BatchClearValuesRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("ranges")) {
+      ranges = _json["ranges"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (ranges != null) {
+      _json["ranges"] = ranges;
+    }
+    return _json;
+  }
+}
+
+/** The response when updating a range of values in a spreadsheet. */
+class BatchClearValuesResponse {
+  /**
+   * The ranges that were cleared, in A1 notation.
+   * (If the requests were for an unbounded range or a ranger larger
+   *  than the bounds of the sheet, this will be the actual ranges
+   *  that were cleared, bounded to the sheet's limits.)
+   */
+  core.List<core.String> clearedRanges;
+  /** The spreadsheet the updates were applied to. */
+  core.String spreadsheetId;
+
+  BatchClearValuesResponse();
+
+  BatchClearValuesResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("clearedRanges")) {
+      clearedRanges = _json["clearedRanges"];
+    }
+    if (_json.containsKey("spreadsheetId")) {
+      spreadsheetId = _json["spreadsheetId"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (clearedRanges != null) {
+      _json["clearedRanges"] = clearedRanges;
+    }
+    if (spreadsheetId != null) {
+      _json["spreadsheetId"] = spreadsheetId;
+    }
+    return _json;
+  }
+}
+
 /**
  * The response when retrieving more than one range of values in a spreadsheet.
  */
 class BatchGetValuesResponse {
   /** The ID of the spreadsheet the data was retrieved from. */
   core.String spreadsheetId;
   /**
    * The requested values. The order of the ValueRanges is the same as the
    * order of the requested ranges.
    */
@@ skipping 235 matching lines @@
    * Requires exactly two ConditionValues.
    * - "TEXT_CONTAINS" : The cell's value must contain the condition's value.
    * Supported by data validation, conditional formatting and filters.
    * Requires a single ConditionValue.
    * - "TEXT_NOT_CONTAINS" : The cell's value must not contain the condition's
    * value.
    * Supported by data validation, conditional formatting and filters.
    * Requires a single ConditionValue.
    * - "TEXT_STARTS_WITH" : The cell's value must start with the condition's
    * value.
-   * Supported by data validation, conditional formatting and filters.
+   * Supported by conditional formatting and filters.
    * Requires a single ConditionValue.
    * - "TEXT_ENDS_WITH" : The cell's value must end with the condition's value.
-   * Supported by data validation, conditional formatting and filters.
+   * Supported by conditional formatting and filters.
    * Requires a single ConditionValue.
    * - "TEXT_EQ" : The cell's value must be exactly the condition's value.
    * Supported by data validation, conditional formatting and filters.
    * Requires a single ConditionValue.
    * - "TEXT_IS_EMAIL" : The cell's value must be a valid email address.
    * Supported by data validation.
    * Requires no ConditionValues.
    * - "TEXT_IS_URL" : The cell's value must be a valid URL.
    * Supported by data validation.
    * Requires no ConditionValues.
    * - "DATE_EQ" : The cell's value must be the same date as the condition's
    * value.
    * Supported by data validation, conditional formatting and filters.
    * Requires a single ConditionValue.
    * - "DATE_BEFORE" : The cell's value must be before the date of the
    * condition's value.
    * Supported by data validation, conditional formatting and filters.
    * Requires a single ConditionValue
    * that may be a relative date.
    * - "DATE_AFTER" : The cell's value must be after the date of the condition's
    * value.
    * Supported by data validation, conditional formatting and filters.
    * Requires a single ConditionValue
    * that may be a relative date.
    * - "DATE_ON_OR_BEFORE" : The cell's value must be on or before the date of
    * the condition's value.
-   * Supported by data validation, conditional formatting and filters.
+   * Supported by data validation.
    * Requires a single ConditionValue
    * that may be a relative date.
    * - "DATE_ON_OR_AFTER" : The cell's value must be on or after the date of the
    * condition's value.
-   * Supported by data validation, conditional formatting and filters.
+   * Supported by data validation.
    * Requires a single ConditionValue
    * that may be a relative date.
    * - "DATE_BETWEEN" : The cell's value must be between the dates of the two
    * condition values.
    * Supported by data validation.
    * Requires exactly two ConditionValues.
    * - "DATE_NOT_BETWEEN" : The cell's value must be outside the dates of the
    * two condition values.
    * Supported by data validation.
    * Requires exactly two ConditionValues.
    * - "DATE_IS_VALID" : The cell's value must be a date.
    * Supported by data validation.
    * Requires no ConditionValues.
    * - "ONE_OF_RANGE" : The cell's value must be listed in the grid in condition
    * value's range.
    * Supported by data validation.
    * Requires a single ConditionValue,
    * and the value must be a valid range in A1 notation.
    * - "ONE_OF_LIST" : The cell's value must in the list of condition values.
    * Supported by data validation.
    * Supports any number of condition values,
    * one per item in the list.
    * Formulas are not supported in the values.
    * - "BLANK" : The cell's value must be empty.
-   * Supported by data validation, conditional formatting and filters.
+   * Supported by conditional formatting and filters.
    * Requires no ConditionValues.
    * - "NOT_BLANK" : The cell's value must not be empty.
-   * Supported by data validation, conditional formatting and filters.
+   * Supported by conditional formatting and filters.
    * Requires no ConditionValues.
    * - "CUSTOM_FORMULA" : The condition's formula must evaluate to true.
    * Supported by data validation, conditional formatting and filters.
    * Requires a single ConditionValue.
    */
   core.String type;
   /**
    * The values of the condition. The number of supported values depends
    * on the condition type.  Some support zero values,
    * others one or two values,
@@ skipping 67 matching lines @@
 /** A border along a cell. */
 class Border {
   /** The color of the border. */
   Color color;
   /**
    * The style of the border.
    * Possible string values are:
    * - "STYLE_UNSPECIFIED" : The style is not specified. Do not use this.
    * - "DOTTED" : The border is dotted.
    * - "DASHED" : The border is dashed.
-   * - "SOLID" : The border is a solid line.
+   * - "SOLID" : The border is a thin solid line.
+   * - "SOLID_MEDIUM" : The border is a medium solid line.
+   * - "SOLID_THICK" : The border is a thick solid line.
    * - "NONE" : No border.
    * Used only when updating a border in order to erase it.
    * - "DOUBLE" : The border is two solid lines.
    */
   core.String style;
   /**
    * The width of the border, in pixels.
-   * Border widths must be between 0 and 3 pixels, inclusive.
+   * Deprecated; the width is determined by the "style" field.
    */
   core.int width;
 
   Border();
 
   Border.fromJson(core.Map _json) {
     if (_json.containsKey("color")) {
       color = new Color.fromJson(_json["color"]);
     }
     if (_json.containsKey("style")) {
@@ skipping 512 matching lines @@
 
   core.Map toJson() {
     var _json = new core.Map();
     if (sheetId != null) {
       _json["sheetId"] = sheetId;
     }
     return _json;
   }
 }
 
+/** The request for clearing a range of values in a spreadsheet. */
+class ClearValuesRequest {
+
+  ClearValuesRequest();
+
+  ClearValuesRequest.fromJson(core.Map _json) {
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    return _json;
+  }
+}
+
+/** The response when clearing a range of values in a spreadsheet. */
+class ClearValuesResponse {
+  /**
+   * The range (in A1 notation) that was cleared.
+   * (If the request was for an unbounded range or a ranger larger
+   *  than the bounds of the sheet, this will be the actual range
+   *  that was cleared, bounded to the sheet's limits.)
+   */
+  core.String clearedRange;
+  /** The spreadsheet the updates were applied to. */
+  core.String spreadsheetId;
+
+  ClearValuesResponse();
+
+  ClearValuesResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("clearedRange")) {
+      clearedRange = _json["clearedRange"];
+    }
+    if (_json.containsKey("spreadsheetId")) {
+      spreadsheetId = _json["spreadsheetId"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (clearedRange != null) {
+      _json["clearedRange"] = clearedRange;
+    }
+    if (spreadsheetId != null) {
+      _json["spreadsheetId"] = spreadsheetId;
+    }
+    return _json;
+  }
+}
+
 /**
  * Represents a color in the RGBA color space. This representation is designed
  * for simplicity of conversion to/from color representations in various
  * languages over compactness; for example, the fields of this representation
  * can be trivially provided to the constructor of "java.awt.Color" in Java; it
  * can also be trivially provided to UIColor's "+colorWithRed:green:blue:alpha"
  * method in iOS; and, with just a little work, it can be easily formatted into
  * a CSS "rgba()" string in JavaScript, as well. Here are some examples:
  *
  * Example (Java):
@@ skipping 439 matching lines @@
     if (showCustomUi != null) {
       _json["showCustomUi"] = showCustomUi;
     }
     if (strict != null) {
       _json["strict"] = strict;
     }
     return _json;
   }
 }
 
+/** Removes the banded range with the given ID from the spreadsheet. */
+class DeleteBandingRequest {
+  /** The ID of the banded range to delete. */
+  core.int bandedRangeId;
+
+  DeleteBandingRequest();
+
+  DeleteBandingRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("bandedRangeId")) {
+      bandedRangeId = _json["bandedRangeId"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (bandedRangeId != null) {
+      _json["bandedRangeId"] = bandedRangeId;
+    }
+    return _json;
+  }
+}
+
 /**
  * Deletes a conditional format rule at the given index.
  * All subsequent rules' indexes are decremented.
  */
 class DeleteConditionalFormatRuleRequest {
   /** The zero-based index of the rule to be deleted. */
   core.int index;
   /** The sheet the rule is being deleted from. */
   core.int sheetId;
 
@@ skipping 1412 matching lines @@
     }
     return _json;
   }
 }
 
 /** The number format of a cell. */
 class NumberFormat {
   /**
    * Pattern string used for formatting.  If not set, a default pattern based on
    * the user's locale will be used if necessary for the given type.
+   * See the [Date and Number Formats guide](/sheets/guides/formats) for more
+   * information about the supported patterns.
    */
   core.String pattern;
   /**
    * The type of the number format.
    * When writing, this field must be set.
    * Possible string values are:
    * - "NUMBER_FORMAT_TYPE_UNSPECIFIED" : The number format is not specified
    * and is based on the contents of the cell.
    * Do not explicitly use this.
    * - "TEXT" : Text formatting, e.g `1000.12`
@@ skipping 764 matching lines @@
     }
     if (range != null) {
       _json["range"] = (range).toJson();
     }
     return _json;
   }
 }
 
 /** A single kind of update to apply to a spreadsheet. */
 class Request {
+  /** Adds a new banded range */
+  AddBandingRequest addBanding;
   /** Adds a chart. */
   AddChartRequest addChart;
   /** Adds a new conditional format rule. */
   AddConditionalFormatRuleRequest addConditionalFormatRule;
   /** Adds a filter view. */
   AddFilterViewRequest addFilterView;
   /** Adds a named range. */
   AddNamedRangeRequest addNamedRange;
   /** Adds a protected range. */
   AddProtectedRangeRequest addProtectedRange;
   /** Adds a sheet. */
   AddSheetRequest addSheet;
   /** Appends cells after the last row with data in a sheet. */
   AppendCellsRequest appendCells;
   /** Appends dimensions to the end of a sheet. */
   AppendDimensionRequest appendDimension;
   /** Automatically fills in more data based on existing data. */
   AutoFillRequest autoFill;
   /**
    * Automatically resizes one or more dimensions based on the contents
    * of the cells in that dimension.
    */
   AutoResizeDimensionsRequest autoResizeDimensions;
   /** Clears the basic filter on a sheet. */
   ClearBasicFilterRequest clearBasicFilter;
   /** Copies data from one area and pastes it to another. */
   CopyPasteRequest copyPaste;
   /** Cuts data from one area and pastes it to another. */
   CutPasteRequest cutPaste;
+  /** Removes a banded range */
+  DeleteBandingRequest deleteBanding;
   /** Deletes an existing conditional format rule. */
   DeleteConditionalFormatRuleRequest deleteConditionalFormatRule;
   /** Deletes rows or columns in a sheet. */
   DeleteDimensionRequest deleteDimension;
   /** Deletes an embedded object (e.g, chart, image) in a sheet. */
   DeleteEmbeddedObjectRequest deleteEmbeddedObject;
   /** Deletes a filter view from a sheet. */
   DeleteFilterViewRequest deleteFilterView;
   /** Deletes a named range. */
   DeleteNamedRangeRequest deleteNamedRange;
@@ skipping 20 matching lines @@
   /** Sets the basic filter on a sheet. */
   SetBasicFilterRequest setBasicFilter;
   /** Sets data validation for one or more cells. */
   SetDataValidationRequest setDataValidation;
   /** Sorts data in a range. */
   SortRangeRequest sortRange;
   /** Converts a column of text into many columns of text. */
   TextToColumnsRequest textToColumns;
   /** Unmerges merged cells. */
   UnmergeCellsRequest unmergeCells;
+  /** Updates a banded range */
+  UpdateBandingRequest updateBanding;
   /** Updates the borders in a range of cells. */
   UpdateBordersRequest updateBorders;
   /** Updates many cells at once. */
   UpdateCellsRequest updateCells;
   /** Updates a chart's specifications. */
   UpdateChartSpecRequest updateChartSpec;
   /** Updates an existing conditional format rule. */
   UpdateConditionalFormatRuleRequest updateConditionalFormatRule;
   /** Updates dimensions' properties. */
   UpdateDimensionPropertiesRequest updateDimensionProperties;
   /** Updates an embedded object's (e.g. chart, image) position. */
   UpdateEmbeddedObjectPositionRequest updateEmbeddedObjectPosition;
   /** Updates the properties of a filter view. */
   UpdateFilterViewRequest updateFilterView;
   /** Updates a named range. */
   UpdateNamedRangeRequest updateNamedRange;
   /** Updates a protected range. */
   UpdateProtectedRangeRequest updateProtectedRange;
   /** Updates a sheet's properties. */
   UpdateSheetPropertiesRequest updateSheetProperties;
   /** Updates the spreadsheet's properties. */
   UpdateSpreadsheetPropertiesRequest updateSpreadsheetProperties;
 
   Request();
 
   Request.fromJson(core.Map _json) {
+    if (_json.containsKey("addBanding")) {
+      addBanding = new AddBandingRequest.fromJson(_json["addBanding"]);
+    }
     if (_json.containsKey("addChart")) {
       addChart = new AddChartRequest.fromJson(_json["addChart"]);
     }
     if (_json.containsKey("addConditionalFormatRule")) {
       addConditionalFormatRule = new AddConditionalFormatRuleRequest.fromJson(_json["addConditionalFormatRule"]);
     }
     if (_json.containsKey("addFilterView")) {
       addFilterView = new AddFilterViewRequest.fromJson(_json["addFilterView"]);
     }
     if (_json.containsKey("addNamedRange")) {
@@ skipping 19 matching lines @@
     }
     if (_json.containsKey("clearBasicFilter")) {
       clearBasicFilter = new ClearBasicFilterRequest.fromJson(_json["clearBasicFilter"]);
     }
     if (_json.containsKey("copyPaste")) {
       copyPaste = new CopyPasteRequest.fromJson(_json["copyPaste"]);
     }
     if (_json.containsKey("cutPaste")) {
       cutPaste = new CutPasteRequest.fromJson(_json["cutPaste"]);
     }
+    if (_json.containsKey("deleteBanding")) {
+      deleteBanding = new DeleteBandingRequest.fromJson(_json["deleteBanding"]);
+    }
     if (_json.containsKey("deleteConditionalFormatRule")) {
       deleteConditionalFormatRule = new DeleteConditionalFormatRuleRequest.fromJson(_json["deleteConditionalFormatRule"]);
     }
     if (_json.containsKey("deleteDimension")) {
       deleteDimension = new DeleteDimensionRequest.fromJson(_json["deleteDimension"]);
     }
     if (_json.containsKey("deleteEmbeddedObject")) {
       deleteEmbeddedObject = new DeleteEmbeddedObjectRequest.fromJson(_json["deleteEmbeddedObject"]);
     }
     if (_json.containsKey("deleteFilterView")) {
@@ skipping 40 matching lines @@
     }
     if (_json.containsKey("sortRange")) {
       sortRange = new SortRangeRequest.fromJson(_json["sortRange"]);
     }
     if (_json.containsKey("textToColumns")) {
       textToColumns = new TextToColumnsRequest.fromJson(_json["textToColumns"]);
     }
     if (_json.containsKey("unmergeCells")) {
       unmergeCells = new UnmergeCellsRequest.fromJson(_json["unmergeCells"]);
     }
+    if (_json.containsKey("updateBanding")) {
+      updateBanding = new UpdateBandingRequest.fromJson(_json["updateBanding"]);
+    }
     if (_json.containsKey("updateBorders")) {
       updateBorders = new UpdateBordersRequest.fromJson(_json["updateBorders"]);
     }
     if (_json.containsKey("updateCells")) {
       updateCells = new UpdateCellsRequest.fromJson(_json["updateCells"]);
     }
     if (_json.containsKey("updateChartSpec")) {
       updateChartSpec = new UpdateChartSpecRequest.fromJson(_json["updateChartSpec"]);
     }
     if (_json.containsKey("updateConditionalFormatRule")) {
@@ skipping 17 matching lines @@
     if (_json.containsKey("updateSheetProperties")) {
       updateSheetProperties = new UpdateSheetPropertiesRequest.fromJson(_json["updateSheetProperties"]);
     }
     if (_json.containsKey("updateSpreadsheetProperties")) {
       updateSpreadsheetProperties = new UpdateSpreadsheetPropertiesRequest.fromJson(_json["updateSpreadsheetProperties"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (addBanding != null) {
+      _json["addBanding"] = (addBanding).toJson();
+    }
     if (addChart != null) {
       _json["addChart"] = (addChart).toJson();
     }
     if (addConditionalFormatRule != null) {
       _json["addConditionalFormatRule"] = (addConditionalFormatRule).toJson();
     }
     if (addFilterView != null) {
       _json["addFilterView"] = (addFilterView).toJson();
     }
     if (addNamedRange != null) {
@@ skipping 19 matching lines @@
     }
     if (clearBasicFilter != null) {
       _json["clearBasicFilter"] = (clearBasicFilter).toJson();
     }
     if (copyPaste != null) {
       _json["copyPaste"] = (copyPaste).toJson();
     }
     if (cutPaste != null) {
       _json["cutPaste"] = (cutPaste).toJson();
     }
+    if (deleteBanding != null) {
+      _json["deleteBanding"] = (deleteBanding).toJson();
+    }
     if (deleteConditionalFormatRule != null) {
       _json["deleteConditionalFormatRule"] = (deleteConditionalFormatRule).toJson();
     }
     if (deleteDimension != null) {
       _json["deleteDimension"] = (deleteDimension).toJson();
     }
     if (deleteEmbeddedObject != null) {
       _json["deleteEmbeddedObject"] = (deleteEmbeddedObject).toJson();
     }
     if (deleteFilterView != null) {
@@ skipping 40 matching lines @@
     }
     if (sortRange != null) {
       _json["sortRange"] = (sortRange).toJson();
     }
     if (textToColumns != null) {
       _json["textToColumns"] = (textToColumns).toJson();
     }
     if (unmergeCells != null) {
       _json["unmergeCells"] = (unmergeCells).toJson();
     }
+    if (updateBanding != null) {
+      _json["updateBanding"] = (updateBanding).toJson();
+    }
     if (updateBorders != null) {
       _json["updateBorders"] = (updateBorders).toJson();
     }
     if (updateCells != null) {
       _json["updateCells"] = (updateCells).toJson();
     }
     if (updateChartSpec != null) {
       _json["updateChartSpec"] = (updateChartSpec).toJson();
     }
     if (updateConditionalFormatRule != null) {
@@ skipping 19 matching lines @@
     }
     if (updateSpreadsheetProperties != null) {
       _json["updateSpreadsheetProperties"] = (updateSpreadsheetProperties).toJson();
     }
     return _json;
   }
 }
 
 /** A single response from an update. */
 class Response {
+  /** A reply from adding a banded range. */
+  AddBandingResponse addBanding;
   /** A reply from adding a chart. */
   AddChartResponse addChart;
   /** A reply from adding a filter view. */
   AddFilterViewResponse addFilterView;
   /** A reply from adding a named range. */
   AddNamedRangeResponse addNamedRange;
   /** A reply from adding a protected range. */
   AddProtectedRangeResponse addProtectedRange;
   /** A reply from adding a sheet. */
   AddSheetResponse addSheet;
   /** A reply from deleting a conditional format rule. */
   DeleteConditionalFormatRuleResponse deleteConditionalFormatRule;
   /** A reply from duplicating a filter view. */
   DuplicateFilterViewResponse duplicateFilterView;
   /** A reply from duplicating a sheet. */
   DuplicateSheetResponse duplicateSheet;
   /** A reply from doing a find/replace. */
   FindReplaceResponse findReplace;
   /** A reply from updating a conditional format rule. */
   UpdateConditionalFormatRuleResponse updateConditionalFormatRule;
   /** A reply from updating an embedded object's position. */
   UpdateEmbeddedObjectPositionResponse updateEmbeddedObjectPosition;
 
   Response();
 
   Response.fromJson(core.Map _json) {
+    if (_json.containsKey("addBanding")) {
+      addBanding = new AddBandingResponse.fromJson(_json["addBanding"]);
+    }
     if (_json.containsKey("addChart")) {
       addChart = new AddChartResponse.fromJson(_json["addChart"]);
     }
     if (_json.containsKey("addFilterView")) {
       addFilterView = new AddFilterViewResponse.fromJson(_json["addFilterView"]);
     }
     if (_json.containsKey("addNamedRange")) {
       addNamedRange = new AddNamedRangeResponse.fromJson(_json["addNamedRange"]);
     }
     if (_json.containsKey("addProtectedRange")) {
@@ skipping 17 matching lines @@
     if (_json.containsKey("updateConditionalFormatRule")) {
       updateConditionalFormatRule = new UpdateConditionalFormatRuleResponse.fromJson(_json["updateConditionalFormatRule"]);
     }
     if (_json.containsKey("updateEmbeddedObjectPosition")) {
       updateEmbeddedObjectPosition = new UpdateEmbeddedObjectPositionResponse.fromJson(_json["updateEmbeddedObjectPosition"]);
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (addBanding != null) {
+      _json["addBanding"] = (addBanding).toJson();
+    }
     if (addChart != null) {
       _json["addChart"] = (addChart).toJson();
     }
     if (addFilterView != null) {
       _json["addFilterView"] = (addFilterView).toJson();
     }
     if (addNamedRange != null) {
       _json["addNamedRange"] = (addNamedRange).toJson();
     }
     if (addProtectedRange != null) {
@@ skipping 99 matching lines @@
     }
     if (rule != null) {
       _json["rule"] = (rule).toJson();
     }
     return _json;
   }
 }
 
 /** A sheet in a spreadsheet. */
 class Sheet {
+  /** The banded (i.e. alternating colors) ranges on this sheet. */
+  core.List<BandedRange> bandedRanges;
   /** The filter on this sheet, if any. */
   BasicFilter basicFilter;
   /** The specifications of every chart on this sheet. */
   core.List<EmbeddedChart> charts;
   /** The conditional format rules in this sheet. */
   core.List<ConditionalFormatRule> conditionalFormats;
   /**
    * Data in the grid, if this is a grid sheet.
    * The number of GridData objects returned is dependent on the number of
    * ranges requested on this sheet. For example, if this is representing
    * `Sheet1`, and the spreadsheet was requested with ranges
    * `Sheet1!A1:C10` and `Sheet1!D15:E20`, then the first GridData will have a
    * startRow/startColumn of `0`,
    * while the second one will have `startRow 14` (zero-based row 15),
    * and `startColumn 3` (zero-based column D).
    */
   core.List<GridData> data;
   /** The filter views in this sheet. */
   core.List<FilterView> filterViews;
   /** The ranges that are merged together. */
   core.List<GridRange> merges;
   /** The properties of the sheet. */
   SheetProperties properties;
   /** The protected ranges in this sheet. */
   core.List<ProtectedRange> protectedRanges;
 
   Sheet();
 
   Sheet.fromJson(core.Map _json) {
+    if (_json.containsKey("bandedRanges")) {
+      bandedRanges = _json["bandedRanges"].map((value) => new BandedRange.fromJson(value)).toList();
+    }
     if (_json.containsKey("basicFilter")) {
       basicFilter = new BasicFilter.fromJson(_json["basicFilter"]);
     }
     if (_json.containsKey("charts")) {
       charts = _json["charts"].map((value) => new EmbeddedChart.fromJson(value)).toList();
     }
     if (_json.containsKey("conditionalFormats")) {
       conditionalFormats = _json["conditionalFormats"].map((value) => new ConditionalFormatRule.fromJson(value)).toList();
     }
     if (_json.containsKey("data")) {
       data = _json["data"].map((value) => new GridData.fromJson(value)).toList();
     }
     if (_json.containsKey("filterViews")) {
       filterViews = _json["filterViews"].map((value) => new FilterView.fromJson(value)).toList();
     }
     if (_json.containsKey("merges")) {
       merges = _json["merges"].map((value) => new GridRange.fromJson(value)).toList();
     }
     if (_json.containsKey("properties")) {
       properties = new SheetProperties.fromJson(_json["properties"]);
     }
     if (_json.containsKey("protectedRanges")) {
       protectedRanges = _json["protectedRanges"].map((value) => new ProtectedRange.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
+    if (bandedRanges != null) {
+      _json["bandedRanges"] = bandedRanges.map((value) => (value).toJson()).toList();
+    }
     if (basicFilter != null) {
       _json["basicFilter"] = (basicFilter).toJson();
     }
     if (charts != null) {
       _json["charts"] = charts.map((value) => (value).toJson()).toList();
     }
     if (conditionalFormats != null) {
       _json["conditionalFormats"] = conditionalFormats.map((value) => (value).toJson()).toList();
     }
     if (data != null) {
@@ skipping 543 matching lines @@
 
   core.Map toJson() {
     var _json = new core.Map();
     if (range != null) {
       _json["range"] = (range).toJson();
     }
     return _json;
   }
 }
 
+/** Updates properties of the supplied banded range. */
+class UpdateBandingRequest {
+  /** The banded range to update with the new properties. */
+  BandedRange bandedRange;
+  /**
+   * The fields that should be updated.  At least one field must be specified.
+   * The root `bandedRange` is implied and should not be specified.
+   * A single `"*"` can be used as short-hand for listing every field.
+   */
+  core.String fields;
+
+  UpdateBandingRequest();
+
+  UpdateBandingRequest.fromJson(core.Map _json) {
+    if (_json.containsKey("bandedRange")) {
+      bandedRange = new BandedRange.fromJson(_json["bandedRange"]);
+    }
+    if (_json.containsKey("fields")) {
+      fields = _json["fields"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (bandedRange != null) {
+      _json["bandedRange"] = (bandedRange).toJson();
+    }
+    if (fields != null) {
+      _json["fields"] = fields;
+    }
+    return _json;
+  }
+}
+
 /**
  * Updates the borders of a range.
  * If a field is not set in the request, that means the border remains as-is.
  * For example, with two subsequent UpdateBordersRequest:
  *
  *  1. range: A1:A5 `{ top: RED, bottom: WHITE }`
  *  2. range: A1:A5 `{ left: BLUE }`
  *
  * That would result in A1:A5 having a borders of
  * `{ top: RED, bottom: WHITE, left: BLUE }`.
@@ skipping 692 matching lines @@
     }
     if (range != null) {
       _json["range"] = range;
     }
     if (values != null) {
       _json["values"] = values;
     }
     return _json;
   }
 }