Roll of googleapis as of 4/7/2015.

generated/googleapis/lib/games/v1.dart

+// This is a generated file (see the discoveryapis_generator project).
+
 library googleapis.games.v1;
 
-import "dart:core" as core;
-import "dart:collection" as collection_1;
-import "dart:async" as async;
-import "dart:convert" as convert;
+import 'dart:core' as core;
+import 'dart:collection' as collection_1;
+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 games/v1';
 
 /** The API for Google Play Game Services. */
 class GamesApi {
   /** View and manage its own configuration data in your Google Drive */
   static const DriveAppdataScope = "https://www.googleapis.com/auth/drive.appdata";
 
   /**
    * Share your Google+ profile information and view and manage your game
    * activity
    */
   static const GamesScope = "https://www.googleapis.com/auth/games";
 
   /** Know your basic profile info and list of people in your circles. */
   static const PlusLoginScope = "https://www.googleapis.com/auth/plus.login";
 
 
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
   AchievementDefinitionsResourceApi get achievementDefinitions => new AchievementDefinitionsResourceApi(_requester);
   AchievementsResourceApi get achievements => new AchievementsResourceApi(_requester);
   ApplicationsResourceApi get applications => new ApplicationsResourceApi(_requester);
   EventsResourceApi get events => new EventsResourceApi(_requester);
   LeaderboardsResourceApi get leaderboards => new LeaderboardsResourceApi(_requester);
   MetagameResourceApi get metagame => new MetagameResourceApi(_requester);
   PlayersResourceApi get players => new PlayersResourceApi(_requester);
   PushtokensResourceApi get pushtokens => new PushtokensResourceApi(_requester);
   QuestMilestonesResourceApi get questMilestones => new QuestMilestonesResourceApi(_requester);
   QuestsResourceApi get quests => new QuestsResourceApi(_requester);
   RevisionsResourceApi get revisions => new RevisionsResourceApi(_requester);
   RoomsResourceApi get rooms => new RoomsResourceApi(_requester);
   ScoresResourceApi get scores => new ScoresResourceApi(_requester);
   SnapshotsResourceApi get snapshots => new SnapshotsResourceApi(_requester);
   TurnBasedMatchesResourceApi get turnBasedMatches => new TurnBasedMatchesResourceApi(_requester);
 
   GamesApi(http.Client client, {core.String rootUrl: "https://www.googleapis.com/", core.String servicePath: "games/v1/"}) :
-      _requester = new common_internal.ApiRequester(client, rootUrl, servicePath);
+      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
 
-/** Not documented yet. */
 class AchievementDefinitionsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  AchievementDefinitionsResourceApi(common_internal.ApiRequester client) : 
+  AchievementDefinitionsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Lists all the achievement definitions for your application.
    *
    * Request parameters:
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [maxResults] - The maximum number of achievement resources to return in the
    * response, used for paging. For any response, the actual number of
    * achievement resources returned may be less than the specified maxResults.
    * Value must be between "1" and "200".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [AchievementDefinitionsListResponse].
    *
-   * 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<AchievementDefinitionsListResponse> list({core.String language, core.int maxResults, 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 (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
     _url = 'achievements';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AchievementDefinitionsListResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class AchievementsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  AchievementsResourceApi(common_internal.ApiRequester client) : 
+  AchievementsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Increments the steps of the achievement with the given ID for the currently
    * authenticated player.
    *
    * Request parameters:
    *
    * [achievementId] - The ID of the achievement used by this method.
    *
    * [stepsToIncrement] - The number of steps to increment.
    *
    * [requestId] - A randomly generated numeric ID for each request specified by
    * the caller. This number is used at the server to ensure that the request is
    * handled correctly across retries.
    *
    * Completes with a [AchievementIncrementResponse].
    *
-   * 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<AchievementIncrementResponse> increment(core.String achievementId, core.int stepsToIncrement, {core.String requestId}) {
     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 (achievementId == null) {
       throw new core.ArgumentError("Parameter achievementId is required.");
     }
     if (stepsToIncrement == null) {
       throw new core.ArgumentError("Parameter stepsToIncrement is required.");
     }
     _queryParams["stepsToIncrement"] = ["${stepsToIncrement}"];
     if (requestId != null) {
       _queryParams["requestId"] = [requestId];
     }
 
 
-    _url = 'achievements/' + common_internal.Escaper.ecapeVariable('$achievementId') + '/increment';
+    _url = 'achievements/' + commons.Escaper.ecapeVariable('$achievementId') + '/increment';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AchievementIncrementResponse.fromJson(data));
   }
@@ skipping 20 matching lines @@
    * [state] - Tells the server to return only achievements with the specified
    * state. If this parameter isn't specified, all achievements are returned.
    * Possible string values are:
    * - "ALL" : List all achievements. This is the default.
    * - "HIDDEN" : List only hidden achievements.
    * - "REVEALED" : List only revealed achievements.
    * - "UNLOCKED" : List only unlocked achievements.
    *
    * Completes with a [PlayerAchievementListResponse].
    *
-   * 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<PlayerAchievementListResponse> list(core.String playerId, {core.String language, core.int maxResults, core.String pageToken, core.String state}) {
     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 (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (state != null) {
       _queryParams["state"] = [state];
     }
 
 
-    _url = 'players/' + common_internal.Escaper.ecapeVariable('$playerId') + '/achievements';
+    _url = 'players/' + commons.Escaper.ecapeVariable('$playerId') + '/achievements';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PlayerAchievementListResponse.fromJson(data));
   }
 
   /**
    * Sets the state of the achievement with the given ID to REVEALED for the
    * currently authenticated player.
    *
    * Request parameters:
    *
    * [achievementId] - The ID of the achievement used by this method.
    *
    * Completes with a [AchievementRevealResponse].
    *
-   * 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<AchievementRevealResponse> reveal(core.String achievementId) {
     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 (achievementId == null) {
       throw new core.ArgumentError("Parameter achievementId is required.");
     }
 
 
-    _url = 'achievements/' + common_internal.Escaper.ecapeVariable('$achievementId') + '/reveal';
+    _url = 'achievements/' + commons.Escaper.ecapeVariable('$achievementId') + '/reveal';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AchievementRevealResponse.fromJson(data));
   }
 
   /**
    * Sets the steps for the currently authenticated player towards unlocking an
    * achievement. If the steps parameter is less than the current number of
    * steps that the player already gained for the achievement, the achievement
    * is not modified.
    *
    * Request parameters:
    *
    * [achievementId] - The ID of the achievement used by this method.
    *
    * [steps] - The minimum value to set the steps to.
    *
    * Completes with a [AchievementSetStepsAtLeastResponse].
    *
-   * 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<AchievementSetStepsAtLeastResponse> setStepsAtLeast(core.String achievementId, core.int steps) {
     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 (achievementId == null) {
       throw new core.ArgumentError("Parameter achievementId is required.");
     }
     if (steps == null) {
       throw new core.ArgumentError("Parameter steps is required.");
     }
     _queryParams["steps"] = ["${steps}"];
 
 
-    _url = 'achievements/' + common_internal.Escaper.ecapeVariable('$achievementId') + '/setStepsAtLeast';
+    _url = 'achievements/' + commons.Escaper.ecapeVariable('$achievementId') + '/setStepsAtLeast';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AchievementSetStepsAtLeastResponse.fromJson(data));
   }
 
   /**
    * Unlocks this achievement for the currently authenticated player.
    *
    * Request parameters:
    *
    * [achievementId] - The ID of the achievement used by this method.
    *
    * Completes with a [AchievementUnlockResponse].
    *
-   * 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<AchievementUnlockResponse> unlock(core.String achievementId) {
     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 (achievementId == null) {
       throw new core.ArgumentError("Parameter achievementId is required.");
     }
 
 
-    _url = 'achievements/' + common_internal.Escaper.ecapeVariable('$achievementId') + '/unlock';
+    _url = 'achievements/' + commons.Escaper.ecapeVariable('$achievementId') + '/unlock';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AchievementUnlockResponse.fromJson(data));
   }
 
   /**
    * Updates multiple achievements for the currently authenticated player.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * Completes with a [AchievementUpdateMultipleResponse].
    *
-   * 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<AchievementUpdateMultipleResponse> updateMultiple(AchievementUpdateMultipleRequest request) {
     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());
     }
 
 
     _url = 'achievements/updateMultiple';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new AchievementUpdateMultipleResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ApplicationsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  ApplicationsResourceApi(common_internal.ApiRequester client) : 
+  ApplicationsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Retrieves the metadata of the application with the given ID. If the
    * requested application is not available for the specified platformType, the
    * returned response will not include any instance data.
    *
    * Request parameters:
    *
    * [applicationId] - The application ID from the Google Play developer
    * console.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [platformType] - Restrict application details returned to the specific
    * platform.
    * Possible string values are:
    * - "ANDROID" : Retrieve applications that can be played on Android.
    * - "IOS" : Retrieve applications that can be played on iOS.
    * - "WEB_APP" : Retrieve applications that can be played on desktop web.
    *
    * Completes with a [Application].
    *
-   * 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<Application> get(core.String applicationId, {core.String language, core.String platformType}) {
     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 (applicationId == null) {
       throw new core.ArgumentError("Parameter applicationId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (platformType != null) {
       _queryParams["platformType"] = [platformType];
     }
 
 
-    _url = 'applications/' + common_internal.Escaper.ecapeVariable('$applicationId');
+    _url = 'applications/' + commons.Escaper.ecapeVariable('$applicationId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Application.fromJson(data));
   }
 
   /**
    * Indicate that the the currently authenticated user is playing your
    * application.
    *
    * Request parameters:
    *
-   * 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 played() {
     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;
 
 
     _downloadOptions = null;
 
     _url = 'applications/played';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
 }
 
 
-/** Not documented yet. */
 class EventsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  EventsResourceApi(common_internal.ApiRequester client) : 
+  EventsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Returns a list showing the current progress on events in this application
    * for the currently authenticated user.
    *
    * Request parameters:
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [maxResults] - The maximum number of events to return in the response, used
    * for paging. For any response, the actual number of events to return may be
    * less than the specified maxResults.
    * Value must be between "1" and "100".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [PlayerEventListResponse].
    *
-   * 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<PlayerEventListResponse> listByPlayer({core.String language, core.int maxResults, 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 (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
@@ skipping 22 matching lines @@
    *
    * [maxResults] - The maximum number of event definitions to return in the
    * response, used for paging. For any response, the actual number of event
    * definitions to return may be less than the specified maxResults.
    * Value must be between "1" and "100".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [EventDefinitionListResponse].
    *
-   * 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<EventDefinitionListResponse> listDefinitions({core.String language, core.int maxResults, 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 (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
@@ skipping 18 matching lines @@
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [EventUpdateResponse].
    *
-   * 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<EventUpdateResponse> record(EventRecordRequest request, {core.String language}) {
     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 (language != null) {
       _queryParams["language"] = [language];
     }
 
 
     _url = 'events';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new EventUpdateResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class LeaderboardsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  LeaderboardsResourceApi(common_internal.ApiRequester client) : 
+  LeaderboardsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Retrieves the metadata of the leaderboard with the given ID.
    *
    * Request parameters:
    *
    * [leaderboardId] - The ID of the leaderboard.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Leaderboard].
    *
-   * 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<Leaderboard> get(core.String leaderboardId, {core.String language}) {
     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 (leaderboardId == null) {
       throw new core.ArgumentError("Parameter leaderboardId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'leaderboards/' + common_internal.Escaper.ecapeVariable('$leaderboardId');
+    _url = 'leaderboards/' + commons.Escaper.ecapeVariable('$leaderboardId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Leaderboard.fromJson(data));
   }
 
   /**
    * Lists all the leaderboard metadata for your application.
    *
    * Request parameters:
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [maxResults] - The maximum number of leaderboards to return in the
    * response. For any response, the actual number of leaderboards returned may
    * be less than the specified maxResults.
    * Value must be between "1" and "200".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [LeaderboardListResponse].
    *
-   * 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<LeaderboardListResponse> list({core.String language, core.int maxResults, 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 (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
     _url = 'leaderboards';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new LeaderboardListResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class MetagameResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  MetagameResourceApi(common_internal.ApiRequester client) : 
+  MetagameResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Return the metagame configuration data for the calling application.
    *
    * Request parameters:
    *
    * Completes with a [MetagameConfig].
    *
-   * 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<MetagameConfig> getMetagameConfig() {
     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;
 
 
 
     _url = 'metagameConfig';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 22 matching lines @@
    *
    * [maxResults] - The maximum number of category resources to return in the
    * response, used for paging. For any response, the actual number of category
    * resources returned may be less than the specified maxResults.
    * Value must be between "1" and "100".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [CategoryListResponse].
    *
-   * 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<CategoryListResponse> listCategoriesByPlayer(core.String playerId, core.String collection, {core.String language, core.int maxResults, 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 (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
     if (collection == null) {
       throw new core.ArgumentError("Parameter collection is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = 'players/' + common_internal.Escaper.ecapeVariable('$playerId') + '/categories/' + common_internal.Escaper.ecapeVariable('$collection');
+    _url = 'players/' + commons.Escaper.ecapeVariable('$playerId') + '/categories/' + commons.Escaper.ecapeVariable('$collection');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new CategoryListResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class PlayersResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  PlayersResourceApi(common_internal.ApiRequester client) : 
+  PlayersResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Retrieves the Player resource with the given ID. To retrieve the player for
    * the currently authenticated user, set playerId to me.
    *
    * Request parameters:
    *
    * [playerId] - A player ID. A value of me may be used in place of the
    * authenticated player's ID.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Player].
    *
-   * 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<Player> get(core.String playerId, {core.String language}) {
     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 (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'players/' + common_internal.Escaper.ecapeVariable('$playerId');
+    _url = 'players/' + commons.Escaper.ecapeVariable('$playerId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Player.fromJson(data));
   }
@@ skipping 16 matching lines @@
    *
    * [maxResults] - The maximum number of player resources to return in the
    * response, used for paging. For any response, the actual number of player
    * resources returned may be less than the specified maxResults.
    * Value must be between "1" and "15".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [PlayerListResponse].
    *
-   * 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<PlayerListResponse> list(core.String collection, {core.String language, core.int maxResults, 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 (collection == null) {
       throw new core.ArgumentError("Parameter collection is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = 'players/me/players/' + common_internal.Escaper.ecapeVariable('$collection');
+    _url = 'players/me/players/' + commons.Escaper.ecapeVariable('$collection');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PlayerListResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class PushtokensResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  PushtokensResourceApi(common_internal.ApiRequester client) : 
+  PushtokensResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Removes a push token for the current user and application. Removing a
    * non-existent push token will report success.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
-   * 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 remove(PushTokenId request) {
     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());
     }
 
     _downloadOptions = null;
 
     _url = 'pushtokens/remove';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Registers a push token for the current user and application.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
-   * 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 update(PushToken request) {
     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());
     }
 
     _downloadOptions = null;
 
     _url = 'pushtokens';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
 }
 
 
-/** Not documented yet. */
 class QuestMilestonesResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  QuestMilestonesResourceApi(common_internal.ApiRequester client) : 
+  QuestMilestonesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Report that a reward for the milestone corresponding to milestoneId for the
    * quest corresponding to questId has been claimed by the currently authorized
    * user.
    *
    * Request parameters:
    *
    * [questId] - The ID of the quest.
    *
    * [milestoneId] - The ID of the milestone.
    *
    * [requestId] - A numeric ID to ensure that the request is handled correctly
    * across retries. Your client application must generate this ID randomly.
    *
-   * 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 claim(core.String questId, core.String milestoneId, core.String requestId) {
     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 (questId == null) {
       throw new core.ArgumentError("Parameter questId is required.");
     }
     if (milestoneId == null) {
       throw new core.ArgumentError("Parameter milestoneId is required.");
     }
     if (requestId == null) {
       throw new core.ArgumentError("Parameter requestId is required.");
     }
     _queryParams["requestId"] = [requestId];
 
     _downloadOptions = null;
 
-    _url = 'quests/' + common_internal.Escaper.ecapeVariable('$questId') + '/milestones/' + common_internal.Escaper.ecapeVariable('$milestoneId') + '/claim';
+    _url = 'quests/' + commons.Escaper.ecapeVariable('$questId') + '/milestones/' + commons.Escaper.ecapeVariable('$milestoneId') + '/claim';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
 }
 
 
-/** Not documented yet. */
 class QuestsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  QuestsResourceApi(common_internal.ApiRequester client) : 
+  QuestsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Indicates that the currently authorized user will participate in the quest.
    *
    * Request parameters:
    *
    * [questId] - The ID of the quest.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Quest].
    *
-   * 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<Quest> accept(core.String questId, {core.String language}) {
     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 (questId == null) {
       throw new core.ArgumentError("Parameter questId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'quests/' + common_internal.Escaper.ecapeVariable('$questId') + '/accept';
+    _url = 'quests/' + commons.Escaper.ecapeVariable('$questId') + '/accept';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Quest.fromJson(data));
   }
@@ skipping 13 matching lines @@
    * [maxResults] - The maximum number of quest resources to return in the
    * response, used for paging. For any response, the actual number of quest
    * resources returned may be less than the specified maxResults. Acceptable
    * values are 1 to 50, inclusive. (Default: 50).
    * Value must be between "1" and "50".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [QuestListResponse].
    *
-   * 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<QuestListResponse> list(core.String playerId, {core.String language, core.int maxResults, 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 (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = 'players/' + common_internal.Escaper.ecapeVariable('$playerId') + '/quests';
+    _url = 'players/' + commons.Escaper.ecapeVariable('$playerId') + '/quests';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new QuestListResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class RevisionsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  RevisionsResourceApi(common_internal.ApiRequester client) : 
+  RevisionsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Checks whether the games client is out of date.
    *
    * Request parameters:
    *
    * [clientRevision] - The revision of the client SDK used by your application.
    * Format:
    * [PLATFORM_TYPE]:[VERSION_NUMBER]. Possible values of PLATFORM_TYPE are:
    *
    * - "ANDROID" - Client is running the Android SDK.
    * - "IOS" - Client is running the iOS SDK.
    * - "WEB_APP" - Client is running as a Web App.
    *
    * Completes with a [RevisionCheckResponse].
    *
-   * 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<RevisionCheckResponse> check(core.String clientRevision) {
     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 (clientRevision == null) {
       throw new core.ArgumentError("Parameter clientRevision is required.");
     }
     _queryParams["clientRevision"] = [clientRevision];
 
 
     _url = 'revisions/check';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new RevisionCheckResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class RoomsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  RoomsResourceApi(common_internal.ApiRequester client) : 
+  RoomsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Create a room. For internal use by the Games SDK only. Calling this method
    * directly is unsupported.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
-   * 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<Room> create(RoomCreateRequest request, {core.String language}) {
     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 (language != null) {
       _queryParams["language"] = [language];
     }
 
 
@@ skipping 15 matching lines @@
    *
    * Request parameters:
    *
    * [roomId] - The ID of the room.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
-   * 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<Room> decline(core.String roomId, {core.String language}) {
     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 (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'rooms/' + common_internal.Escaper.ecapeVariable('$roomId') + '/decline';
+    _url = 'rooms/' + commons.Escaper.ecapeVariable('$roomId') + '/decline';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Room.fromJson(data));
   }
 
   /**
    * Dismiss an invitation to join a room. For internal use by the Games SDK
    * only. Calling this method directly is unsupported.
    *
    * Request parameters:
    *
    * [roomId] - The ID of the room.
    *
-   * 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 dismiss(core.String roomId) {
     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 (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'rooms/' + common_internal.Escaper.ecapeVariable('$roomId') + '/dismiss';
+    _url = 'rooms/' + commons.Escaper.ecapeVariable('$roomId') + '/dismiss';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Get the data for a room.
    *
    * Request parameters:
    *
    * [roomId] - The ID of the room.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
-   * 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<Room> get(core.String roomId, {core.String language}) {
     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 (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'rooms/' + common_internal.Escaper.ecapeVariable('$roomId');
+    _url = 'rooms/' + commons.Escaper.ecapeVariable('$roomId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Room.fromJson(data));
   }
 
   /**
    * Join a room. For internal use by the Games SDK only. Calling this method
    * directly is unsupported.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [roomId] - The ID of the room.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
-   * 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<Room> join(RoomJoinRequest request, core.String roomId, {core.String language}) {
     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 (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'rooms/' + common_internal.Escaper.ecapeVariable('$roomId') + '/join';
+    _url = 'rooms/' + commons.Escaper.ecapeVariable('$roomId') + '/join';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Room.fromJson(data));
   }
 
   /**
    * Leave a room. For internal use by the Games SDK only. Calling this method
    * directly is unsupported.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [roomId] - The ID of the room.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
-   * 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<Room> leave(RoomLeaveRequest request, core.String roomId, {core.String language}) {
     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 (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'rooms/' + common_internal.Escaper.ecapeVariable('$roomId') + '/leave';
+    _url = 'rooms/' + commons.Escaper.ecapeVariable('$roomId') + '/leave';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Room.fromJson(data));
   }
 
   /**
    * Returns invitations to join rooms.
    *
    * Request parameters:
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [maxResults] - The maximum number of rooms to return in the response, used
    * for paging. For any response, the actual number of rooms to return may be
    * less than the specified maxResults.
    * Value must be between "1" and "500".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [RoomList].
    *
-   * 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<RoomList> list({core.String language, core.int maxResults, 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 (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
@@ skipping 21 matching lines @@
    *
    * Request parameters:
    *
    * [roomId] - The ID of the room.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [RoomStatus].
    *
-   * 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<RoomStatus> reportStatus(RoomP2PStatuses request, core.String roomId, {core.String language}) {
     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 (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'rooms/' + common_internal.Escaper.ecapeVariable('$roomId') + '/reportstatus';
+    _url = 'rooms/' + commons.Escaper.ecapeVariable('$roomId') + '/reportstatus';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new RoomStatus.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class ScoresResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  ScoresResourceApi(common_internal.ApiRequester client) : 
+  ScoresResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Get high scores, and optionally ranks, in leaderboards for the currently
    * authenticated player. For a specific time span, leaderboardId can be set to
    * ALL to retrieve data for all leaderboards in a given time span.
    * NOTE: You cannot ask for 'ALL' leaderboards and 'ALL' timeSpans in the same
    * request; only one parameter may be set to 'ALL'.
    *
    * Request parameters:
@@ skipping 25 matching lines @@
    *
    * [maxResults] - The maximum number of leaderboard scores to return in the
    * response. For any response, the actual number of leaderboard scores
    * returned may be less than the specified maxResults.
    * Value must be between "1" and "30".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [PlayerLeaderboardScoreListResponse].
    *
-   * 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<PlayerLeaderboardScoreListResponse> get(core.String playerId, core.String leaderboardId, core.String timeSpan, {core.String includeRankType, core.String language, core.int maxResults, 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 (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
     if (leaderboardId == null) {
       throw new core.ArgumentError("Parameter leaderboardId is required.");
     }
     if (timeSpan == null) {
       throw new core.ArgumentError("Parameter timeSpan is required.");
     }
     if (includeRankType != null) {
       _queryParams["includeRankType"] = [includeRankType];
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = 'players/' + common_internal.Escaper.ecapeVariable('$playerId') + '/leaderboards/' + common_internal.Escaper.ecapeVariable('$leaderboardId') + '/scores/' + common_internal.Escaper.ecapeVariable('$timeSpan');
+    _url = 'players/' + commons.Escaper.ecapeVariable('$playerId') + '/leaderboards/' + commons.Escaper.ecapeVariable('$leaderboardId') + '/scores/' + commons.Escaper.ecapeVariable('$timeSpan');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PlayerLeaderboardScoreListResponse.fromJson(data));
   }
@@ skipping 21 matching lines @@
    *
    * [maxResults] - The maximum number of leaderboard scores to return in the
    * response. For any response, the actual number of leaderboard scores
    * returned may be less than the specified maxResults.
    * Value must be between "1" and "30".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [LeaderboardScores].
    *
-   * 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<LeaderboardScores> list(core.String leaderboardId, core.String collection, core.String timeSpan, {core.String language, core.int maxResults, 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 (leaderboardId == null) {
       throw new core.ArgumentError("Parameter leaderboardId is required.");
     }
     if (collection == null) {
       throw new core.ArgumentError("Parameter collection is required.");
     }
     if (timeSpan == null) {
       throw new core.ArgumentError("Parameter timeSpan is required.");
     }
     _queryParams["timeSpan"] = [timeSpan];
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = 'leaderboards/' + common_internal.Escaper.ecapeVariable('$leaderboardId') + '/scores/' + common_internal.Escaper.ecapeVariable('$collection');
+    _url = 'leaderboards/' + commons.Escaper.ecapeVariable('$leaderboardId') + '/scores/' + commons.Escaper.ecapeVariable('$collection');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new LeaderboardScores.fromJson(data));
   }
@@ skipping 29 matching lines @@
    * [resultsAbove] - The preferred number of scores to return above the
    * player's score. More scores may be returned if the player is at the bottom
    * of the leaderboard; fewer may be returned if the player is at the top. Must
    * be less than or equal to maxResults.
    *
    * [returnTopIfAbsent] - True if the top scores should be returned when the
    * player is not in the leaderboard. Defaults to true.
    *
    * Completes with a [LeaderboardScores].
    *
-   * 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<LeaderboardScores> listWindow(core.String leaderboardId, core.String collection, core.String timeSpan, {core.String language, core.int maxResults, core.String pageToken, core.int resultsAbove, core.bool returnTopIfAbsent}) {
     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 (leaderboardId == null) {
       throw new core.ArgumentError("Parameter leaderboardId is required.");
     }
     if (collection == null) {
       throw new core.ArgumentError("Parameter collection is required.");
     }
     if (timeSpan == null) {
       throw new core.ArgumentError("Parameter timeSpan is required.");
     }
     _queryParams["timeSpan"] = [timeSpan];
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (resultsAbove != null) {
       _queryParams["resultsAbove"] = ["${resultsAbove}"];
     }
     if (returnTopIfAbsent != null) {
       _queryParams["returnTopIfAbsent"] = ["${returnTopIfAbsent}"];
     }
 
 
-    _url = 'leaderboards/' + common_internal.Escaper.ecapeVariable('$leaderboardId') + '/window/' + common_internal.Escaper.ecapeVariable('$collection');
+    _url = 'leaderboards/' + commons.Escaper.ecapeVariable('$leaderboardId') + '/window/' + commons.Escaper.ecapeVariable('$collection');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new LeaderboardScores.fromJson(data));
   }
@@ skipping 15 matching lines @@
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [scoreTag] - Additional information about the score you're submitting.
    * Values must contain no more than 64 URI-safe characters as defined by
    * section 2.3 of RFC 3986.
    * Value must have pattern "[a-zA-Z0-9-._~]{0,64}".
    *
    * Completes with a [PlayerScoreResponse].
    *
-   * 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<PlayerScoreResponse> submit(core.String leaderboardId, core.String score, {core.String language, core.String scoreTag}) {
     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 (leaderboardId == null) {
       throw new core.ArgumentError("Parameter leaderboardId is required.");
     }
     if (score == null) {
       throw new core.ArgumentError("Parameter score is required.");
     }
     _queryParams["score"] = [score];
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (scoreTag != null) {
       _queryParams["scoreTag"] = [scoreTag];
     }
 
 
-    _url = 'leaderboards/' + common_internal.Escaper.ecapeVariable('$leaderboardId') + '/scores';
+    _url = 'leaderboards/' + commons.Escaper.ecapeVariable('$leaderboardId') + '/scores';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PlayerScoreResponse.fromJson(data));
   }
 
   /**
    * Submits multiple scores to leaderboards.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [PlayerScoreListResponse].
    *
-   * 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<PlayerScoreListResponse> submitMultiple(PlayerScoreSubmissionList request, {core.String language}) {
     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 (language != null) {
       _queryParams["language"] = [language];
     }
 
 
     _url = 'leaderboards/scores';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PlayerScoreListResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class SnapshotsResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  SnapshotsResourceApi(common_internal.ApiRequester client) : 
+  SnapshotsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Retrieves the metadata for a given snapshot ID.
    *
    * Request parameters:
    *
    * [snapshotId] - The ID of the snapshot.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Snapshot].
    *
-   * 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<Snapshot> get(core.String snapshotId, {core.String language}) {
     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 (snapshotId == null) {
       throw new core.ArgumentError("Parameter snapshotId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'snapshots/' + common_internal.Escaper.ecapeVariable('$snapshotId');
+    _url = 'snapshots/' + commons.Escaper.ecapeVariable('$snapshotId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Snapshot.fromJson(data));
   }
@@ skipping 12 matching lines @@
    *
    * [maxResults] - The maximum number of snapshot resources to return in the
    * response, used for paging. For any response, the actual number of snapshot
    * resources returned may be less than the specified maxResults.
    * Value must be between "1" and "25".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [SnapshotListResponse].
    *
-   * 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<SnapshotListResponse> list(core.String playerId, {core.String language, core.int maxResults, 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 (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
 
-    _url = 'players/' + common_internal.Escaper.ecapeVariable('$playerId') + '/snapshots';
+    _url = 'players/' + commons.Escaper.ecapeVariable('$playerId') + '/snapshots';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new SnapshotListResponse.fromJson(data));
   }
 
 }
 
 
-/** Not documented yet. */
 class TurnBasedMatchesResourceApi {
-  final common_internal.ApiRequester _requester;
+  final commons.ApiRequester _requester;
 
-  TurnBasedMatchesResourceApi(common_internal.ApiRequester client) : 
+  TurnBasedMatchesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Cancel a turn-based match.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
-   * 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 cancel(core.String matchId) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/cancel';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/cancel';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Create a turn-based match.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
-   * 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<TurnBasedMatch> create(TurnBasedMatchCreateRequest request, {core.String language}) {
     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 (language != null) {
       _queryParams["language"] = [language];
     }
 
 
@@ skipping 14 matching lines @@
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
-   * 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<TurnBasedMatch> decline(core.String matchId, {core.String language}) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/decline';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/decline';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatch.fromJson(data));
   }
 
   /**
    * Dismiss a turn-based match from the match list. The match will no longer
    * show up in the list and will not generate notifications.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
-   * 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 dismiss(core.String matchId) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
 
     _downloadOptions = null;
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/dismiss';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/dismiss';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => null);
   }
 
   /**
    * Finish a turn-based match. Each player should make this call once, after
    * all results are in. Only the player whose turn it is may make the first
    * call to Finish, and can pass in the final match state.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
-   * 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<TurnBasedMatch> finish(TurnBasedMatchResults request, core.String matchId, {core.String language}) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/finish';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/finish';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatch.fromJson(data));
   }
 
   /**
    * Get the data for a turn-based match.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
    * [includeMatchData] - Get match data along with metadata.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
-   * 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<TurnBasedMatch> get(core.String matchId, {core.bool includeMatchData, core.String language}) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
     if (includeMatchData != null) {
       _queryParams["includeMatchData"] = ["${includeMatchData}"];
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId');
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatch.fromJson(data));
   }
 
   /**
    * Join a turn-based match.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
-   * 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<TurnBasedMatch> join(core.String matchId, {core.String language}) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/join';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/join';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatch.fromJson(data));
   }
 
   /**
    * Leave a turn-based match when it is not the current player's turn, without
    * canceling the match.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
-   * 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<TurnBasedMatch> leave(core.String matchId, {core.String language}) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/leave';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/leave';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatch.fromJson(data));
   }
@@ skipping 11 matching lines @@
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [pendingParticipantId] - The ID of another participant who should take
    * their turn next. If not set, the match will wait for other player(s) to
    * join via automatching; this is only valid if automatch criteria is set on
    * the match with remaining slots for automatched players.
    *
    * Completes with a [TurnBasedMatch].
    *
-   * 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<TurnBasedMatch> leaveTurn(core.String matchId, core.int matchVersion, {core.String language, core.String pendingParticipantId}) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
     if (matchVersion == null) {
       throw new core.ArgumentError("Parameter matchVersion is required.");
     }
     _queryParams["matchVersion"] = ["${matchVersion}"];
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (pendingParticipantId != null) {
       _queryParams["pendingParticipantId"] = [pendingParticipantId];
     }
 
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/leaveTurn';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/leaveTurn';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatch.fromJson(data));
   }
@@ skipping 19 matching lines @@
    *
    * [maxResults] - The maximum number of matches to return in the response,
    * used for paging. For any response, the actual number of matches to return
    * may be less than the specified maxResults.
    * Value must be between "1" and "500".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [TurnBasedMatchList].
    *
-   * 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<TurnBasedMatchList> list({core.bool includeMatchData, core.String language, core.int maxCompletedMatches, core.int maxResults, 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 (includeMatchData != null) {
       _queryParams["includeMatchData"] = ["${includeMatchData}"];
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxCompletedMatches != null) {
       _queryParams["maxCompletedMatches"] = ["${maxCompletedMatches}"];
@@ skipping 30 matching lines @@
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [requestId] - A randomly generated numeric ID for each request specified by
    * the caller. This number is used at the server to ensure that the request is
    * handled correctly across retries.
    *
    * Completes with a [TurnBasedMatchRematch].
    *
-   * 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<TurnBasedMatchRematch> rematch(core.String matchId, {core.String language, core.String requestId}) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (requestId != null) {
       _queryParams["requestId"] = [requestId];
     }
 
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/rematch';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/rematch';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatchRematch.fromJson(data));
   }
@@ skipping 22 matching lines @@
    *
    * [maxResults] - The maximum number of matches to return in the response,
    * used for paging. For any response, the actual number of matches to return
    * may be less than the specified maxResults.
    * Value must be between "1" and "500".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [TurnBasedMatchSync].
    *
-   * 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<TurnBasedMatchSync> sync({core.bool includeMatchData, core.String language, core.int maxCompletedMatches, core.int maxResults, 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 (includeMatchData != null) {
       _queryParams["includeMatchData"] = ["${includeMatchData}"];
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxCompletedMatches != null) {
       _queryParams["maxCompletedMatches"] = ["${maxCompletedMatches}"];
@@ skipping 25 matching lines @@
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
-   * 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<TurnBasedMatch> takeTurn(TurnBasedMatchTurn request, core.String matchId, {core.String language}) {
     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 (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
 
-    _url = 'turnbasedmatches/' + common_internal.Escaper.ecapeVariable('$matchId') + '/turn';
+    _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/turn';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatch.fromJson(data));
   }
@@ skipping 6715 matching lines @@
     }
     if (pendingParticipantId != null) {
       _json["pendingParticipantId"] = pendingParticipantId;
     }
     if (results != null) {
       _json["results"] = results.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
-
-