Api-roll 21: 2015-08-04

discovery/googleapis/fitness__v1.json

 {
     "auth": {
         "oauth2": {
             "scopes": {
                 "https://www.googleapis.com/auth/fitness.activity.read": {
                     "description": "View your activity information in Google Fit"
                 },
                 "https://www.googleapis.com/auth/fitness.activity.write": {
                     "description": "View and store your activity information in Google Fit"
                 },
@@ skipping 11 matching lines @@
                 }
             }
         }
     },
     "basePath": "/fitness/v1/users/",
     "baseUrl": "https://www.googleapis.com/fitness/v1/users/",
     "batchPath": "batch",
     "description": "Google Fit API",
     "discoveryVersion": "v1",
     "documentationLink": "https://developers.google.com/fit/rest/",
-    "etag": "\"ye6orv2F-1npMW3u9suM3a7C5Bo/ON1-o8QnfSjPgDpi2fa5Rxma0qA\"",
+    "etag": "\"ye6orv2F-1npMW3u9suM3a7C5Bo/HDPUkwKxWfeChsVb7MggQS7MZkw\"",
     "icons": {
         "x16": "http://www.google.com/images/icons/product/search-16.gif",
         "x32": "http://www.google.com/images/icons/product/search-32.gif"
     },
     "id": "fitness:v1",
     "kind": "discovery#restDescription",
     "name": "fitness",
     "ownerDomain": "google.com",
     "ownerName": "Google",
     "parameters": {
@@ skipping 399 matching lines @@
                                         "https://www.googleapis.com/auth/fitness.location.write"
                                     ]
                                 }
                             }
                         }
                     }
                 },
                 "dataset": {
                     "methods": {
                         "aggregate": {
+                            "description": "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.",
                             "httpMethod": "POST",
                             "id": "fitness.users.dataset.aggregate",
                             "parameterOrder": [
                                 "userId"
                             ],
                             "parameters": {
                                 "userId": {
+                                    "description": "Aggregate data for the person identified. Use me to indicate the authenticated user. Only me is supported at this time.",
                                     "location": "path",
                                     "required": true,
                                     "type": "string"
                                 }
                             },
                             "path": "{userId}/dataset:aggregate",
                             "request": {
                                 "$ref": "AggregateRequest"
                             },
                             "response": {
                                 "$ref": "AggregateResponse"
-                            }
+                            },
+                            "scopes": [
+                                "https://www.googleapis.com/auth/fitness.activity.write",
+                                "https://www.googleapis.com/auth/fitness.body.write",
+                                "https://www.googleapis.com/auth/fitness.location.write"
+                            ]
                         }
                     }
                 },
                 "sessions": {
                     "methods": {
                         "delete": {
                             "description": "Deletes a session specified by the given session ID.",
                             "httpMethod": "DELETE",
                             "id": "fitness.users.sessions.delete",
                             "parameterOrder": [
@@ skipping 110 matching lines @@
                             },
                             "scopes": [
                                 "https://www.googleapis.com/auth/fitness.activity.write"
                             ]
                         }
                     }
                 }
             }
         }
     },
-    "revision": "20150527",
+    "revision": "20150720",
     "rootUrl": "https://www.googleapis.com/",
     "schemas": {
         "AggregateBucket": {
             "id": "AggregateBucket",
             "properties": {
                 "activity": {
-                    "description": "available for Bucket.Type.ACTIVITY_TYPE, Bucket.Type.ACTIVITY_SEGMENT",
+                    "description": "Available for Bucket.Type.ACTIVITY_TYPE, Bucket.Type.ACTIVITY_SEGMENT",
                     "format": "int32",
                     "type": "integer"
                 },
                 "dataset": {
-                    "description": "There will be one dataset per datatype/datasource",
+                    "description": "There will be one dataset per AggregateBy in the request.",
                     "items": {
                         "$ref": "Dataset"
                     },
                     "type": "array"
                 },
                 "endTimeMillis": {
+                    "description": "The end time for the aggregated data, in milliseconds since epoch, inclusive.",
                     "format": "int64",
                     "type": "string"
                 },
                 "session": {
                     "$ref": "Session",
-                    "description": "available for Bucket.Type.SESSION"
+                    "description": "Available for Bucket.Type.SESSION"
                 },
                 "startTimeMillis": {
+                    "description": "The start time for the aggregated data, in milliseconds since epoch, inclusive.",
                     "format": "int64",
                     "type": "string"
                 },
                 "type": {
                     "description": "The type of a bucket signifies how the data aggregation is performed in the bucket.",
                     "enum": [
                         "activitySegment",
                         "activityType",
                         "session",
                         "time",
                         "unknown"
                     ],
                     "enumDescriptions": [
                         "",
                         "",
                         "",
                         "",
                         ""
                     ],
                     "type": "string"
                 }
             },
             "type": "object"
         },
         "AggregateBy": {
+            "description": "The specification of which data to aggregate.",
             "id": "AggregateBy",
             "properties": {
                 "dataSourceId": {
+                    "description": "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.",
                     "type": "string"
                 },
                 "dataTypeName": {
-                    "description": "by dataype or by datasource",
-                    "type": "string"
-                },
-                "outputDataSourceId": {
-                    "type": "string"
-                },
-                "outputDataTypeName": {
+                    "description": "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",
                     "type": "string"
                 }
             },
             "type": "object"
         },
         "AggregateRequest": {
             "id": "AggregateRequest",
             "properties": {
                 "aggregateBy": {
+                    "annotations": {
+                        "required": [
+                            "fitness.users.dataset.aggregate"
+                        ]
+                    },
+                    "description": "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.",
                     "items": {
                         "$ref": "AggregateBy"
                     },
                     "type": "array"
                 },
                 "bucketByActivitySegment": {
-                    "$ref": "BucketByActivity"
+                    "$ref": "BucketByActivity",
+                    "description": "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."
                 },
                 "bucketByActivityType": {
-                    "$ref": "BucketByActivity"
+                    "$ref": "BucketByActivity",
+                    "description": "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."
                 },
                 "bucketBySession": {
-                    "$ref": "BucketBySession"
+                    "$ref": "BucketBySession",
+                    "description": "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."
                 },
                 "bucketByTime": {
                     "$ref": "BucketByTime",
-                    "description": "apparently oneof is not supported by reduced_nano_proto"
+                    "description": "Specifies that data be aggregated by a single time interval. Mutually exclusive of other bucketing specifications."
                 },
                 "endTimeMillis": {
+                    "annotations": {
+                        "required": [
+                            "fitness.users.dataset.aggregate"
+                        ]
+                    },
+                    "description": "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.",
                     "format": "int64",
                     "type": "string"
                 },
                 "startTimeMillis": {
-                    "description": "required time range",
+                    "annotations": {
+                        "required": [
+                            "fitness.users.dataset.aggregate"
+                        ]
+                    },
+                    "description": "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.",
                     "format": "int64",
                     "type": "string"
                 }
             },
             "type": "object"
         },
         "AggregateResponse": {
             "id": "AggregateResponse",
             "properties": {
                 "bucket": {
+                    "description": "A list of buckets containing the aggregated data.",
                     "items": {
                         "$ref": "AggregateBucket"
                     },
                     "type": "array"
                 }
             },
             "type": "object"
         },
         "Application": {
             "description": "See: google3/java/com/google/android/apps/heart/platform/api/Application.java",
@@ skipping 22 matching lines @@
                     "description": "Version of the application. You should update this field whenever the application changes in a way that affects the computation of the data.",
                     "type": "string"
                 }
             },
             "type": "object"
         },
         "BucketByActivity": {
             "id": "BucketByActivity",
             "properties": {
                 "activityDataSourceId": {
-                    "description": "default activity stream will be used if not specified",
+                    "description": "The default activity stream will be used if a specific activityDataSourceId is not specified.",
                     "type": "string"
                 },
                 "minDurationMillis": {
-                    "description": "Only activity segments of duration longer than this is used",
+                    "description": "Specifies that only activity segments of duration longer than minDurationMillis are considered and used as a container for aggregated data.",
                     "format": "int64",
                     "type": "string"
                 }
             },
             "type": "object"
         },
         "BucketBySession": {
             "id": "BucketBySession",
             "properties": {
                 "minDurationMillis": {
-                    "description": "Only sessions of duration longer than this is used",
+                    "description": "Specifies that only sessions of duration longer than minDurationMillis are considered and used as a container for aggregated data.",
                     "format": "int64",
                     "type": "string"
                 }
             },
             "type": "object"
         },
         "BucketByTime": {
             "id": "BucketByTime",
             "properties": {
                 "durationMillis": {
+                    "description": "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.",
                     "format": "int64",
                     "type": "string"
                 }
             },
             "type": "object"
         },
         "DataPoint": {
             "description": "Represents a single data point, generated by a particular data source. A data point holds a value for each field, an end timestamp and an optional start time. The exact semantics of each of these attributes are specified in the documentation for the particular data type.\n\nA data point can represent an instantaneous measurement, reading or input observation, as well as averages or aggregates over a time interval. Check the data type documentation to determine which is the case for a particular data type.\n\nData points always contain one value for each field of the data type.",
             "id": "DataPoint",
             "properties": {
@@ skipping 363 matching lines @@
                 "session": {
                     "description": "Sessions with an end time that is between startTime and endTime of the request.",
                     "items": {
                         "$ref": "Session"
                     },
                     "type": "array"
                 }
             },
             "type": "object"
         },
+        "MapValue": {
+            "description": "Holder object for the value of an entry in a map field of a data point.\n\nA map value supports a subset of the formats that the regular Value supports.",
+            "id": "MapValue",
+            "properties": {
+                "fpVal": {
+                    "description": "Floating point value.",
+                    "format": "double",
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
         "Session": {
             "description": "Sessions contain metadata, such as a user-friendly name and time interval information.",
             "id": "Session",
             "properties": {
                 "activeTimeMillis": {
                     "description": "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",
                     "format": "int64",
                     "type": "string"
                 },
                 "activityType": {
@@ skipping 63 matching lines @@
                     "type": "string"
                 }
             },
             "type": "object"
         },
         "Value": {
             "description": "Holder object for the value of a single field in a data point.\n\nA field value has a particular format and is only ever set to one of an integer or a floating point value.",
             "id": "Value",
             "properties": {
                 "fpVal": {
-                    "description": "Floating point value. When this is set, intVal must not be set.",
+                    "description": "Floating point value. When this is set, other values must not be set.",
                     "format": "double",
                     "type": "number"
                 },
                 "intVal": {
-                    "description": "Integer value. When this is set, fpVal must not be set.",
+                    "description": "Integer value. When this is set, other values must not be set.",
                     "format": "int32",
                     "type": "integer"
+                },
+                "mapVal": {
+                    "description": "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.",
+                    "items": {
+                        "$ref": "ValueMapValEntry"
+                    },
+                    "type": "array"
+                },
+                "stringVal": {
+                    "description": "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.",
+                    "type": "string"
                 }
             },
             "type": "object"
+        },
+        "ValueMapValEntry": {
+            "id": "ValueMapValEntry",
+            "properties": {
+                "key": {
+                    "type": "string"
+                },
+                "value": {
+                    "$ref": "MapValue"
+                }
+            },
+            "type": "object"
         }
     },
     "servicePath": "fitness/v1/users/",
     "title": "Fitness",
     "version": "v1"
 }