Api-roll 47: 2017-03-27

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 273 matching lines @@
   final commons.ApiRequester _requester;
 
   SpreadsheetsValuesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Appends values to a spreadsheet. The input range is used to search for
    * existing data and find a "table" within that range. Values will be
    * appended to the next row of the table, starting with the first column of
    * the table. See the
-   * [guide](/sheets/guides/values#appending_values)
+   * [guide](/sheets/api/guides/values#appending_values)
    * and
-   * [sample code](/sheets/samples/writing#append_values)
+   * [sample code](/sheets/api/samples/writing#append_values)
    * for specific details of how tables are detected and data is appended.
    *
    * The caller must specify the spreadsheet ID, range, and
    * a valueInputOption.  The `valueInputOption` only
    * controls how the input data will be added to the sheet (column-wise or
    * row-wise), it does not influence what cell the data starts being written
    * to.
    *
    * [request] - The metadata request object.
    *
@@ skipping 138 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.
-   *
-   * [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
-   * `[[1,3],[2,4]]`.
-   * Possible string values are:
-   * - "DIMENSION_UNSPECIFIED" : A DIMENSION_UNSPECIFIED.
-   * - "ROWS" : A ROWS.
-   * - "COLUMNS" : A COLUMNS.
-   *
    * [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.
    *
+   * [ranges] - The A1 notation of the values to retrieve.
+   *
+   * [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
+   * `[[1,3],[2,4]]`.
+   * Possible string values are:
+   * - "DIMENSION_UNSPECIFIED" : A DIMENSION_UNSPECIFIED.
+   * - "ROWS" : A ROWS.
+   * - "COLUMNS" : A COLUMNS.
+   *
    * Completes with a [BatchGetValuesResponse].
    *
    * 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<BatchGetValuesResponse> batchGet(core.String spreadsheetId, {core.List<core.String> ranges, core.String majorDimension, core.String valueRenderOption, core.String dateTimeRenderOption}) {
+  async.Future<BatchGetValuesResponse> batchGet(core.String spreadsheetId, {core.String valueRenderOption, core.String dateTimeRenderOption, core.List<core.String> ranges, core.String majorDimension}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (spreadsheetId == null) {
       throw new core.ArgumentError("Parameter spreadsheetId is required.");
     }
+    if (valueRenderOption != null) {
+      _queryParams["valueRenderOption"] = [valueRenderOption];
+    }
+    if (dateTimeRenderOption != null) {
+      _queryParams["dateTimeRenderOption"] = [dateTimeRenderOption];
+    }
     if (ranges != null) {
       _queryParams["ranges"] = ranges;
     }
     if (majorDimension != null) {
       _queryParams["majorDimension"] = [majorDimension];
     }
-    if (valueRenderOption != null) {
-      _queryParams["valueRenderOption"] = [valueRenderOption];
-    }
-    if (dateTimeRenderOption != null) {
-      _queryParams["dateTimeRenderOption"] = [dateTimeRenderOption];
-    }
 
     _url = 'v4/spreadsheets/' + commons.Escaper.ecapeVariable('$spreadsheetId') + '/values:batchGet';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 1470 matching lines @@
   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.
+   * The whole number portion of the value (left of the decimal) counts
+   * the days since December 30th 1899. The fractional portion (right of
+   * the decimal) counts the time as a fraction of the day. For example,
+   * January 1st 1900 at noon would be 2.5, 2 because it's 2 days after
+   * December 30st 1899, and .5 because noon is half a day.  February 1st
+   * 1900 at 3pm would be 33.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:
@@ skipping 612 matching lines @@
    * - "LEFT_TO_RIGHT" : The text direction of left-to-right was set by the
    * user.
    * - "RIGHT_TO_LEFT" : The text direction of right-to-left was set by the
    * user.
    */
   core.String textDirection;
   /**
    * The format of the text in the cell (unless overridden by a format run).
    */
   TextFormat textFormat;
+  /** The rotation applied to text in a cell */
+  TextRotation textRotation;
   /**
    * The vertical alignment of the value in the cell.
    * Possible string values are:
    * - "VERTICAL_ALIGN_UNSPECIFIED" : The vertical alignment is not specified.
    * Do not use this.
    * - "TOP" : The text is explicitly aligned to the top of the cell.
    * - "MIDDLE" : The text is explicitly aligned to the middle of the cell.
    * - "BOTTOM" : The text is explicitly aligned to the bottom of the cell.
    */
   core.String verticalAlignment;
@@ skipping 59 matching lines @@
     }
     if (_json.containsKey("padding")) {
       padding = new Padding.fromJson(_json["padding"]);
     }
     if (_json.containsKey("textDirection")) {
       textDirection = _json["textDirection"];
     }
     if (_json.containsKey("textFormat")) {
       textFormat = new TextFormat.fromJson(_json["textFormat"]);
     }
+    if (_json.containsKey("textRotation")) {
+      textRotation = new TextRotation.fromJson(_json["textRotation"]);
+    }
     if (_json.containsKey("verticalAlignment")) {
       verticalAlignment = _json["verticalAlignment"];
     }
     if (_json.containsKey("wrapStrategy")) {
       wrapStrategy = _json["wrapStrategy"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
@@ skipping 14 matching lines @@
     }
     if (padding != null) {
       _json["padding"] = (padding).toJson();
     }
     if (textDirection != null) {
       _json["textDirection"] = textDirection;
     }
     if (textFormat != null) {
       _json["textFormat"] = (textFormat).toJson();
     }
+    if (textRotation != null) {
+      _json["textRotation"] = (textRotation).toJson();
+    }
     if (verticalAlignment != null) {
       _json["verticalAlignment"] = verticalAlignment;
     }
     if (wrapStrategy != null) {
       _json["wrapStrategy"] = wrapStrategy;
     }
     return _json;
   }
 }
 
@@ skipping 2057 matching lines @@
     return _json;
   }
 }
 
 /**
  * Settings to control how circular dependencies are resolved with iterative
  * calculation.
  */
 class IterativeCalculationSettings {
   /**
-   * When iterative calculation is enabled, the threshold value such that
-   * calculation rounds stop when succesive results differ by less.
+   * When iterative calculation is enabled and successive results differ by
+   * less than this threshold value, the calculation rounds stop.
    */
   core.double convergenceThreshold;
   /**
    * When iterative calculation is enabled, the maximum number of calculation
-   * rounds to perform during iterative calculation.
+   * rounds to perform.
    */
   core.int maxIterations;
 
   IterativeCalculationSettings();
 
   IterativeCalculationSettings.fromJson(core.Map _json) {
     if (_json.containsKey("convergenceThreshold")) {
       convergenceThreshold = _json["convergenceThreshold"];
     }
     if (_json.containsKey("maxIterations")) {
@@ skipping 128 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
+   * See the [Date and Number Formats guide](/sheets/api/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.
@@ skipping 1941 matching lines @@
     if (format != null) {
       _json["format"] = (format).toJson();
     }
     if (startIndex != null) {
       _json["startIndex"] = startIndex;
     }
     return _json;
   }
 }
 
+/** The rotation applied to text in a cell. */
+class TextRotation {
+  /**
+   * The angle between the standard orientation and the desired orientation.
+   * Measured in degrees. Valid values are between -90 and 90. Positive
+   * angles are angled upwards, negative are angled downwards.
+   *
+   * Note: For LTR text direction positive angles are in the counterclockwise
+   * direction, whereas for RTL they are in the clockwise direction
+   */
+  core.int angle;
+  /**
+   * If true, text reads top to bottom, but the orientation of individual
+   * characters is unchanged.
+   * For example:
+   *
+   *     | V |
+   *     | e |
+   *     | r |
+   *     | t |
+   *     | i |
+   *     | c |
+   *     | a |
+   *     | l |
+   */
+  core.bool vertical;
+
+  TextRotation();
+
+  TextRotation.fromJson(core.Map _json) {
+    if (_json.containsKey("angle")) {
+      angle = _json["angle"];
+    }
+    if (_json.containsKey("vertical")) {
+      vertical = _json["vertical"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (angle != null) {
+      _json["angle"] = angle;
+    }
+    if (vertical != null) {
+      _json["vertical"] = vertical;
+    }
+    return _json;
+  }
+}
+
 /**
  * Splits a column of text into multiple columns,
  * based on a delimiter in each cell.
  */
 class TextToColumnsRequest {
   /**
    * The delimiter to use. Used only if delimiterType is
    * CUSTOM.
    */
   core.String delimiter;
@@ skipping 818 matching lines @@
     }
     if (range != null) {
       _json["range"] = range;
     }
     if (values != null) {
       _json["values"] = values;
     }
     return _json;
   }
 }