Api-roll 37: 2016-06-06

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:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
-import 'package:crypto/crypto.dart' as crypto;
 import 'package:http/http.dart' as http;
 
 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 */
@@ skipping 36 matching lines @@
   final commons.ApiRequester _requester;
 
   AchievementDefinitionsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Lists all the achievement definitions for your application.
    *
    * Request parameters:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<AchievementDefinitionsListResponse> list({core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 21 matching lines @@
   /**
    * 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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<AchievementIncrementResponse> increment(core.String achievementId, core.int stepsToIncrement, {core.String consistencyToken, core.String requestId}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (requestId != null) {
       _queryParams["requestId"] = [requestId];
     }
 
     _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));
   }
 
   /**
    * Lists the progress for all your application's achievements for the
    * currently authenticated player.
    *
    * Request parameters:
    *
    * [playerId] - A player ID. A value of me may be used in place of the
    * authenticated player's ID.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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.
    *
    * [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 [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}) {
+  async.Future<PlayerAchievementListResponse> list(core.String playerId, {core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (state != null) {
@@ skipping 13 matching lines @@
   }
 
   /**
    * 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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * Completes with a [AchievementRevealResponse].
    *
    * 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) {
+  async.Future<AchievementRevealResponse> reveal(core.String achievementId, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (achievementId == null) {
       throw new core.ArgumentError("Parameter achievementId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * Completes with a [AchievementSetStepsAtLeastResponse].
    *
    * 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) {
+  async.Future<AchievementSetStepsAtLeastResponse> setStepsAtLeast(core.String achievementId, core.int steps, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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}"];
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * Completes with a [AchievementUnlockResponse].
    *
    * 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) {
+  async.Future<AchievementUnlockResponse> unlock(core.String achievementId, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (achievementId == null) {
       throw new core.ArgumentError("Parameter achievementId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * Completes with a [AchievementUpdateMultipleResponse].
    *
    * 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) {
+  async.Future<AchievementUpdateMultipleResponse> updateMultiple(AchievementUpdateMultipleRequest request, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _url = 'achievements/updateMultiple';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 12 matching lines @@
   /**
    * 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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<Application> get(core.String applicationId, {core.String consistencyToken, core.String language, core.String platformType}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (applicationId == null) {
       throw new core.ArgumentError("Parameter applicationId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (platformType != null) {
       _queryParams["platformType"] = [platformType];
     }
 
     _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * 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() {
+  async.Future played({core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _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);
   }
 
   /**
    * Verifies the auth token provided with this request is for the application
    * with the specified ID, and returns the ID of the player it was granted for.
    *
    * Request parameters:
    *
    * [applicationId] - The application ID from the Google Play developer
    * console.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * Completes with a [ApplicationVerifyResponse].
    *
    * 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<ApplicationVerifyResponse> verify(core.String applicationId) {
+  async.Future<ApplicationVerifyResponse> verify(core.String applicationId, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (applicationId == null) {
       throw new core.ArgumentError("Parameter applicationId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _url = 'applications/' + commons.Escaper.ecapeVariable('$applicationId') + '/verify';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new ApplicationVerifyResponse.fromJson(data));
   }
 
 }
 
 
 class EventsResourceApi {
   final commons.ApiRequester _requester;
 
   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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<PlayerEventListResponse> listByPlayer({core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
     _url = 'events';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new PlayerEventListResponse.fromJson(data));
   }
 
   /**
    * Returns a list of the event definitions in this application.
    *
    * Request parameters:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [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 [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}) {
+  async.Future<EventDefinitionListResponse> listDefinitions({core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 10 matching lines @@
   }
 
   /**
    * Records a batch of changes to the number of times events have occurred for
    * the currently authenticated user of this application.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [EventUpdateResponse].
    *
    * 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}) {
+  async.Future<EventUpdateResponse> record(EventRecordRequest request, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _url = 'events';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 12 matching lines @@
   LeaderboardsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Retrieves the metadata of the leaderboard with the given ID.
    *
    * Request parameters:
    *
    * [leaderboardId] - The ID of the leaderboard.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Leaderboard].
    *
    * 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}) {
+  async.Future<Leaderboard> get(core.String leaderboardId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (leaderboardId == null) {
       throw new core.ArgumentError("Parameter leaderboardId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<LeaderboardListResponse> list({core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 16 matching lines @@
   final commons.ApiRequester _requester;
 
   MetagameResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Return the metagame configuration data for the calling application.
    *
    * Request parameters:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * Completes with a [MetagameConfig].
    *
    * 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() {
+  async.Future<MetagameConfig> getMetagameConfig({core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _url = 'metagameConfig';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new MetagameConfig.fromJson(data));
   }
 
   /**
    * List play data aggregated per category for the player corresponding to
    * playerId.
    *
    * Request parameters:
    *
    * [playerId] - A player ID. A value of me may be used in place of the
    * authenticated player's ID.
    *
    * [collection] - The collection of categories for which data will be
    * returned.
    * Possible string values are:
    * - "all" : Retrieve data for all categories. This is the default.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [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 [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}) {
+  async.Future<CategoryListResponse> listCategoriesByPlayer(core.String playerId, core.String collection, {core.String consistencyToken, 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 = 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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 20 matching lines @@
 
   /**
    * 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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Player].
    *
    * 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}) {
+  async.Future<Player> get(core.String playerId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _url = 'players/' + commons.Escaper.ecapeVariable('$playerId');
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 13 matching lines @@
    * - "connected" : Retrieve a list of players that are also playing this game
    * in reverse chronological order.
    * - "playedWith" : (DEPRECATED: please use played_with!) Retrieve a list of
    * players you have played a multiplayer game (realtime or turn-based) with
    * recently.
    * - "played_with" : Retrieve a list of players you have played a multiplayer
    * game (realtime or turn-based) with recently.
    * - "visible" : Retrieve a list of players in the user's social graph that
    * are visible to this game.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [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 "50".
    *
    * [pageToken] - The token returned by the previous request.
    *
    * Completes with a [PlayerListResponse].
    *
    * 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}) {
+  async.Future<PlayerListResponse> list(core.String collection, {core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (collection == null) {
       throw new core.ArgumentError("Parameter collection is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 19 matching lines @@
       _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * 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) {
+  async.Future remove(PushTokenId request, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * 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) {
+  async.Future update(PushToken request, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _downloadOptions = null;
 
     _url = 'pushtokens';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
@@ skipping 18 matching lines @@
    *
    * 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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * 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) {
+  async.Future claim(core.String questId, core.String milestoneId, core.String requestId, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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];
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _downloadOptions = null;
 
     _url = 'quests/' + commons.Escaper.ecapeVariable('$questId') + '/milestones/' + commons.Escaper.ecapeVariable('$milestoneId') + '/claim';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
@@ skipping 11 matching lines @@
   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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Quest].
    *
    * 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}) {
+  async.Future<Quest> accept(core.String questId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (questId == null) {
       throw new core.ArgumentError("Parameter questId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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));
   }
 
   /**
    * Get a list of quests for your application and the currently authenticated
    * player.
    *
    * Request parameters:
    *
    * [playerId] - A player ID. A value of me may be used in place of the
    * authenticated player's ID.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [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 [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}) {
+  async.Future<QuestListResponse> list(core.String playerId, {core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 24 matching lines @@
    * 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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * Completes with a [RevisionCheckResponse].
    *
    * 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) {
+  async.Future<RevisionCheckResponse> check(core.String clientRevision, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (clientRevision == null) {
       throw new core.ArgumentError("Parameter clientRevision is required.");
     }
     _queryParams["clientRevision"] = [clientRevision];
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _url = 'revisions/check';
 
     var _response = _requester.request(_url,
                                        "GET",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
@@ skipping 10 matching lines @@
       _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
    * 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}) {
+  async.Future<Room> create(RoomCreateRequest request, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _url = 'rooms/create';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Room.fromJson(data));
   }
 
   /**
    * Decline 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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
    * 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}) {
+  async.Future<Room> decline(core.String roomId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * 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) {
+  async.Future dismiss(core.String roomId, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _downloadOptions = null;
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
    * 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}) {
+  async.Future<Room> get(core.String roomId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (roomId == null) {
       throw new core.ArgumentError("Parameter roomId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
    * 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}) {
+  async.Future<Room> join(RoomJoinRequest request, core.String roomId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Room].
    *
    * 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}) {
+  async.Future<Room> leave(RoomLeaveRequest request, core.String roomId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<RoomList> list({core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 13 matching lines @@
    * Updates sent by a client reporting the status of peers in 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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [RoomStatus].
    *
    * 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}) {
+  async.Future<RoomStatus> reportStatus(RoomP2PStatuses request, core.String roomId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _url = 'rooms/' + commons.Escaper.ecapeVariable('$roomId') + '/reportstatus';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 28 matching lines @@
    * retrieve data for all leaderboards for this application.
    *
    * [timeSpan] - The time span for the scores and ranks you're requesting.
    * Possible string values are:
    * - "ALL" : Get the high scores for all time spans. If this is used,
    * maxResults values will be ignored.
    * - "ALL_TIME" : Get the all time high score.
    * - "DAILY" : List the top scores for the current day.
    * - "WEEKLY" : List the top scores for the current week.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [includeRankType] - The types of ranks to return. If the parameter is
    * omitted, no ranks will be returned.
    * Possible string values are:
    * - "ALL" : Retrieve public and social ranks.
    * - "PUBLIC" : Retrieve public ranks, if the player is sharing their gameplay
    * activity publicly.
    * - "SOCIAL" : Retrieve the social rank.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [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 [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}) {
+  async.Future<PlayerLeaderboardScoreListResponse> get(core.String playerId, core.String leaderboardId, core.String timeSpan, {core.String consistencyToken, 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 = 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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (includeRankType != null) {
       _queryParams["includeRankType"] = [includeRankType];
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
@@ skipping 24 matching lines @@
    * - "PUBLIC" : List all scores in the public leaderboard.
    * - "SOCIAL" : List only social scores.
    * - "SOCIAL_1P" : List only social scores, not respecting the fACL.
    *
    * [timeSpan] - The time span for the scores and ranks you're requesting.
    * Possible string values are:
    * - "ALL_TIME" : List the all-time top scores.
    * - "DAILY" : List the top scores for the current day.
    * - "WEEKLY" : List the top scores for the current week.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [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 [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}) {
+  async.Future<LeaderboardScores> list(core.String leaderboardId, core.String collection, core.String timeSpan, {core.String consistencyToken, 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 = 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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 21 matching lines @@
    * - "PUBLIC" : List all scores in the public leaderboard.
    * - "SOCIAL" : List only social scores.
    * - "SOCIAL_1P" : List only social scores, not respecting the fACL.
    *
    * [timeSpan] - The time span for the scores and ranks you're requesting.
    * Possible string values are:
    * - "ALL_TIME" : List the all-time top scores.
    * - "DAILY" : List the top scores for the current day.
    * - "WEEKLY" : List the top scores for the current week.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [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.
    *
    * [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 [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}) {
+  async.Future<LeaderboardScores> listWindow(core.String leaderboardId, core.String collection, core.String timeSpan, {core.String consistencyToken, 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 = 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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
     if (resultsAbove != null) {
@@ skipping 22 matching lines @@
    *
    * [leaderboardId] - The ID of the leaderboard.
    *
    * [score] - The score you're submitting. The submitted score is ignored if it
    * is worse than a previously submitted score, where worse depends on the
    * leaderboard sort order. The meaning of the score value depends on the
    * leaderboard format type. For fixed-point, the score represents the raw
    * value. For time, the score represents elapsed time in milliseconds. For
    * currency, the score represents a value in micro units.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<PlayerScoreResponse> submit(core.String leaderboardId, core.String score, {core.String consistencyToken, core.String language, core.String scoreTag}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (scoreTag != null) {
       _queryParams["scoreTag"] = [scoreTag];
     }
 
     _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [PlayerScoreListResponse].
    *
    * 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}) {
+  async.Future<PlayerScoreListResponse> submitMultiple(PlayerScoreSubmissionList request, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _url = 'leaderboards/scores';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 12 matching lines @@
   SnapshotsResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Retrieves the metadata for a given snapshot ID.
    *
    * Request parameters:
    *
    * [snapshotId] - The ID of the snapshot.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [Snapshot].
    *
    * 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}) {
+  async.Future<Snapshot> get(core.String snapshotId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (snapshotId == null) {
       throw new core.ArgumentError("Parameter snapshotId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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));
   }
 
   /**
    * Retrieves a list of snapshots created by your application for the player
    * corresponding to the player ID.
    *
    * Request parameters:
    *
    * [playerId] - A player ID. A value of me may be used in place of the
    * authenticated player's ID.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [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 [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}) {
+  async.Future<SnapshotListResponse> list(core.String playerId, {core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (playerId == null) {
       throw new core.ArgumentError("Parameter playerId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxResults != null) {
       _queryParams["maxResults"] = ["${maxResults}"];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
 
@@ skipping 18 matching lines @@
   TurnBasedMatchesResourceApi(commons.ApiRequester client) : 
       _requester = client;
 
   /**
    * Cancel a turn-based match.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * 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) {
+  async.Future cancel(core.String matchId, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _downloadOptions = null;
 
     _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:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
    * 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}) {
+  async.Future<TurnBasedMatch> create(TurnBasedMatchCreateRequest request, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (request != null) {
       _body = convert.JSON.encode((request).toJson());
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _url = 'turnbasedmatches/create';
 
     var _response = _requester.request(_url,
                                        "POST",
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new TurnBasedMatch.fromJson(data));
   }
 
   /**
    * Decline an invitation to play a turn-based match.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
    * 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}) {
+  async.Future<TurnBasedMatch> decline(core.String matchId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * 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) {
+  async.Future dismiss(core.String matchId, {core.String consistencyToken}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
 
     _downloadOptions = null;
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
    * 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}) {
+  async.Future<TurnBasedMatch> finish(TurnBasedMatchResults request, core.String matchId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<TurnBasedMatch> get(core.String matchId, {core.String consistencyToken, core.bool includeMatchData, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (includeMatchData != null) {
       _queryParams["includeMatchData"] = ["${includeMatchData}"];
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
    * 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}) {
+  async.Future<TurnBasedMatch> join(core.String matchId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
    * 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}) {
+  async.Future<TurnBasedMatch> leave(core.String matchId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _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));
   }
 
   /**
    * Leave a turn-based match during the current player's turn, without
    * canceling the match.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
    * [matchVersion] - The version of the match being updated.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<TurnBasedMatch> leaveTurn(core.String matchId, core.int matchVersion, {core.String consistencyToken, core.String language, core.String pendingParticipantId}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (pendingParticipantId != null) {
       _queryParams["pendingParticipantId"] = [pendingParticipantId];
     }
 
     _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));
   }
 
   /**
    * Returns turn-based matches the player is or was involved in.
    *
    * Request parameters:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [includeMatchData] - True if match data should be returned in the response.
    * Note that not all data will necessarily be returned if include_match_data
    * is true; the server may decide to only return data for some of the matches
    * to limit download size for the client. The remainder of the data for these
    * matches will be retrievable on request.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [maxCompletedMatches] - The maximum number of completed or canceled matches
    * to return in the response. If not set, all matches returned could be
    * completed or canceled.
    * Value must be between "0" and "500".
    *
    * [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 [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}) {
+  async.Future<TurnBasedMatchList> list({core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (includeMatchData != null) {
       _queryParams["includeMatchData"] = ["${includeMatchData}"];
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxCompletedMatches != null) {
       _queryParams["maxCompletedMatches"] = ["${maxCompletedMatches}"];
     }
     if (maxResults != null) {
@@ skipping 18 matching lines @@
   /**
    * Create a rematch of a match that was previously completed, with the same
    * participants. This can be called by only one player on a match still in
    * their list; the player must have called Finish first. Returns the newly
    * created match; it will be the caller's turn.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [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 [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}) {
+  async.Future<TurnBasedMatchRematch> rematch(core.String matchId, {core.String consistencyToken, core.String language, core.String requestId}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (matchId == null) {
       throw new core.ArgumentError("Parameter matchId is required.");
     }
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (requestId != null) {
       _queryParams["requestId"] = [requestId];
     }
 
     _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));
   }
 
   /**
    * Returns turn-based matches the player is or was involved in that changed
    * since the last sync call, with the least recent changes coming first.
    * Matches that should be removed from the local cache will have a status of
    * MATCH_DELETED.
    *
    * Request parameters:
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [includeMatchData] - True if match data should be returned in the response.
    * Note that not all data will necessarily be returned if include_match_data
    * is true; the server may decide to only return data for some of the matches
    * to limit download size for the client. The remainder of the data for these
    * matches will be retrievable on request.
    *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * [maxCompletedMatches] - The maximum number of completed or canceled matches
    * to return in the response. If not set, all matches returned could be
    * completed or canceled.
    * Value must be between "0" and "500".
    *
    * [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 [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}) {
+  async.Future<TurnBasedMatchSync> sync({core.String consistencyToken, 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 = commons.DownloadOptions.Metadata;
     var _body = null;
 
+    if (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (includeMatchData != null) {
       _queryParams["includeMatchData"] = ["${includeMatchData}"];
     }
     if (language != null) {
       _queryParams["language"] = [language];
     }
     if (maxCompletedMatches != null) {
       _queryParams["maxCompletedMatches"] = ["${maxCompletedMatches}"];
     }
     if (maxResults != null) {
@@ skipping 17 matching lines @@
 
   /**
    * Commit the results of a player turn.
    *
    * [request] - The metadata request object.
    *
    * Request parameters:
    *
    * [matchId] - The ID of the match.
    *
+   * [consistencyToken] - The last-seen mutation timestamp.
+   *
    * [language] - The preferred language to use for strings returned by this
    * method.
    *
    * Completes with a [TurnBasedMatch].
    *
    * 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}) {
+  async.Future<TurnBasedMatch> takeTurn(TurnBasedMatchTurn request, core.String matchId, {core.String consistencyToken, core.String language}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     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 (consistencyToken != null) {
+      _queryParams["consistencyToken"] = [consistencyToken];
+    }
     if (language != null) {
       _queryParams["language"] = [language];
     }
 
     _url = 'turnbasedmatches/' + commons.Escaper.ecapeVariable('$matchId') + '/turn';
 
     var _response = _requester.request(_url,
                                        "PUT",
                                        body: _body,
                                        queryParams: _queryParams,
@@ skipping 3595 matching lines @@
 }
 
 /** A push token ID for iOS devices. */
 class PushTokenIdIos {
   /**
    * Device token supplied by an iOS system call to register for remote
    * notifications. Encode this field as web-safe base64.
    */
   core.String apnsDeviceToken;
   core.List<core.int> get apnsDeviceTokenAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(apnsDeviceToken);
+    return convert.BASE64.decode(apnsDeviceToken);
   }
 
   void set apnsDeviceTokenAsBytes(core.List<core.int> _bytes) {
-    apnsDeviceToken = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    apnsDeviceToken = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * Indicates whether this token should be used for the production or sandbox
    * APNS server.
    */
   core.String apnsEnvironment;
 
   PushTokenIdIos();
 
   PushTokenIdIos.fromJson(core.Map _json) {
@@ skipping 389 matching lines @@
 
 /** This is a JSON template for a Quest Milestone resource. */
 class QuestMilestone {
   /**
    * The completion reward data of the milestone, represented as a
    * Base64-encoded string. This is a developer-specified binary blob with size
    * between 0 and 2 KB before encoding.
    */
   core.String completionRewardData;
   core.List<core.int> get completionRewardDataAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(completionRewardData);
+    return convert.BASE64.decode(completionRewardData);
   }
 
   void set completionRewardDataAsBytes(core.List<core.int> _bytes) {
-    completionRewardData = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    completionRewardData = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /** The criteria of the milestone. */
   core.List<QuestCriterion> criteria;
   /** The milestone ID. */
   core.String id;
   /**
    * Uniquely identifies the type of this resource. Value is always the fixed
    * string games#questMilestone.
    */
   core.String kind;
@@ skipping 1758 matching lines @@
 }
 
 /** This is a JSON template for a turn-based match data object. */
 class TurnBasedMatchData {
   /**
    * The byte representation of the data (limited to 128 kB), as a
    * Base64-encoded string with the URL_SAFE encoding option.
    */
   core.String data;
   core.List<core.int> get dataAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(data);
+    return convert.BASE64.decode(data);
   }
 
   void set dataAsBytes(core.List<core.int> _bytes) {
-    data = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    data = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * True if this match has data available but it wasn't returned in a list
    * response; fetching the match individually will retrieve this data.
    */
   core.bool dataAvailable;
   /**
    * Uniquely identifies the type of this resource. Value is always the fixed
    * string games#turnBasedMatchData.
    */
@@ skipping 29 matching lines @@
 }
 
 /** This is a JSON template for sending a turn-based match data object. */
 class TurnBasedMatchDataRequest {
   /**
    * The byte representation of the data (limited to 128 kB), as a
    * Base64-encoded string with the URL_SAFE encoding option.
    */
   core.String data;
   core.List<core.int> get dataAsBytes {
-    return crypto.CryptoUtils.base64StringToBytes(data);
+    return convert.BASE64.decode(data);
   }
 
   void set dataAsBytes(core.List<core.int> _bytes) {
-    data = crypto.CryptoUtils.bytesToBase64(_bytes, urlSafe: true);
+    data = convert.BASE64.encode(_bytes).replaceAll("/", "_").replaceAll("+", "-");
   }
   /**
    * Uniquely identifies the type of this resource. Value is always the fixed
    * string games#turnBasedMatchDataRequest.
    */
   core.String kind;
 
   TurnBasedMatchDataRequest();
 
   TurnBasedMatchDataRequest.fromJson(core.Map _json) {
@@ skipping 402 matching lines @@
     }
     if (pendingParticipantId != null) {
       _json["pendingParticipantId"] = pendingParticipantId;
     }
     if (results != null) {
       _json["results"] = results.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }