Api roll 6: 2014-11-17

generated/googleapis/lib/fitness/v1.dart

 library googleapis.fitness.v1;
 
 import "dart:core" as core;
 import "dart:collection" as collection;
 import "dart:async" as async;
 import "dart:convert" as convert;
 
 import "package:crypto/crypto.dart" as crypto;
 import 'package:http/http.dart' as http;
 import '../src/common_internal.dart' as common_internal;
@@ skipping 409 matching lines @@
    * the authenticated user. Only me is supported at this time.
    *
    * [dataSourceId] - The data stream ID of the data source that created the
    * dataset.
    *
    * [datasetId] - Dataset identifier that is a composite of the minimum data
    * point start time and maximum data point end time represented as nanoseconds
    * from the epoch. The ID is formatted like: "startTime-endTime" where
    * startTime and endTime are 64 bit integers.
    *
+   * [pageToken] - The continuation token, which is used to page through large
+   * datasets. To get the next page of a dataset, set this parameter to the
+   * value of nextPageToken from the previous response. Each subsequent call
+   * will yield a partial dataset with data point end timestamps that are
+   * strictly smaller than those in the previous partial response.
+   *
    * Completes with a [Dataset].
    *
    * Completes with a [common.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<Dataset> get(core.String userId, core.String dataSourceId, core.String datasetId) {
+  async.Future<Dataset> get(core.String userId, core.String dataSourceId, core.String datasetId, {core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = common.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (dataSourceId == null) {
       throw new core.ArgumentError("Parameter dataSourceId is required.");
     }
     if (datasetId == null) {
       throw new core.ArgumentError("Parameter datasetId is required.");
     }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
 
 
     _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources/' + common_internal.Escaper.ecapeVariable('$dataSourceId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
@@ skipping 702 matching lines @@
   core.String maxEndTimeNs;
 
   /**
    * The smallest start time of all data points in this possibly partial
    * representation of the dataset. Time is in nanoseconds from epoch. This
    * should also match the first part of the dataset identifier.
    */
   core.String minStartTimeNs;
 
   /**
-   * A partial list of data points contained in the dataset. This list is
-   * considered complete when retrieving a dataset and partial when patching a
-   * dataset.
+   * This token will be set when a dataset is received in response to a GET
+   * request and the dataset is too large to be included in a single response.
+   * Provide this value in a subsequent GET request to return the next page of
+   * data points within this dataset.
+   */
+  core.String nextPageToken;
+
+  /**
+   * A partial list of data points contained in the dataset, ordered by largest
+   * endTimeNanos first. This list is considered complete when retrieving a
+   * small dataset and partial when patching a dataset or retrieving a dataset
+   * that is too large to include in a single response.
    */
   core.List<DataPoint> point;
 
 
   Dataset();
 
   Dataset.fromJson(core.Map _json) {
     if (_json.containsKey("dataSourceId")) {
       dataSourceId = _json["dataSourceId"];
     }
     if (_json.containsKey("maxEndTimeNs")) {
       maxEndTimeNs = _json["maxEndTimeNs"];
     }
     if (_json.containsKey("minStartTimeNs")) {
       minStartTimeNs = _json["minStartTimeNs"];
     }
+    if (_json.containsKey("nextPageToken")) {
+      nextPageToken = _json["nextPageToken"];
+    }
     if (_json.containsKey("point")) {
       point = _json["point"].map((value) => new DataPoint.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (dataSourceId != null) {
       _json["dataSourceId"] = dataSourceId;
     }
     if (maxEndTimeNs != null) {
       _json["maxEndTimeNs"] = maxEndTimeNs;
     }
     if (minStartTimeNs != null) {
       _json["minStartTimeNs"] = minStartTimeNs;
     }
+    if (nextPageToken != null) {
+      _json["nextPageToken"] = nextPageToken;
+    }
     if (point != null) {
       _json["point"] = point.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 
 /**
  * Representation of an integrated device (such as a phone or a wearable) that
@@ skipping 252 matching lines @@
 }
 
 
 /**
  * Holder object for the value of a single field in a data point.
  *
  * A field value has a particular format and is only ever set to one of an
  * integer or a floating point value.
  */
 class Value {
-  /** Floating point value. */
+  /** Floating point value. When this is set, intVal must not be set. */
   core.double fpVal;
 
-  /** Integer value. */
+  /** Integer value. When this is set, fpVal must not be set. */
   core.int intVal;
 
 
   Value();
 
   Value.fromJson(core.Map _json) {
     if (_json.containsKey("fpVal")) {
       fpVal = _json["fpVal"];
     }
     if (_json.containsKey("intVal")) {
       intVal = _json["intVal"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (fpVal != null) {
       _json["fpVal"] = fpVal;
     }
     if (intVal != null) {
       _json["intVal"] = intVal;
     }
     return _json;
   }
 }