Roll of googleapis as of 4/7/2015.

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:collection" as collection;
-import "dart:async" as async;
-import "dart:convert" as convert;
+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:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
+import 'package:crypto/crypto.dart' as crypto;
 import 'package:http/http.dart' as http;
-import '../src/common_internal.dart' as common_internal;
-import '../common/common.dart' as common;
 
-export '../common/common.dart' show ApiRequestError;
-export '../common/common.dart' show DetailedApiRequestError;
+export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
+    ApiRequestError, DetailedApiRequestError;
+
+const core.String USER_AGENT = 'dart-api-client fitness/v1';
 
 /** Google Fit API */
 class FitnessApi {
   /** View your activity information in Google Fit */
   static const FitnessActivityReadScope = "https://www.googleapis.com/auth/fitness.activity.read";
 
   /** View and store your activity information in Google Fit */
   static const FitnessActivityWriteScope = "https://www.googleapis.com/auth/fitness.activity.write";
 
   /** View body sensor information in Google Fit */
   static const FitnessBodyReadScope = "https://www.googleapis.com/auth/fitness.body.read";
 
   /** View and store body sensor data in Google Fit */
   static const FitnessBodyWriteScope = "https://www.googleapis.com/auth/fitness.body.write";
 
   /** View your stored location data in Google Fit */
   static const FitnessLocationReadScope = "https://www.googleapis.com/auth/fitness.location.read";
 
   /** View and store your location data in Google Fit */
   static const FitnessLocationWriteScope = "https://www.googleapis.com/auth/fitness.location.write";
 
 
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   UsersResourceApi get users => new UsersResourceApi(_requester);
 
   FitnessApi(http.Client client, {core.String rootUrl: "https://www.googleapis.com/", core.String servicePath: "fitness/v1/users/"}) :
-      _requester = new common_internal.ApiRequester(client, rootUrl, servicePath);
+      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
 
-/** Not documented yet. */
 class UsersResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   UsersDataSourcesResourceApi get dataSources => new UsersDataSourcesResourceApi(_requester);
   UsersSessionsResourceApi get sessions => new UsersSessionsResourceApi(_requester);
 
-  UsersResourceApi(common_internal.ApiRequester client) : 
+  UsersResourceApi(commons.ApiRequester client) : 
       _requester = client;
 }
 
 
-/** Not documented yet. */
 class UsersDataSourcesResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   UsersDataSourcesDatasetsResourceApi get datasets => new UsersDataSourcesDatasetsResourceApi(_requester);
 
-  UsersDataSourcesResourceApi(common_internal.ApiRequester client) : 
+  UsersDataSourcesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Creates a new data source that is unique across all data sources belonging
    * to this user. The data stream ID field can be omitted and will be generated
    * by the server with the correct format. The data stream ID is an ordered
    * combination of some fields from the data source. In addition to the data
    * source fields reflected into the data source ID, the developer project
    * number that is authenticated when creating the data source is included.
    * This developer project number is obfuscated when read by any other
    * developer reading public data types.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [userId] - Create the data source for the person identified. Use me to
    * indicate the authenticated user. Only me is supported at this time.
    *
    * Completes with a [DataSource].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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<DataSource> create(DataSource request, core.String userId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources';
+    _url = commons.Escaper.ecapeVariable('$userId') + '/dataSources';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new DataSource.fromJson(data));
   }
 
   /**
    * Returns a data source identified by a data stream ID.
    *
    * Request parameters:
    *
    * [userId] - Retrieve a data source for the person identified. Use me to
    * indicate the authenticated user. Only me is supported at this time.
    *
    * [dataSourceId] - The data stream ID of the data source to retrieve.
    *
    * Completes with a [DataSource].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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<DataSource> get(core.String userId, core.String dataSourceId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.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.");
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources/' + common_internal.Escaper.ecapeVariable('$dataSourceId');
+    _url = commons.Escaper.ecapeVariable('$userId') + '/dataSources/' + commons.Escaper.ecapeVariable('$dataSourceId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new DataSource.fromJson(data));
   }
 
   /**
    * Lists all data sources that are visible to the developer, using the OAuth
    * scopes provided. The list is not exhaustive: the user may have private data
    * sources that are only visible to other developers or calls using other
    * scopes.
    *
    * Request parameters:
    *
    * [userId] - List data sources for the person identified. Use me to indicate
    * the authenticated user. Only me is supported at this time.
    *
    * [dataTypeName] - The names of data types to include in the list. If not
    * specified, all data sources will be returned.
    *
    * Completes with a [ListDataSourcesResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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<ListDataSourcesResponse> list(core.String userId, {core.List<core.String> dataTypeName}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (dataTypeName != null) {
       _queryParams["dataTypeName"] = dataTypeName;
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources';
+    _url = commons.Escaper.ecapeVariable('$userId') + '/dataSources';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListDataSourcesResponse.fromJson(data));
   }
@@ skipping 11 matching lines @@
    *
    * Request parameters:
    *
    * [userId] - Update the data source for the person identified. Use me to
    * indicate the authenticated user. Only me is supported at this time.
    *
    * [dataSourceId] - The data stream ID of the data source to update.
    *
    * Completes with a [DataSource].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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<DataSource> patch(DataSource request, core.String userId, core.String dataSourceId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (dataSourceId == null) {
       throw new core.ArgumentError("Parameter dataSourceId is required.");
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources/' + common_internal.Escaper.ecapeVariable('$dataSourceId');
+    _url = commons.Escaper.ecapeVariable('$userId') + '/dataSources/' + commons.Escaper.ecapeVariable('$dataSourceId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new DataSource.fromJson(data));
   }
@@ skipping 10 matching lines @@
    *
    * Request parameters:
    *
    * [userId] - Update the data source for the person identified. Use me to
    * indicate the authenticated user. Only me is supported at this time.
    *
    * [dataSourceId] - The data stream ID of the data source to update.
    *
    * Completes with a [DataSource].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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<DataSource> update(DataSource request, core.String userId, core.String dataSourceId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (dataSourceId == null) {
       throw new core.ArgumentError("Parameter dataSourceId is required.");
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources/' + common_internal.Escaper.ecapeVariable('$dataSourceId');
+    _url = commons.Escaper.ecapeVariable('$userId') + '/dataSources/' + commons.Escaper.ecapeVariable('$dataSourceId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new DataSource.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class UsersDataSourcesDatasetsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  UsersDataSourcesDatasetsResourceApi(common_internal.ApiRequester client) : 
+  UsersDataSourcesDatasetsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Performs an inclusive delete of all data points whose start and end times
    * have any overlap with the time range specified by the dataset ID. For most
    * data types, the entire data point will be deleted. For data types where the
    * time span represents a consistent value (such as
    * com.google.activity.segment), and a data point straddles either end point
    * of the dataset, only the overlapping portion of the data point will be
    * deleted.
    *
    * Request parameters:
    *
    * [userId] - Delete a dataset for the person identified. Use me to indicate
    * 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.
    *
    * [currentTimeMillis] - The client's current time in milliseconds since
    * epoch.
    *
    * [modifiedTimeMillis] - When the operation was performed on the client.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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 delete(core.String userId, core.String dataSourceId, core.String datasetId, {core.String currentTimeMillis, core.String modifiedTimeMillis}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.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 (currentTimeMillis != null) {
       _queryParams["currentTimeMillis"] = [currentTimeMillis];
     }
     if (modifiedTimeMillis != null) {
       _queryParams["modifiedTimeMillis"] = [modifiedTimeMillis];
     }
 
     _downloadOptions = null;
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources/' + common_internal.Escaper.ecapeVariable('$dataSourceId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = commons.Escaper.ecapeVariable('$userId') + '/dataSources/' + commons.Escaper.ecapeVariable('$dataSourceId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
@@ skipping 23 matching lines @@
    * nextPageToken will be set in the dataset response.
    *
    * [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
+   * 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<Dataset> get(core.String userId, core.String dataSourceId, core.String datasetId, {core.int limit, core.String pageToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.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 (limit != null) {
       _queryParams["limit"] = ["${limit}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources/' + common_internal.Escaper.ecapeVariable('$dataSourceId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = commons.Escaper.ecapeVariable('$userId') + '/dataSources/' + commons.Escaper.ecapeVariable('$dataSourceId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
@@ skipping 18 matching lines @@
    * 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.
    *
    * [currentTimeMillis] - The client's current time in milliseconds since
    * epoch. Note that the minStartTimeNs and maxEndTimeNs properties in the
    * request body are in nanoseconds instead of milliseconds.
    *
    * Completes with a [Dataset].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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<Dataset> patch(Dataset request, core.String userId, core.String dataSourceId, core.String datasetId, {core.String currentTimeMillis}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     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 (currentTimeMillis != null) {
       _queryParams["currentTimeMillis"] = [currentTimeMillis];
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/dataSources/' + common_internal.Escaper.ecapeVariable('$dataSourceId') + '/datasets/' + common_internal.Escaper.ecapeVariable('$datasetId');
+    _url = commons.Escaper.ecapeVariable('$userId') + '/dataSources/' + commons.Escaper.ecapeVariable('$dataSourceId') + '/datasets/' + commons.Escaper.ecapeVariable('$datasetId');
 
     var _response = _requester.request(_url,
                                        "PATCH",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Dataset.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class UsersSessionsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  UsersSessionsResourceApi(common_internal.ApiRequester client) : 
+  UsersSessionsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Deletes a session specified by the given session ID.
    *
    * Request parameters:
    *
    * [userId] - Delete a session for the person identified. Use me to indicate
    * the authenticated user. Only me is supported at this time.
    *
    * [sessionId] - The ID of the session to be deleted.
    *
    * [currentTimeMillis] - The client's current time in milliseconds since
    * epoch.
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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 delete(core.String userId, core.String sessionId, {core.String currentTimeMillis}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (sessionId == null) {
       throw new core.ArgumentError("Parameter sessionId is required.");
     }
     if (currentTimeMillis != null) {
       _queryParams["currentTimeMillis"] = [currentTimeMillis];
     }
 
     _downloadOptions = null;
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/sessions/' + common_internal.Escaper.ecapeVariable('$sessionId');
+    _url = commons.Escaper.ecapeVariable('$userId') + '/sessions/' + commons.Escaper.ecapeVariable('$sessionId');
 
     var _response = _requester.request(_url,
                                        "DELETE",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
@@ skipping 15 matching lines @@
    *
    * [pageToken] - The continuation token, which is used to page through large
    * result sets. To get the next page of results, set this parameter to the
    * value of nextPageToken from the previous response.
    *
    * [startTime] - An RFC3339 timestamp. Only sessions ending between the start
    * and end times will be included in the response.
    *
    * Completes with a [ListSessionsResponse].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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<ListSessionsResponse> list(core.String userId, {core.String endTime, core.bool includeDeleted, core.String pageToken, core.String startTime}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (endTime != null) {
       _queryParams["endTime"] = [endTime];
     }
     if (includeDeleted != null) {
       _queryParams["includeDeleted"] = ["${includeDeleted}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (startTime != null) {
       _queryParams["startTime"] = [startTime];
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/sessions';
+    _url = commons.Escaper.ecapeVariable('$userId') + '/sessions';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListSessionsResponse.fromJson(data));
   }
 
   /**
    * Updates or insert a given session.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [userId] - Create sessions for the person identified. Use me to indicate
    * the authenticated user. Only me is supported at this time.
    *
    * [sessionId] - The ID of the session to be created.
    *
    * [currentTimeMillis] - The client's current time in milliseconds since
    * epoch.
    *
    * Completes with a [Session].
    *
-   * Completes with a [common.ApiRequestError] if the API endpoint returned an
+   * 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<Session> update(Session request, core.String userId, core.String sessionId, {core.String currentTimeMillis}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
-    var _downloadOptions = common.DownloadOptions.Metadata;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
     if (userId == null) {
       throw new core.ArgumentError("Parameter userId is required.");
     }
     if (sessionId == null) {
       throw new core.ArgumentError("Parameter sessionId is required.");
     }
     if (currentTimeMillis != null) {
       _queryParams["currentTimeMillis"] = [currentTimeMillis];
     }
 
 
-    _url = common_internal.Escaper.ecapeVariable('$userId') + '/sessions/' + common_internal.Escaper.ecapeVariable('$sessionId');
+    _url = commons.Escaper.ecapeVariable('$userId') + '/sessions/' + commons.Escaper.ecapeVariable('$sessionId');
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Session.fromJson(data));
   }
@@ skipping 392 matching lines @@
    * - "integer"
    */
   core.String format;
 
   /**
    * Defines the name and format of data. Unlike data type names, field names
    * are not namespaced, and only need to be unique within the data type.
    */
   core.String name;
 
-  /** Not documented yet. */
   core.bool optional;
 
 
   DataTypeField();
 
   DataTypeField.fromJson(core.Map _json) {
     if (_json.containsKey("format")) {
       format = _json["format"];
     }
     if (_json.containsKey("name")) {
@@ skipping 185 matching lines @@
       _json["uid"] = uid;
     }
     if (version != null) {
       _json["version"] = version;
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ListDataSourcesResponse {
   /** A previously created data source. */
   core.List<DataSource> dataSource;
 
 
   ListDataSourcesResponse();
 
   ListDataSourcesResponse.fromJson(core.Map _json) {
     if (_json.containsKey("dataSource")) {
       dataSource = _json["dataSource"].map((value) => new DataSource.fromJson(value)).toList();
     }
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     if (dataSource != null) {
       _json["dataSource"] = dataSource.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 
-/** Not documented yet. */
 class ListSessionsResponse {
   /**
    * If includeDeleted is set to true in the request, this list will contain
    * sessions deleted with original end times that are within the startTime and
    * endTime frame.
    */
   core.List<Session> deletedSession;
 
   /**
    * The continuation token, which is used to page through large result sets.
@@ skipping 161 matching lines @@
     var _json = new core.Map();
     if (fpVal != null) {
       _json["fpVal"] = fpVal;
     }
     if (intVal != null) {
       _json["intVal"] = intVal;
     }
     return _json;
   }
 }
-
-