Api-roll 21: 2015-08-04

generated/googleapis/lib/fitness/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.fitness.v1;
 
 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 581 matching lines @@
 }
 
 
 class UsersDatasetResourceApi {
   final commons.ApiRequester _requester;
 
   UsersDatasetResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
+   * Aggregates data of a certain type or stream into buckets divided by a given
+   * type of boundary. Multiple data sets of multiple types and from multiple
+   * sources can be aggreated into exactly one bucket type per request.
+   *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
-   * [userId] - null
+   * [userId] - Aggregate data for the person identified. Use me to indicate the
+   * authenticated user. Only me is supported at this time.
    *
    * Completes with a [AggregateResponse].
    *
    * 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<AggregateResponse> aggregate(AggregateRequest request, core.String userId) {
@@ skipping 203 matching lines @@
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Session.fromJson(data));
   }
 
 }
 
 
 
 class AggregateBucket {
-  /** available for Bucket.Type.ACTIVITY_TYPE, Bucket.Type.ACTIVITY_SEGMENT */
+  /** Available for Bucket.Type.ACTIVITY_TYPE, Bucket.Type.ACTIVITY_SEGMENT */
   core.int activity;
-  /** There will be one dataset per datatype/datasource */
+  /** There will be one dataset per AggregateBy in the request. */
   core.List<Dataset> dataset;
+  /**
+   * The end time for the aggregated data, in milliseconds since epoch,
+   * inclusive.
+   */
   core.String endTimeMillis;
-  /** available for Bucket.Type.SESSION */
+  /** Available for Bucket.Type.SESSION */
   Session session;
+  /**
+   * The start time for the aggregated data, in milliseconds since epoch,
+   * inclusive.
+   */
   core.String startTimeMillis;
   /**
    * The type of a bucket signifies how the data aggregation is performed in the
    * bucket.
    * Possible string values are:
    * - "activitySegment"
    * - "activityType"
    * - "session"
    * - "time"
    * - "unknown"
@@ skipping 40 matching lines @@
     if (startTimeMillis != null) {
       _json["startTimeMillis"] = startTimeMillis;
     }
     if (type != null) {
       _json["type"] = type;
     }
     return _json;
   }
 }
 
+/** The specification of which data to aggregate. */
 class AggregateBy {
+  /**
+   * A data source ID to aggregate. Mutually exclusive of dataTypeName. Only
+   * data from the specified data source ID will be included in the aggregation.
+   * The dataset in the response will have the same data source ID.
+   */
   core.String dataSourceId;
-  /** by dataype or by datasource */
+  /**
+   * The data type to aggregate. All data sources providing this data type will
+   * contribute data to the aggregation. The response will contain a single
+   * dataset for this data type name. The dataset will have a data source ID of
+   * derived:com.google.:com.google.android.gms:aggregated
+   */
   core.String dataTypeName;
-  core.String outputDataSourceId;
-  core.String outputDataTypeName;
 
   AggregateBy();
 
   AggregateBy.fromJson(core.Map _json) {
     if (_json.containsKey("dataSourceId")) {
       dataSourceId = _json["dataSourceId"];
     }
     if (_json.containsKey("dataTypeName")) {
       dataTypeName = _json["dataTypeName"];
     }
-    if (_json.containsKey("outputDataSourceId")) {
-      outputDataSourceId = _json["outputDataSourceId"];
-    }
-    if (_json.containsKey("outputDataTypeName")) {
-      outputDataTypeName = _json["outputDataTypeName"];
-    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (dataSourceId != null) {
       _json["dataSourceId"] = dataSourceId;
     }
     if (dataTypeName != null) {
       _json["dataTypeName"] = dataTypeName;
     }
-    if (outputDataSourceId != null) {
-      _json["outputDataSourceId"] = outputDataSourceId;
-    }
-    if (outputDataTypeName != null) {
-      _json["outputDataTypeName"] = outputDataTypeName;
-    }
     return _json;
   }
 }
 
 class AggregateRequest {
+  /**
+   * The specification of data to be aggregated. At least one aggregateBy spec
+   * must be provided. All data that is specified will be aggregated using the
+   * same bucketing criteria. There will be one dataset in the response for
+   * every aggregateBy spec.
+   */
   core.List<AggregateBy> aggregateBy;
+  /**
+   * Specifies that data be aggregated each activity segment recored for a user.
+   * Similar to bucketByActivitySegment, but bucketing is done for each activity
+   * segment rather than all segments of the same type. Mutually exclusive of
+   * other bucketing specifications.
+   */
   BucketByActivity bucketByActivitySegment;
+  /**
+   * Specifies that data be aggregated by the type of activity being performed
+   * when the data was recorded. All data that was recorded during a certain
+   * activity type (for the given time range) will be aggregated into the same
+   * bucket. Data that was recorded while the user was not active will not be
+   * included in the response. Mutually exclusive of other bucketing
+   * specifications.
+   */
   BucketByActivity bucketByActivityType;
+  /**
+   * Specifies that data be aggregated by user sessions. Data that does not fall
+   * within the time range of a session will not be included in the response.
+   * Mutually exclusive of other bucketing specifications.
+   */
   BucketBySession bucketBySession;
-  /** apparently oneof is not supported by reduced_nano_proto */
+  /**
+   * Specifies that data be aggregated by a single time interval. Mutually
+   * exclusive of other bucketing specifications.
+   */
   BucketByTime bucketByTime;
+  /**
+   * The end of a window of time. Data that intersects with this time window
+   * will be aggregated. The time is in milliseconds since epoch, inclusive.
+   */
   core.String endTimeMillis;
-  /** required time range */
+  /**
+   * The start of a window of time. Data that intersects with this time window
+   * will be aggregated. The time is in milliseconds since epoch, inclusive.
+   */
   core.String startTimeMillis;
 
   AggregateRequest();
 
   AggregateRequest.fromJson(core.Map _json) {
     if (_json.containsKey("aggregateBy")) {
       aggregateBy = _json["aggregateBy"].map((value) => new AggregateBy.fromJson(value)).toList();
     }
     if (_json.containsKey("bucketByActivitySegment")) {
       bucketByActivitySegment = new BucketByActivity.fromJson(_json["bucketByActivitySegment"]);
@@ skipping 36 matching lines @@
       _json["endTimeMillis"] = endTimeMillis;
     }
     if (startTimeMillis != null) {
       _json["startTimeMillis"] = startTimeMillis;
     }
     return _json;
   }
 }
 
 class AggregateResponse {
+  /** A list of buckets containing the aggregated data. */
   core.List<AggregateBucket> bucket;
 
   AggregateResponse();
 
   AggregateResponse.fromJson(core.Map _json) {
     if (_json.containsKey("bucket")) {
       bucket = _json["bucket"].map((value) => new AggregateBucket.fromJson(value)).toList();
     }
   }
 
@@ skipping 61 matching lines @@
       _json["packageName"] = packageName;
     }
     if (version != null) {
       _json["version"] = version;
     }
     return _json;
   }
 }
 
 class BucketByActivity {
-  /** default activity stream will be used if not specified */
+  /**
+   * The default activity stream will be used if a specific activityDataSourceId
+   * is not specified.
+   */
   core.String activityDataSourceId;
-  /** Only activity segments of duration longer than this is used */
+  /**
+   * Specifies that only activity segments of duration longer than
+   * minDurationMillis are considered and used as a container for aggregated
+   * data.
+   */
   core.String minDurationMillis;
 
   BucketByActivity();
 
   BucketByActivity.fromJson(core.Map _json) {
     if (_json.containsKey("activityDataSourceId")) {
       activityDataSourceId = _json["activityDataSourceId"];
     }
     if (_json.containsKey("minDurationMillis")) {
       minDurationMillis = _json["minDurationMillis"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (activityDataSourceId != null) {
       _json["activityDataSourceId"] = activityDataSourceId;
     }
     if (minDurationMillis != null) {
       _json["minDurationMillis"] = minDurationMillis;
     }
     return _json;
   }
 }
 
 class BucketBySession {
-  /** Only sessions of duration longer than this is used */
+  /**
+   * Specifies that only sessions of duration longer than minDurationMillis are
+   * considered and used as a container for aggregated data.
+   */
   core.String minDurationMillis;
 
   BucketBySession();
 
   BucketBySession.fromJson(core.Map _json) {
     if (_json.containsKey("minDurationMillis")) {
       minDurationMillis = _json["minDurationMillis"];
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (minDurationMillis != null) {
       _json["minDurationMillis"] = minDurationMillis;
     }
     return _json;
   }
 }
 
 class BucketByTime {
+  /**
+   * Specifies that result buckets aggregate data by exactly durationMillis time
+   * frames. Time frames that contain no data will be included in the response
+   * with an empty dataset.
+   */
   core.String durationMillis;
 
   BucketByTime();
 
   BucketByTime.fromJson(core.Map _json) {
     if (_json.containsKey("durationMillis")) {
       durationMillis = _json["durationMillis"];
     }
   }
 
@@ skipping 573 matching lines @@
       _json["nextPageToken"] = nextPageToken;
     }
     if (session != null) {
       _json["session"] = session.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /**
+ * Holder object for the value of an entry in a map field of a data point.
+ *
+ * A map value supports a subset of the formats that the regular Value supports.
+ */
+class MapValue {
+  /** Floating point value. */
+  core.double fpVal;
+
+  MapValue();
+
+  MapValue.fromJson(core.Map _json) {
+    if (_json.containsKey("fpVal")) {
+      fpVal = _json["fpVal"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (fpVal != null) {
+      _json["fpVal"] = fpVal;
+    }
+    return _json;
+  }
+}
+
+/**
  * Sessions contain metadata, such as a user-friendly name and time interval
  * information.
  */
 class Session {
   /**
    * Session active time. While start_time_millis and end_time_millis define the
    * full session time, the active time can be shorter and specified by
    * active_time_millis. If the inactive time during the session is known, it
    * should also be inserted via a com.google.activity.segment data point with a
    * STILL activity value
@@ skipping 84 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. When this is set, intVal must not be set. */
+  /** Floating point value. When this is set, other values must not be set. */
   core.double fpVal;
-  /** Integer value. When this is set, fpVal must not be set. */
+  /** Integer value. When this is set, other values must not be set. */
   core.int intVal;
+  /**
+   * Map value. The valid key space and units for the corresponding value of
+   * each entry should be documented as part of the data type definition. Keys
+   * should be kept small whenever possible. Data streams with large keys and
+   * high data frequency may be down sampled.
+   */
+  core.List<ValueMapValEntry> mapVal;
+  /**
+   * String value. When this is set, other values must not be set. Strings
+   * should be kept small whenever possible. Data streams with large string
+   * values and high data frequency may be down sampled.
+   */
+  core.String stringVal;
 
   Value();
 
   Value.fromJson(core.Map _json) {
     if (_json.containsKey("fpVal")) {
       fpVal = _json["fpVal"];
     }
     if (_json.containsKey("intVal")) {
       intVal = _json["intVal"];
     }
+    if (_json.containsKey("mapVal")) {
+      mapVal = _json["mapVal"].map((value) => new ValueMapValEntry.fromJson(value)).toList();
+    }
+    if (_json.containsKey("stringVal")) {
+      stringVal = _json["stringVal"];
+    }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (fpVal != null) {
       _json["fpVal"] = fpVal;
     }
     if (intVal != null) {
       _json["intVal"] = intVal;
     }
+    if (mapVal != null) {
+      _json["mapVal"] = mapVal.map((value) => (value).toJson()).toList();
+    }
+    if (stringVal != null) {
+      _json["stringVal"] = stringVal;
+    }
     return _json;
   }
 }
+
+class ValueMapValEntry {
+  core.String key;
+  MapValue value;
+
+  ValueMapValEntry();
+
+  ValueMapValEntry.fromJson(core.Map _json) {
+    if (_json.containsKey("key")) {
+      key = _json["key"];
+    }
+    if (_json.containsKey("value")) {
+      value = new MapValue.fromJson(_json["value"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (key != null) {
+      _json["key"] = key;
+    }
+    if (value != null) {
+      _json["value"] = (value).toJson();
+    }
+    return _json;
+  }
+}