Api-roll 33: 2016-03-14

generated/googleapis_beta/lib/appengine/v1beta5.dart

+// This is a generated file (see the discoveryapis_generator project).
+
+library googleapis_beta.appengine.v1beta5;
+
+import 'dart:core' as core;
+import 'dart:async' as async;
+import 'dart:convert' as convert;
+
+import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
+import 'package:http/http.dart' as http;
+
+export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
+    ApiRequestError, DetailedApiRequestError;
+
+const core.String USER_AGENT = 'dart-api-client appengine/v1beta5';
+
+/**
+ * The Google App Engine Admin API enables developers to provision and manage
+ * their App Engine applications.
+ */
+class AppengineApi {
+  /** View and manage your data across Google Cloud Platform services */
+  static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
+
+
+  final commons.ApiRequester _requester;
+
+  AppsResourceApi get apps => new AppsResourceApi(_requester);
+
+  AppengineApi(http.Client client, {core.String rootUrl: "https://appengine.googleapis.com/", core.String servicePath: ""}) :
+      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
+}
+
+
+class AppsResourceApi {
+  final commons.ApiRequester _requester;
+
+  AppsOperationsResourceApi get operations => new AppsOperationsResourceApi(_requester);
+  AppsServicesResourceApi get services => new AppsServicesResourceApi(_requester);
+
+  AppsResourceApi(commons.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Gets information about an application.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the application to get. For example:
+   * "apps/myapp".
+   *
+   * [ensureResourcesExist] - Certain resources associated with an application
+   * are created on-demand. Controls whether these resources should be created
+   * when performing the `GET` operation. If specified and any resources could
+   * not be created, the request will fail with an error code. Additionally,
+   * this parameter can cause the request to take longer to complete. Note: This
+   * parameter will be deprecated in a future version of the API.
+   *
+   * 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 appsId, {core.bool ensureResourcesExist}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (ensureResourcesExist != null) {
+      _queryParams["ensureResourcesExist"] = ["${ensureResourcesExist}"];
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId');
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Application.fromJson(data));
+  }
+
+}
+
+
+class AppsOperationsResourceApi {
+  final commons.ApiRequester _requester;
+
+  AppsOperationsResourceApi(commons.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Gets the latest state of a long-running operation. Clients can use this
+   * method to poll the operation result at intervals as recommended by the API
+   * service.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. The name of the operation resource.
+   *
+   * [operationsId] - Part of `name`. See documentation of `appsId`.
+   *
+   * Completes with a [Operation].
+   *
+   * 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<Operation> get(core.String appsId, core.String operationsId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (operationsId == null) {
+      throw new core.ArgumentError("Parameter operationsId is required.");
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/operations/' + commons.Escaper.ecapeVariable('$operationsId');
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Operation.fromJson(data));
+  }
+
+  /**
+   * Lists operations that match the specified filter in the request. If the
+   * server doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the
+   * `name` binding below allows API services to override the binding to use
+   * different resource name schemes, such as `users / * /operations`.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. The name of the operation collection.
+   *
+   * [filter] - The standard list filter.
+   *
+   * [pageSize] - The standard list page size.
+   *
+   * [pageToken] - The standard list page token.
+   *
+   * Completes with a [ListOperationsResponse].
+   *
+   * 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<ListOperationsResponse> list(core.String appsId, {core.String filter, core.int pageSize, 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 (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (filter != null) {
+      _queryParams["filter"] = [filter];
+    }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/operations';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new ListOperationsResponse.fromJson(data));
+  }
+
+}
+
+
+class AppsServicesResourceApi {
+  final commons.ApiRequester _requester;
+
+  AppsServicesVersionsResourceApi get versions => new AppsServicesVersionsResourceApi(_requester);
+
+  AppsServicesResourceApi(commons.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Deletes a service and all enclosed versions.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource requested. For example:
+   * "apps/myapp/services/default".
+   *
+   * [servicesId] - Part of `name`. See documentation of `appsId`.
+   *
+   * Completes with a [Operation].
+   *
+   * 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<Operation> delete(core.String appsId, core.String servicesId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (servicesId == null) {
+      throw new core.ArgumentError("Parameter servicesId is required.");
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services/' + commons.Escaper.ecapeVariable('$servicesId');
+
+    var _response = _requester.request(_url,
+                                       "DELETE",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Operation.fromJson(data));
+  }
+
+  /**
+   * Gets the current configuration of the service.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource requested. For example:
+   * "apps/myapp/services/default".
+   *
+   * [servicesId] - Part of `name`. See documentation of `appsId`.
+   *
+   * Completes with a [Service].
+   *
+   * 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<Service> get(core.String appsId, core.String servicesId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (servicesId == null) {
+      throw new core.ArgumentError("Parameter servicesId is required.");
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services/' + commons.Escaper.ecapeVariable('$servicesId');
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Service.fromJson(data));
+  }
+
+  /**
+   * Lists all the services in the application.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource requested. For example:
+   * "apps/myapp".
+   *
+   * [pageSize] - Maximum results to return per page.
+   *
+   * [pageToken] - Continuation token for fetching the next page of results.
+   *
+   * Completes with a [ListServicesResponse].
+   *
+   * 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<ListServicesResponse> list(core.String appsId, {core.int pageSize, 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 (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new ListServicesResponse.fromJson(data));
+  }
+
+  /**
+   * Updates the configuration of the specified service.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource to update. For example:
+   * "apps/myapp/services/default".
+   *
+   * [servicesId] - Part of `name`. See documentation of `appsId`.
+   *
+   * [mask] - Standard field mask for the set of fields to be updated.
+   *
+   * [migrateTraffic] - Whether to use Traffic Migration to shift traffic
+   * gradually. Traffic can only be migrated from a single version to another
+   * single version.
+   *
+   * Completes with a [Operation].
+   *
+   * 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<Operation> patch(Service request, core.String appsId, core.String servicesId, {core.String mask, core.bool migrateTraffic}) {
+    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 (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (servicesId == null) {
+      throw new core.ArgumentError("Parameter servicesId is required.");
+    }
+    if (mask != null) {
+      _queryParams["mask"] = [mask];
+    }
+    if (migrateTraffic != null) {
+      _queryParams["migrateTraffic"] = ["${migrateTraffic}"];
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services/' + commons.Escaper.ecapeVariable('$servicesId');
+
+    var _response = _requester.request(_url,
+                                       "PATCH",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Operation.fromJson(data));
+  }
+
+}
+
+
+class AppsServicesVersionsResourceApi {
+  final commons.ApiRequester _requester;
+
+  AppsServicesVersionsResourceApi(commons.ApiRequester client) : 
+      _requester = client;
+
+  /**
+   * Deploys new code and resource files to a version.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource to update. For example:
+   * "apps/myapp/services/default".
+   *
+   * [servicesId] - Part of `name`. See documentation of `appsId`.
+   *
+   * Completes with a [Operation].
+   *
+   * 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<Operation> create(Version request, core.String appsId, core.String servicesId) {
+    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 (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (servicesId == null) {
+      throw new core.ArgumentError("Parameter servicesId is required.");
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services/' + commons.Escaper.ecapeVariable('$servicesId') + '/versions';
+
+    var _response = _requester.request(_url,
+                                       "POST",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Operation.fromJson(data));
+  }
+
+  /**
+   * Deletes an existing version.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource requested. For example:
+   * "apps/myapp/services/default/versions/v1".
+   *
+   * [servicesId] - Part of `name`. See documentation of `appsId`.
+   *
+   * [versionsId] - Part of `name`. See documentation of `appsId`.
+   *
+   * Completes with a [Operation].
+   *
+   * 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<Operation> delete(core.String appsId, core.String servicesId, core.String versionsId) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (servicesId == null) {
+      throw new core.ArgumentError("Parameter servicesId is required.");
+    }
+    if (versionsId == null) {
+      throw new core.ArgumentError("Parameter versionsId is required.");
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services/' + commons.Escaper.ecapeVariable('$servicesId') + '/versions/' + commons.Escaper.ecapeVariable('$versionsId');
+
+    var _response = _requester.request(_url,
+                                       "DELETE",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Operation.fromJson(data));
+  }
+
+  /**
+   * Gets application deployment information.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource requested. For example:
+   * "apps/myapp/services/default/versions/v1".
+   *
+   * [servicesId] - Part of `name`. See documentation of `appsId`.
+   *
+   * [versionsId] - Part of `name`. See documentation of `appsId`.
+   *
+   * [view] - Controls the set of fields returned in the `Get` response.
+   * Possible string values are:
+   * - "BASIC" : A BASIC.
+   * - "FULL" : A FULL.
+   *
+   * Completes with a [Version].
+   *
+   * 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<Version> get(core.String appsId, core.String servicesId, core.String versionsId, {core.String view}) {
+    var _url = null;
+    var _queryParams = new core.Map();
+    var _uploadMedia = null;
+    var _uploadOptions = null;
+    var _downloadOptions = commons.DownloadOptions.Metadata;
+    var _body = null;
+
+    if (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (servicesId == null) {
+      throw new core.ArgumentError("Parameter servicesId is required.");
+    }
+    if (versionsId == null) {
+      throw new core.ArgumentError("Parameter versionsId is required.");
+    }
+    if (view != null) {
+      _queryParams["view"] = [view];
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services/' + commons.Escaper.ecapeVariable('$servicesId') + '/versions/' + commons.Escaper.ecapeVariable('$versionsId');
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Version.fromJson(data));
+  }
+
+  /**
+   * Lists the versions of a service.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource requested. For example:
+   * "apps/myapp/services/default".
+   *
+   * [servicesId] - Part of `name`. See documentation of `appsId`.
+   *
+   * [view] - Controls the set of fields returned in the `List` response.
+   * Possible string values are:
+   * - "BASIC" : A BASIC.
+   * - "FULL" : A FULL.
+   *
+   * [pageSize] - Maximum results to return per page.
+   *
+   * [pageToken] - Continuation token for fetching the next page of results.
+   *
+   * Completes with a [ListVersionsResponse].
+   *
+   * 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<ListVersionsResponse> list(core.String appsId, core.String servicesId, {core.String view, core.int pageSize, 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 (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (servicesId == null) {
+      throw new core.ArgumentError("Parameter servicesId is required.");
+    }
+    if (view != null) {
+      _queryParams["view"] = [view];
+    }
+    if (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services/' + commons.Escaper.ecapeVariable('$servicesId') + '/versions';
+
+    var _response = _requester.request(_url,
+                                       "GET",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new ListVersionsResponse.fromJson(data));
+  }
+
+  /**
+   * Updates an existing version. Note: UNIMPLEMENTED.
+   *
+   * [request] - The metadata request object.
+   *
+   * Request parameters:
+   *
+   * [appsId] - Part of `name`. Name of the resource to update. For example:
+   * "apps/myapp/services/default/versions/1".
+   *
+   * [servicesId] - Part of `name`. See documentation of `appsId`.
+   *
+   * [versionsId] - Part of `name`. See documentation of `appsId`.
+   *
+   * [mask] - Standard field mask for the set of fields to be updated.
+   *
+   * Completes with a [Version].
+   *
+   * 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<Version> patch(Version request, core.String appsId, core.String servicesId, core.String versionsId, {core.String mask}) {
+    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 (appsId == null) {
+      throw new core.ArgumentError("Parameter appsId is required.");
+    }
+    if (servicesId == null) {
+      throw new core.ArgumentError("Parameter servicesId is required.");
+    }
+    if (versionsId == null) {
+      throw new core.ArgumentError("Parameter versionsId is required.");
+    }
+    if (mask != null) {
+      _queryParams["mask"] = [mask];
+    }
+
+    _url = 'v1beta5/apps/' + commons.Escaper.ecapeVariable('$appsId') + '/services/' + commons.Escaper.ecapeVariable('$servicesId') + '/versions/' + commons.Escaper.ecapeVariable('$versionsId');
+
+    var _response = _requester.request(_url,
+                                       "PATCH",
+                                       body: _body,
+                                       queryParams: _queryParams,
+                                       uploadOptions: _uploadOptions,
+                                       uploadMedia: _uploadMedia,
+                                       downloadOptions: _downloadOptions);
+    return _response.then((data) => new Version.fromJson(data));
+  }
+
+}
+
+
+
+/** API Serving configuration for Cloud Endpoints. */
+class ApiConfigHandler {
+  /**
+   * For users not logged in, how to handle access to resources with required
+   * login. Defaults to "redirect".
+   * Possible string values are:
+   * - "AUTH_FAIL_ACTION_UNSPECIFIED" : A AUTH_FAIL_ACTION_UNSPECIFIED.
+   * - "AUTH_FAIL_ACTION_REDIRECT" : A AUTH_FAIL_ACTION_REDIRECT.
+   * - "AUTH_FAIL_ACTION_UNAUTHORIZED" : A AUTH_FAIL_ACTION_UNAUTHORIZED.
+   */
+  core.String authFailAction;
+  /**
+   * What level of login is required to access this resource. Default is
+   * "optional".
+   * Possible string values are:
+   * - "LOGIN_UNSPECIFIED" : A LOGIN_UNSPECIFIED.
+   * - "LOGIN_OPTIONAL" : A LOGIN_OPTIONAL.
+   * - "LOGIN_ADMIN" : A LOGIN_ADMIN.
+   * - "LOGIN_REQUIRED" : A LOGIN_REQUIRED.
+   */
+  core.String login;
+  /** Specifies the path to the script from the application root directory. */
+  core.String script;
+  /**
+   * Configures whether security (HTTPS) should be enforced for this URL.
+   * Possible string values are:
+   * - "SECURE_UNSPECIFIED" : A SECURE_UNSPECIFIED.
+   * - "SECURE_DEFAULT" : A SECURE_DEFAULT.
+   * - "SECURE_NEVER" : A SECURE_NEVER.
+   * - "SECURE_OPTIONAL" : A SECURE_OPTIONAL.
+   * - "SECURE_ALWAYS" : A SECURE_ALWAYS.
+   */
+  core.String securityLevel;
+  /** URL to serve the endpoint at. */
+  core.String url;
+
+  ApiConfigHandler();
+
+  ApiConfigHandler.fromJson(core.Map _json) {
+    if (_json.containsKey("authFailAction")) {
+      authFailAction = _json["authFailAction"];
+    }
+    if (_json.containsKey("login")) {
+      login = _json["login"];
+    }
+    if (_json.containsKey("script")) {
+      script = _json["script"];
+    }
+    if (_json.containsKey("securityLevel")) {
+      securityLevel = _json["securityLevel"];
+    }
+    if (_json.containsKey("url")) {
+      url = _json["url"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (authFailAction != null) {
+      _json["authFailAction"] = authFailAction;
+    }
+    if (login != null) {
+      _json["login"] = login;
+    }
+    if (script != null) {
+      _json["script"] = script;
+    }
+    if (securityLevel != null) {
+      _json["securityLevel"] = securityLevel;
+    }
+    if (url != null) {
+      _json["url"] = url;
+    }
+    return _json;
+  }
+}
+
+/** Use Google Cloud Endpoints to handle requests. */
+class ApiEndpointHandler {
+  /** Specifies the path to the script from the application root directory. */
+  core.String scriptPath;
+
+  ApiEndpointHandler();
+
+  ApiEndpointHandler.fromJson(core.Map _json) {
+    if (_json.containsKey("scriptPath")) {
+      scriptPath = _json["scriptPath"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (scriptPath != null) {
+      _json["scriptPath"] = scriptPath;
+    }
+    return _json;
+  }
+}
+
+/**
+ * An Application contains the top-level configuration of an App Engine
+ * application.
+ */
+class Application {
+  /**
+   * If set, only users from the specified Google Apps authentication domain may
+   * access the application. If not set, any Google Account may access the
+   * application.
+   */
+  core.String authDomain;
+  /**
+   * A Google Cloud Storage bucket which can be used for storing files
+   * associated with an application. This bucket is associated with the
+   * application and can be used by the gcloud deployment commands. @OutputOnly
+   */
+  core.String codeBucket;
+  /**
+   * A Google Cloud Storage bucket which can be used by the application to store
+   * content. @OutputOnly
+   */
+  core.String defaultBucket;
+  /** Determines the cookie expiration policy for the application. */
+  core.String defaultCookieExpiration;
+  /**
+   * The hostname used to reach the application, as resolved by App Engine.
+   * @OutputOnly
+   */
+  core.String defaultHostname;
+  /**
+   * HTTP path dispatch rules for requests to the app that do not explicitly
+   * target a service or version. The rules are order-dependent.
+   */
+  core.List<UrlDispatchRule> dispatchRules;
+  /** The relative name/path of the application. Example: "myapp". */
+  core.String id;
+  /**
+   * The location from which the application will be run. Choices are "us" for
+   * United States and "eu" for European Union. Application instances will run
+   * out of data centers in the chosen location and all of the application's End
+   * User Content will be stored at rest in the chosen location. The default is
+   * "us".
+   */
+  core.String location;
+  /**
+   * The full path to the application in the API. Example: "apps/myapp".
+   * @OutputOnly
+   */
+  core.String name;
+
+  Application();
+
+  Application.fromJson(core.Map _json) {
+    if (_json.containsKey("authDomain")) {
+      authDomain = _json["authDomain"];
+    }
+    if (_json.containsKey("codeBucket")) {
+      codeBucket = _json["codeBucket"];
+    }
+    if (_json.containsKey("defaultBucket")) {
+      defaultBucket = _json["defaultBucket"];
+    }
+    if (_json.containsKey("defaultCookieExpiration")) {
+      defaultCookieExpiration = _json["defaultCookieExpiration"];
+    }
+    if (_json.containsKey("defaultHostname")) {
+      defaultHostname = _json["defaultHostname"];
+    }
+    if (_json.containsKey("dispatchRules")) {
+      dispatchRules = _json["dispatchRules"].map((value) => new UrlDispatchRule.fromJson(value)).toList();
+    }
+    if (_json.containsKey("id")) {
+      id = _json["id"];
+    }
+    if (_json.containsKey("location")) {
+      location = _json["location"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (authDomain != null) {
+      _json["authDomain"] = authDomain;
+    }
+    if (codeBucket != null) {
+      _json["codeBucket"] = codeBucket;
+    }
+    if (defaultBucket != null) {
+      _json["defaultBucket"] = defaultBucket;
+    }
+    if (defaultCookieExpiration != null) {
+      _json["defaultCookieExpiration"] = defaultCookieExpiration;
+    }
+    if (defaultHostname != null) {
+      _json["defaultHostname"] = defaultHostname;
+    }
+    if (dispatchRules != null) {
+      _json["dispatchRules"] = dispatchRules.map((value) => (value).toJson()).toList();
+    }
+    if (id != null) {
+      _json["id"] = id;
+    }
+    if (location != null) {
+      _json["location"] = location;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    return _json;
+  }
+}
+
+/**
+ * Automatic scaling is the scaling policy that App Engine has used since its
+ * inception. It is based on request rate, response latencies, and other
+ * application metrics.
+ */
+class AutomaticScaling {
+  /**
+   * The amount of time that the
+   * [Autoscaler](https://cloud.google.com/compute/docs/autoscaler/) should wait
+   * between changes to the number of virtual machines. Applies only to the VM
+   * runtime.
+   */
+  core.String coolDownPeriod;
+  /** Target scaling by CPU usage. */
+  CpuUtilization cpuUtilization;
+  /** Target scaling by disk usage. */
+  DiskUtilization diskUtilization;
+  /**
+   * The number of concurrent requests an automatic scaling instance can accept
+   * before the scheduler spawns a new instance. Default value is chosen based
+   * on the runtime.
+   */
+  core.int maxConcurrentRequests;
+  /**
+   * The maximum number of idle instances that App Engine should maintain for
+   * this version.
+   */
+  core.int maxIdleInstances;
+  /**
+   * The maximum amount of time that App Engine should allow a request to wait
+   * in the pending queue before starting a new instance to handle it.
+   */
+  core.String maxPendingLatency;
+  /**
+   * Max number of instances that App Engine should start to handle requests.
+   */
+  core.int maxTotalInstances;
+  /**
+   * The minimum number of idle instances that App Engine should maintain for
+   * this version. Only applies to the default version of a service, since other
+   * versions are not expected to receive significant traffic.
+   */
+  core.int minIdleInstances;
+  /**
+   * The minimum amount of time that App Engine should allow a request to wait
+   * in the pending queue before starting a new instance to handle it.
+   */
+  core.String minPendingLatency;
+  /** Minimum number of instances that App Engine should maintain. */
+  core.int minTotalInstances;
+  /** Target scaling by network usage. */
+  NetworkUtilization networkUtilization;
+  /** Target scaling by request utilization. */
+  RequestUtilization requestUtilization;
+
+  AutomaticScaling();
+
+  AutomaticScaling.fromJson(core.Map _json) {
+    if (_json.containsKey("coolDownPeriod")) {
+      coolDownPeriod = _json["coolDownPeriod"];
+    }
+    if (_json.containsKey("cpuUtilization")) {
+      cpuUtilization = new CpuUtilization.fromJson(_json["cpuUtilization"]);
+    }
+    if (_json.containsKey("diskUtilization")) {
+      diskUtilization = new DiskUtilization.fromJson(_json["diskUtilization"]);
+    }
+    if (_json.containsKey("maxConcurrentRequests")) {
+      maxConcurrentRequests = _json["maxConcurrentRequests"];
+    }
+    if (_json.containsKey("maxIdleInstances")) {
+      maxIdleInstances = _json["maxIdleInstances"];
+    }
+    if (_json.containsKey("maxPendingLatency")) {
+      maxPendingLatency = _json["maxPendingLatency"];
+    }
+    if (_json.containsKey("maxTotalInstances")) {
+      maxTotalInstances = _json["maxTotalInstances"];
+    }
+    if (_json.containsKey("minIdleInstances")) {
+      minIdleInstances = _json["minIdleInstances"];
+    }
+    if (_json.containsKey("minPendingLatency")) {
+      minPendingLatency = _json["minPendingLatency"];
+    }
+    if (_json.containsKey("minTotalInstances")) {
+      minTotalInstances = _json["minTotalInstances"];
+    }
+    if (_json.containsKey("networkUtilization")) {
+      networkUtilization = new NetworkUtilization.fromJson(_json["networkUtilization"]);
+    }
+    if (_json.containsKey("requestUtilization")) {
+      requestUtilization = new RequestUtilization.fromJson(_json["requestUtilization"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (coolDownPeriod != null) {
+      _json["coolDownPeriod"] = coolDownPeriod;
+    }
+    if (cpuUtilization != null) {
+      _json["cpuUtilization"] = (cpuUtilization).toJson();
+    }
+    if (diskUtilization != null) {
+      _json["diskUtilization"] = (diskUtilization).toJson();
+    }
+    if (maxConcurrentRequests != null) {
+      _json["maxConcurrentRequests"] = maxConcurrentRequests;
+    }
+    if (maxIdleInstances != null) {
+      _json["maxIdleInstances"] = maxIdleInstances;
+    }
+    if (maxPendingLatency != null) {
+      _json["maxPendingLatency"] = maxPendingLatency;
+    }
+    if (maxTotalInstances != null) {
+      _json["maxTotalInstances"] = maxTotalInstances;
+    }
+    if (minIdleInstances != null) {
+      _json["minIdleInstances"] = minIdleInstances;
+    }
+    if (minPendingLatency != null) {
+      _json["minPendingLatency"] = minPendingLatency;
+    }
+    if (minTotalInstances != null) {
+      _json["minTotalInstances"] = minTotalInstances;
+    }
+    if (networkUtilization != null) {
+      _json["networkUtilization"] = (networkUtilization).toJson();
+    }
+    if (requestUtilization != null) {
+      _json["requestUtilization"] = (requestUtilization).toJson();
+    }
+    return _json;
+  }
+}
+
+/**
+ * A service with basic scaling will create an instance when the application
+ * receives a request. The instance will be turned down when the app becomes
+ * idle. Basic scaling is ideal for work that is intermittent or driven by user
+ * activity.
+ */
+class BasicScaling {
+  /**
+   * The instance will be shut down this amount of time after receiving its last
+   * request.
+   */
+  core.String idleTimeout;
+  /**
+   * The maximum number of instances for App Engine to create for this version.
+   */
+  core.int maxInstances;
+
+  BasicScaling();
+
+  BasicScaling.fromJson(core.Map _json) {
+    if (_json.containsKey("idleTimeout")) {
+      idleTimeout = _json["idleTimeout"];
+    }
+    if (_json.containsKey("maxInstances")) {
+      maxInstances = _json["maxInstances"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (idleTimeout != null) {
+      _json["idleTimeout"] = idleTimeout;
+    }
+    if (maxInstances != null) {
+      _json["maxInstances"] = maxInstances;
+    }
+    return _json;
+  }
+}
+
+/**
+ * A Docker (container) image which should be used to start the application.
+ */
+class ContainerInfo {
+  /**
+   * Reference to a hosted container image. Must be a URI to a resource in a
+   * Docker repository. Must be fully qualified, including tag or digest. e.g.
+   * gcr.io/my-project/image:tag or gcr.io/my-project/image@digest
+   */
+  core.String image;
+
+  ContainerInfo();
+
+  ContainerInfo.fromJson(core.Map _json) {
+    if (_json.containsKey("image")) {
+      image = _json["image"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (image != null) {
+      _json["image"] = image;
+    }
+    return _json;
+  }
+}
+
+/** Target scaling by CPU usage. */
+class CpuUtilization {
+  /** The period of time over which CPU utilization is calculated. */
+  core.String aggregationWindowLength;
+  /** Target (0-1) CPU utilization ratio to maintain when scaling. */
+  core.double targetUtilization;
+
+  CpuUtilization();
+
+  CpuUtilization.fromJson(core.Map _json) {
+    if (_json.containsKey("aggregationWindowLength")) {
+      aggregationWindowLength = _json["aggregationWindowLength"];
+    }
+    if (_json.containsKey("targetUtilization")) {
+      targetUtilization = _json["targetUtilization"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (aggregationWindowLength != null) {
+      _json["aggregationWindowLength"] = aggregationWindowLength;
+    }
+    if (targetUtilization != null) {
+      _json["targetUtilization"] = targetUtilization;
+    }
+    return _json;
+  }
+}
+
+/** Code and application artifacts used to deploy a version to App Engine. */
+class Deployment {
+  /**
+   * If supplied, a docker (container) image which should be used to start the
+   * application. Only applicable to the 'vm' runtime.
+   */
+  ContainerInfo container;
+  /**
+   * A manifest of files stored in Google Cloud Storage which should be included
+   * as part of this application. All files must be readable using the
+   * credentials supplied with this call.
+   */
+  core.Map<core.String, FileInfo> files;
+  /**
+   * The origin of the source code for this deployment. There can be more than
+   * one source reference per Version if source code is distributed among
+   * multiple repositories.
+   */
+  core.List<SourceReference> sourceReferences;
+
+  Deployment();
+
+  Deployment.fromJson(core.Map _json) {
+    if (_json.containsKey("container")) {
+      container = new ContainerInfo.fromJson(_json["container"]);
+    }
+    if (_json.containsKey("files")) {
+      files = commons.mapMap(_json["files"], (item) => new FileInfo.fromJson(item));
+    }
+    if (_json.containsKey("sourceReferences")) {
+      sourceReferences = _json["sourceReferences"].map((value) => new SourceReference.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (container != null) {
+      _json["container"] = (container).toJson();
+    }
+    if (files != null) {
+      _json["files"] = commons.mapMap(files, (item) => (item).toJson());
+    }
+    if (sourceReferences != null) {
+      _json["sourceReferences"] = sourceReferences.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/** Target scaling by disk usage (for VM runtimes only). */
+class DiskUtilization {
+  /** Target bytes per second read. */
+  core.int targetReadBytesPerSec;
+  /** Target ops per second read. */
+  core.int targetReadOpsPerSec;
+  /** Target bytes per second written. */
+  core.int targetWriteBytesPerSec;
+  /** Target ops per second written. */
+  core.int targetWriteOpsPerSec;
+
+  DiskUtilization();
+
+  DiskUtilization.fromJson(core.Map _json) {
+    if (_json.containsKey("targetReadBytesPerSec")) {
+      targetReadBytesPerSec = _json["targetReadBytesPerSec"];
+    }
+    if (_json.containsKey("targetReadOpsPerSec")) {
+      targetReadOpsPerSec = _json["targetReadOpsPerSec"];
+    }
+    if (_json.containsKey("targetWriteBytesPerSec")) {
+      targetWriteBytesPerSec = _json["targetWriteBytesPerSec"];
+    }
+    if (_json.containsKey("targetWriteOpsPerSec")) {
+      targetWriteOpsPerSec = _json["targetWriteOpsPerSec"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (targetReadBytesPerSec != null) {
+      _json["targetReadBytesPerSec"] = targetReadBytesPerSec;
+    }
+    if (targetReadOpsPerSec != null) {
+      _json["targetReadOpsPerSec"] = targetReadOpsPerSec;
+    }
+    if (targetWriteBytesPerSec != null) {
+      _json["targetWriteBytesPerSec"] = targetWriteBytesPerSec;
+    }
+    if (targetWriteOpsPerSec != null) {
+      _json["targetWriteOpsPerSec"] = targetWriteOpsPerSec;
+    }
+    return _json;
+  }
+}
+
+/** A custom static error page to be served when an error occurs. */
+class ErrorHandler {
+  /**
+   * The error condition this handler applies to.
+   * Possible string values are:
+   * - "ERROR_CODE_UNSPECIFIED" : A ERROR_CODE_UNSPECIFIED.
+   * - "ERROR_CODE_DEFAULT" : A ERROR_CODE_DEFAULT.
+   * - "ERROR_CODE_OVER_QUOTA" : A ERROR_CODE_OVER_QUOTA.
+   * - "ERROR_CODE_DOS_API_DENIAL" : A ERROR_CODE_DOS_API_DENIAL.
+   * - "ERROR_CODE_TIMEOUT" : A ERROR_CODE_TIMEOUT.
+   */
+  core.String errorCode;
+  /** MIME type of file. If unspecified, "text/html" is assumed. */
+  core.String mimeType;
+  /** Static file content to be served for this error. */
+  core.String staticFile;
+
+  ErrorHandler();
+
+  ErrorHandler.fromJson(core.Map _json) {
+    if (_json.containsKey("errorCode")) {
+      errorCode = _json["errorCode"];
+    }
+    if (_json.containsKey("mimeType")) {
+      mimeType = _json["mimeType"];
+    }
+    if (_json.containsKey("staticFile")) {
+      staticFile = _json["staticFile"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (errorCode != null) {
+      _json["errorCode"] = errorCode;
+    }
+    if (mimeType != null) {
+      _json["mimeType"] = mimeType;
+    }
+    if (staticFile != null) {
+      _json["staticFile"] = staticFile;
+    }
+    return _json;
+  }
+}
+
+/** A single source file which is part of the application to be deployed. */
+class FileInfo {
+  /**
+   * The MIME type of the file; if unspecified, the value from Google Cloud
+   * Storage will be used.
+   */
+  core.String mimeType;
+  /** The SHA1 (160 bits) hash of the file in hex. */
+  core.String sha1Sum;
+  /**
+   * The URL source to use to fetch this file. Must be a URL to a resource in
+   * Google Cloud Storage in the form 'http(s)://storage.googleapis.com/\/\'.
+   */
+  core.String sourceUrl;
+
+  FileInfo();
+
+  FileInfo.fromJson(core.Map _json) {
+    if (_json.containsKey("mimeType")) {
+      mimeType = _json["mimeType"];
+    }
+    if (_json.containsKey("sha1Sum")) {
+      sha1Sum = _json["sha1Sum"];
+    }
+    if (_json.containsKey("sourceUrl")) {
+      sourceUrl = _json["sourceUrl"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (mimeType != null) {
+      _json["mimeType"] = mimeType;
+    }
+    if (sha1Sum != null) {
+      _json["sha1Sum"] = sha1Sum;
+    }
+    if (sourceUrl != null) {
+      _json["sourceUrl"] = sourceUrl;
+    }
+    return _json;
+  }
+}
+
+/**
+ * Configure health checking for the VM instances. Unhealthy VM instances will
+ * be killed and replaced with new instances.
+ */
+class HealthCheck {
+  /** The interval between health checks. */
+  core.String checkInterval;
+  /** Whether to explicitly disable health checks for this instance. */
+  core.bool disableHealthCheck;
+  /**
+   * The number of consecutive successful health checks before receiving
+   * traffic.
+   */
+  core.int healthyThreshold;
+  /**
+   * The host header to send when performing an HTTP health check (e.g.
+   * myapp.appspot.com)
+   */
+  core.String host;
+  /**
+   * The number of consecutive failed health checks before an instance is
+   * restarted.
+   */
+  core.int restartThreshold;
+  /** The amount of time before the health check is considered failed. */
+  core.String timeout;
+  /**
+   * The number of consecutive failed health checks before removing traffic.
+   */
+  core.int unhealthyThreshold;
+
+  HealthCheck();
+
+  HealthCheck.fromJson(core.Map _json) {
+    if (_json.containsKey("checkInterval")) {
+      checkInterval = _json["checkInterval"];
+    }
+    if (_json.containsKey("disableHealthCheck")) {
+      disableHealthCheck = _json["disableHealthCheck"];
+    }
+    if (_json.containsKey("healthyThreshold")) {
+      healthyThreshold = _json["healthyThreshold"];
+    }
+    if (_json.containsKey("host")) {
+      host = _json["host"];
+    }
+    if (_json.containsKey("restartThreshold")) {
+      restartThreshold = _json["restartThreshold"];
+    }
+    if (_json.containsKey("timeout")) {
+      timeout = _json["timeout"];
+    }
+    if (_json.containsKey("unhealthyThreshold")) {
+      unhealthyThreshold = _json["unhealthyThreshold"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (checkInterval != null) {
+      _json["checkInterval"] = checkInterval;
+    }
+    if (disableHealthCheck != null) {
+      _json["disableHealthCheck"] = disableHealthCheck;
+    }
+    if (healthyThreshold != null) {
+      _json["healthyThreshold"] = healthyThreshold;
+    }
+    if (host != null) {
+      _json["host"] = host;
+    }
+    if (restartThreshold != null) {
+      _json["restartThreshold"] = restartThreshold;
+    }
+    if (timeout != null) {
+      _json["timeout"] = timeout;
+    }
+    if (unhealthyThreshold != null) {
+      _json["unhealthyThreshold"] = unhealthyThreshold;
+    }
+    return _json;
+  }
+}
+
+/** A Python runtime third-party library required by the application. */
+class Library {
+  /** The name of the library, e.g. "PIL" or "django". */
+  core.String name;
+  /** The version of the library to select, or "latest". */
+  core.String version;
+
+  Library();
+
+  Library.fromJson(core.Map _json) {
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("version")) {
+      version = _json["version"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (version != null) {
+      _json["version"] = version;
+    }
+    return _json;
+  }
+}
+
+/** The response message for Operations.ListOperations. */
+class ListOperationsResponse {
+  /** The standard List next-page token. */
+  core.String nextPageToken;
+  /** A list of operations that matches the specified filter in the request. */
+  core.List<Operation> operations;
+
+  ListOperationsResponse();
+
+  ListOperationsResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("nextPageToken")) {
+      nextPageToken = _json["nextPageToken"];
+    }
+    if (_json.containsKey("operations")) {
+      operations = _json["operations"].map((value) => new Operation.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (nextPageToken != null) {
+      _json["nextPageToken"] = nextPageToken;
+    }
+    if (operations != null) {
+      _json["operations"] = operations.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/** Response message for `Services.ListServices`. */
+class ListServicesResponse {
+  /** Continuation token for fetching the next page of results. */
+  core.String nextPageToken;
+  /** The services belonging to the requested application. */
+  core.List<Service> services;
+
+  ListServicesResponse();
+
+  ListServicesResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("nextPageToken")) {
+      nextPageToken = _json["nextPageToken"];
+    }
+    if (_json.containsKey("services")) {
+      services = _json["services"].map((value) => new Service.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (nextPageToken != null) {
+      _json["nextPageToken"] = nextPageToken;
+    }
+    if (services != null) {
+      _json["services"] = services.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/** Response message for `Versions.ListVersions`. */
+class ListVersionsResponse {
+  /** Continuation token for fetching the next page of results. */
+  core.String nextPageToken;
+  /** The versions belonging to the requested application service. */
+  core.List<Version> versions;
+
+  ListVersionsResponse();
+
+  ListVersionsResponse.fromJson(core.Map _json) {
+    if (_json.containsKey("nextPageToken")) {
+      nextPageToken = _json["nextPageToken"];
+    }
+    if (_json.containsKey("versions")) {
+      versions = _json["versions"].map((value) => new Version.fromJson(value)).toList();
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (nextPageToken != null) {
+      _json["nextPageToken"] = nextPageToken;
+    }
+    if (versions != null) {
+      _json["versions"] = versions.map((value) => (value).toJson()).toList();
+    }
+    return _json;
+  }
+}
+
+/**
+ * A service with manual scaling runs continuously, allowing you to perform
+ * complex initialization and rely on the state of its memory over time.
+ */
+class ManualScaling {
+  /**
+   * The number of instances to assign to the service at the start. This number
+   * can later be altered by using the [Modules
+   * API](https://cloud.google.com/appengine/docs/python/modules/functions)
+   * `set_num_instances()` function.
+   */
+  core.int instances;
+
+  ManualScaling();
+
+  ManualScaling.fromJson(core.Map _json) {
+    if (_json.containsKey("instances")) {
+      instances = _json["instances"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (instances != null) {
+      _json["instances"] = instances;
+    }
+    return _json;
+  }
+}
+
+/** Used to specify extra network settings (for VM runtimes only). */
+class Network {
+  /**
+   * A list of ports (or port pairs) to forward from the VM into the app
+   * container.
+   */
+  core.List<core.String> forwardedPorts;
+  /** A tag to apply to the VM instance during creation. */
+  core.String instanceTag;
+  /**
+   * The Google Compute Engine network where the VMs will be created. If not
+   * specified, or empty, the network named "default" will be used. (The short
+   * name should be specified, not the resource path.)
+   */
+  core.String name;
+
+  Network();
+
+  Network.fromJson(core.Map _json) {
+    if (_json.containsKey("forwardedPorts")) {
+      forwardedPorts = _json["forwardedPorts"];
+    }
+    if (_json.containsKey("instanceTag")) {
+      instanceTag = _json["instanceTag"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (forwardedPorts != null) {
+      _json["forwardedPorts"] = forwardedPorts;
+    }
+    if (instanceTag != null) {
+      _json["instanceTag"] = instanceTag;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    return _json;
+  }
+}
+
+/** Target scaling by network usage (for VM runtimes only). */
+class NetworkUtilization {
+  /** Target bytes per second received. */
+  core.int targetReceivedBytesPerSec;
+  /** Target packets per second received. */
+  core.int targetReceivedPacketsPerSec;
+  /** Target bytes per second sent. */
+  core.int targetSentBytesPerSec;
+  /** Target packets per second sent. */
+  core.int targetSentPacketsPerSec;
+
+  NetworkUtilization();
+
+  NetworkUtilization.fromJson(core.Map _json) {
+    if (_json.containsKey("targetReceivedBytesPerSec")) {
+      targetReceivedBytesPerSec = _json["targetReceivedBytesPerSec"];
+    }
+    if (_json.containsKey("targetReceivedPacketsPerSec")) {
+      targetReceivedPacketsPerSec = _json["targetReceivedPacketsPerSec"];
+    }
+    if (_json.containsKey("targetSentBytesPerSec")) {
+      targetSentBytesPerSec = _json["targetSentBytesPerSec"];
+    }
+    if (_json.containsKey("targetSentPacketsPerSec")) {
+      targetSentPacketsPerSec = _json["targetSentPacketsPerSec"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (targetReceivedBytesPerSec != null) {
+      _json["targetReceivedBytesPerSec"] = targetReceivedBytesPerSec;
+    }
+    if (targetReceivedPacketsPerSec != null) {
+      _json["targetReceivedPacketsPerSec"] = targetReceivedPacketsPerSec;
+    }
+    if (targetSentBytesPerSec != null) {
+      _json["targetSentBytesPerSec"] = targetSentBytesPerSec;
+    }
+    if (targetSentPacketsPerSec != null) {
+      _json["targetSentPacketsPerSec"] = targetSentPacketsPerSec;
+    }
+    return _json;
+  }
+}
+
+/**
+ * This resource represents a long-running operation that is the result of a
+ * network API call.
+ */
+class Operation {
+  /**
+   * If the value is `false`, it means the operation is still in progress. If
+   * true, the operation is completed, and either `error` or `response` is
+   * available.
+   */
+  core.bool done;
+  /** The error result of the operation in case of failure. */
+  Status error;
+  /**
+   * Service-specific metadata associated with the operation. It typically
+   * contains progress information and common metadata such as create time. Some
+   * services might not provide such metadata. Any method that returns a
+   * long-running operation should document the metadata type, if any.
+   *
+   * The values for Object must be JSON objects. It can consist of `num`,
+   * `String`, `bool` and `null` as well as `Map` and `List` values.
+   */
+  core.Map<core.String, core.Object> metadata;
+  /**
+   * The server-assigned name, which is only unique within the same service that
+   * originally returns it. If you use the default HTTP mapping above, the
+   * `name` should have the format of `operations/some/unique/name`.
+   */
+  core.String name;
+  /**
+   * The normal response of the operation in case of success. If the original
+   * method returns no data on success, such as `Delete`, the response is
+   * `google.protobuf.Empty`. If the original method is standard
+   * `Get`/`Create`/`Update`, the response should be the resource. For other
+   * methods, the response should have the type `XxxResponse`, where `Xxx` is
+   * the original method name. For example, if the original method name is
+   * `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
+   *
+   * The values for Object must be JSON objects. It can consist of `num`,
+   * `String`, `bool` and `null` as well as `Map` and `List` values.
+   */
+  core.Map<core.String, core.Object> response;
+
+  Operation();
+
+  Operation.fromJson(core.Map _json) {
+    if (_json.containsKey("done")) {
+      done = _json["done"];
+    }
+    if (_json.containsKey("error")) {
+      error = new Status.fromJson(_json["error"]);
+    }
+    if (_json.containsKey("metadata")) {
+      metadata = _json["metadata"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("response")) {
+      response = _json["response"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (done != null) {
+      _json["done"] = done;
+    }
+    if (error != null) {
+      _json["error"] = (error).toJson();
+    }
+    if (metadata != null) {
+      _json["metadata"] = metadata;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (response != null) {
+      _json["response"] = response;
+    }
+    return _json;
+  }
+}
+
+/** Metadata for the given google.longrunning.Operation. */
+class OperationMetadata {
+  /**
+   * Timestamp that this operation was completed. (Not present if the operation
+   * is still in progress.) @OutputOnly
+   */
+  core.String endTime;
+  /** Timestamp that this operation was received. @OutputOnly */
+  core.String insertTime;
+  /**
+   * API method name that initiated the operation. Example:
+   * "google.appengine.v1beta4.Version.CreateVersion". @OutputOnly
+   */
+  core.String method;
+  /**
+   * The type of the operation (deprecated, use method field instead). Example:
+   * "create_version". @OutputOnly
+   */
+  core.String operationType;
+  /**
+   * Resource that this operation is acting on. Example:
+   * "apps/myapp/modules/default". @OutputOnly
+   */
+  core.String target;
+  /** The user who requested this operation. @OutputOnly */
+  core.String user;
+
+  OperationMetadata();
+
+  OperationMetadata.fromJson(core.Map _json) {
+    if (_json.containsKey("endTime")) {
+      endTime = _json["endTime"];
+    }
+    if (_json.containsKey("insertTime")) {
+      insertTime = _json["insertTime"];
+    }
+    if (_json.containsKey("method")) {
+      method = _json["method"];
+    }
+    if (_json.containsKey("operationType")) {
+      operationType = _json["operationType"];
+    }
+    if (_json.containsKey("target")) {
+      target = _json["target"];
+    }
+    if (_json.containsKey("user")) {
+      user = _json["user"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (endTime != null) {
+      _json["endTime"] = endTime;
+    }
+    if (insertTime != null) {
+      _json["insertTime"] = insertTime;
+    }
+    if (method != null) {
+      _json["method"] = method;
+    }
+    if (operationType != null) {
+      _json["operationType"] = operationType;
+    }
+    if (target != null) {
+      _json["target"] = target;
+    }
+    if (user != null) {
+      _json["user"] = user;
+    }
+    return _json;
+  }
+}
+
+/** Metadata for the given google.longrunning.Operation. */
+class OperationMetadataV1Beta5 {
+  /**
+   * Timestamp that this operation was completed. (Not present if the operation
+   * is still in progress.) @OutputOnly
+   */
+  core.String endTime;
+  /** Timestamp that this operation was received. @OutputOnly */
+  core.String insertTime;
+  /**
+   * API method name that initiated the operation. Example:
+   * "google.appengine.v1beta5.Version.CreateVersion". @OutputOnly
+   */
+  core.String method;
+  /**
+   * Resource that this operation is acting on. Example:
+   * "apps/myapp/services/default". @OutputOnly
+   */
+  core.String target;
+  /** The user who requested this operation. @OutputOnly */
+  core.String user;
+
+  OperationMetadataV1Beta5();
+
+  OperationMetadataV1Beta5.fromJson(core.Map _json) {
+    if (_json.containsKey("endTime")) {
+      endTime = _json["endTime"];
+    }
+    if (_json.containsKey("insertTime")) {
+      insertTime = _json["insertTime"];
+    }
+    if (_json.containsKey("method")) {
+      method = _json["method"];
+    }
+    if (_json.containsKey("target")) {
+      target = _json["target"];
+    }
+    if (_json.containsKey("user")) {
+      user = _json["user"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (endTime != null) {
+      _json["endTime"] = endTime;
+    }
+    if (insertTime != null) {
+      _json["insertTime"] = insertTime;
+    }
+    if (method != null) {
+      _json["method"] = method;
+    }
+    if (target != null) {
+      _json["target"] = target;
+    }
+    if (user != null) {
+      _json["user"] = user;
+    }
+    return _json;
+  }
+}
+
+/** Target scaling by request utilization (for VM runtimes only). */
+class RequestUtilization {
+  /** Target number of concurrent requests. */
+  core.int targetConcurrentRequests;
+  /** Target requests per second. */
+  core.int targetRequestCountPerSec;
+
+  RequestUtilization();
+
+  RequestUtilization.fromJson(core.Map _json) {
+    if (_json.containsKey("targetConcurrentRequests")) {
+      targetConcurrentRequests = _json["targetConcurrentRequests"];
+    }
+    if (_json.containsKey("targetRequestCountPerSec")) {
+      targetRequestCountPerSec = _json["targetRequestCountPerSec"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (targetConcurrentRequests != null) {
+      _json["targetConcurrentRequests"] = targetConcurrentRequests;
+    }
+    if (targetRequestCountPerSec != null) {
+      _json["targetRequestCountPerSec"] = targetRequestCountPerSec;
+    }
+    return _json;
+  }
+}
+
+/** Used to specify how many machine resources an app version needs. */
+class Resources {
+  /** How many CPU cores an app version needs. */
+  core.double cpu;
+  /** How much disk size, in GB, an app version needs. */
+  core.double diskGb;
+  /** How much memory, in GB, an app version needs. */
+  core.double memoryGb;
+
+  Resources();
+
+  Resources.fromJson(core.Map _json) {
+    if (_json.containsKey("cpu")) {
+      cpu = _json["cpu"];
+    }
+    if (_json.containsKey("diskGb")) {
+      diskGb = _json["diskGb"];
+    }
+    if (_json.containsKey("memoryGb")) {
+      memoryGb = _json["memoryGb"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (cpu != null) {
+      _json["cpu"] = cpu;
+    }
+    if (diskGb != null) {
+      _json["diskGb"] = diskGb;
+    }
+    if (memoryGb != null) {
+      _json["memoryGb"] = memoryGb;
+    }
+    return _json;
+  }
+}
+
+/** Executes a script to handle the request that matches the URL pattern. */
+class ScriptHandler {
+  /** Specifies the path to the script from the application root directory. */
+  core.String scriptPath;
+
+  ScriptHandler();
+
+  ScriptHandler.fromJson(core.Map _json) {
+    if (_json.containsKey("scriptPath")) {
+      scriptPath = _json["scriptPath"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (scriptPath != null) {
+      _json["scriptPath"] = scriptPath;
+    }
+    return _json;
+  }
+}
+
+/**
+ * A service is a logical component of an application that can share state and
+ * communicate in a secure fashion with other services. For example, an
+ * application that handles customer requests might include separate services to
+ * handle other tasks such as API requests from mobile devices or backend data
+ * analysis. Each service has a collection of versions that define a specific
+ * set of code used to implement the functionality of that service.
+ */
+class Service {
+  /**
+   * The relative name/path of the service within the application. Example:
+   * "default" @OutputOnly
+   */
+  core.String id;
+  /**
+   * The full path to the Service resource in the API. Example:
+   * "apps/myapp/services/default" @OutputOnly
+   */
+  core.String name;
+  /**
+   * A mapping that defines fractional HTTP traffic diversion to different
+   * versions within the service.
+   */
+  TrafficSplit split;
+
+  Service();
+
+  Service.fromJson(core.Map _json) {
+    if (_json.containsKey("id")) {
+      id = _json["id"];
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("split")) {
+      split = new TrafficSplit.fromJson(_json["split"]);
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (id != null) {
+      _json["id"] = id;
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (split != null) {
+      _json["split"] = (split).toJson();
+    }
+    return _json;
+  }
+}
+
+/**
+ * A reference to a particular snapshot of the source tree used to build and
+ * deploy the application.
+ */
+class SourceReference {
+  /**
+   * Optional. A URI string identifying the repository. Example:
+   * "https://source.developers.google.com/p/app-123/r/default"
+   */
+  core.String repository;
+  /**
+   * The canonical (and persistent) identifier of the deployed revision, i.e.
+   * any kind of aliases including tags or branch names are not allowed. Example
+   * (git): "2198322f89e0bb2e25021667c2ed489d1fd34e6b"
+   */
+  core.String revisionId;
+
+  SourceReference();
+
+  SourceReference.fromJson(core.Map _json) {
+    if (_json.containsKey("repository")) {
+      repository = _json["repository"];
+    }
+    if (_json.containsKey("revisionId")) {
+      revisionId = _json["revisionId"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (repository != null) {
+      _json["repository"] = repository;
+    }
+    if (revisionId != null) {
+      _json["revisionId"] = revisionId;
+    }
+    return _json;
+  }
+}
+
+/**
+ * Files served directly to the user for a given URL, such as images, CSS
+ * stylesheets, or JavaScript source files. Static file handlers describe which
+ * files in the application directory are static files, and which URLs serve
+ * them.
+ */
+class StaticFilesHandler {
+  /**
+   * By default, files declared in static file handlers are uploaded as static
+   * data and are only served to end users, they cannot be read by an
+   * application. If this field is set to true, the files are also uploaded as
+   * code data so your application can read them. Both uploads are charged
+   * against your code and static data storage resource quotas.
+   */
+  core.bool applicationReadable;
+  /**
+   * The length of time a static file served by this handler ought to be cached
+   * by web proxies and browsers.
+   */
+  core.String expiration;
+  /** HTTP headers to use for all responses from these URLs. */
+  core.Map<core.String, core.String> httpHeaders;
+  /**
+   * If specified, all files served by this handler will be served using the
+   * specified MIME type. If not specified, the MIME type for a file will be
+   * derived from the file's filename extension.
+   */
+  core.String mimeType;
+  /**
+   * The path to the static files matched by the URL pattern, from the
+   * application root directory. The path can refer to text matched in groupings
+   * in the URL pattern.
+   */
+  core.String path;
+  /**
+   * If true, this UrlMap entry does not match the request unless the file
+   * referenced by the handler also exists. If no such file exists, processing
+   * will continue with the next UrlMap that matches the requested URL.
+   */
+  core.bool requireMatchingFile;
+  /**
+   * A regular expression that matches the file paths for all files that will be
+   * referenced by this handler.
+   */
+  core.String uploadPathRegex;
+
+  StaticFilesHandler();
+
+  StaticFilesHandler.fromJson(core.Map _json) {
+    if (_json.containsKey("applicationReadable")) {
+      applicationReadable = _json["applicationReadable"];
+    }
+    if (_json.containsKey("expiration")) {
+      expiration = _json["expiration"];
+    }
+    if (_json.containsKey("httpHeaders")) {
+      httpHeaders = _json["httpHeaders"];
+    }
+    if (_json.containsKey("mimeType")) {
+      mimeType = _json["mimeType"];
+    }
+    if (_json.containsKey("path")) {
+      path = _json["path"];
+    }
+    if (_json.containsKey("requireMatchingFile")) {
+      requireMatchingFile = _json["requireMatchingFile"];
+    }
+    if (_json.containsKey("uploadPathRegex")) {
+      uploadPathRegex = _json["uploadPathRegex"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (applicationReadable != null) {
+      _json["applicationReadable"] = applicationReadable;
+    }
+    if (expiration != null) {
+      _json["expiration"] = expiration;
+    }
+    if (httpHeaders != null) {
+      _json["httpHeaders"] = httpHeaders;
+    }
+    if (mimeType != null) {
+      _json["mimeType"] = mimeType;
+    }
+    if (path != null) {
+      _json["path"] = path;
+    }
+    if (requireMatchingFile != null) {
+      _json["requireMatchingFile"] = requireMatchingFile;
+    }
+    if (uploadPathRegex != null) {
+      _json["uploadPathRegex"] = uploadPathRegex;
+    }
+    return _json;
+  }
+}
+
+/**
+ * The `Status` type defines a logical error model that is suitable for
+ * different programming environments, including REST APIs and RPC APIs. It is
+ * used by [gRPC](https://github.com/grpc). The error model is designed to be: -
+ * Simple to use and understand for most users - Flexible enough to meet
+ * unexpected needs # Overview The `Status` message contains three pieces of
+ * data: error code, error message, and error details. The error code should be
+ * an enum value of google.rpc.Code, but it may accept additional error codes if
+ * needed. The error message should be a developer-facing English message that
+ * helps developers *understand* and *resolve* the error. If a localized
+ * user-facing error message is needed, put the localized message in the error
+ * details or localize it in the client. The optional error details may contain
+ * arbitrary information about the error. There is a predefined set of error
+ * detail types in the package `google.rpc` which can be used for common error
+ * conditions. # Language mapping The `Status` message is the logical
+ * representation of the error model, but it is not necessarily the actual wire
+ * format. When the `Status` message is exposed in different client libraries
+ * and different wire protocols, it can be mapped differently. For example, it
+ * will likely be mapped to some exceptions in Java, but more likely mapped to
+ * some error codes in C. # Other uses The error model and the `Status` message
+ * can be used in a variety of environments, either with or without APIs, to
+ * provide a consistent developer experience across different environments.
+ * Example uses of this error model include: - Partial errors. If a service
+ * needs to return partial errors to the client, it may embed the `Status` in
+ * the normal response to indicate the partial errors. - Workflow errors. A
+ * typical workflow has multiple steps. Each step may have a `Status` message
+ * for error reporting purpose. - Batch operations. If a client uses batch
+ * request and batch response, the `Status` message should be used directly
+ * inside batch response, one for each error sub-response. - Asynchronous
+ * operations. If an API call embeds asynchronous operation results in its
+ * response, the status of those operations should be represented directly using
+ * the `Status` message. - Logging. If some API errors are stored in logs, the
+ * message `Status` could be used directly after any stripping needed for
+ * security/privacy reasons.
+ */
+class Status {
+  /** The status code, which should be an enum value of google.rpc.Code. */
+  core.int code;
+  /**
+   * A list of messages that carry the error details. There will be a common set
+   * of message types for APIs to use.
+   *
+   * The values for Object must be JSON objects. It can consist of `num`,
+   * `String`, `bool` and `null` as well as `Map` and `List` values.
+   */
+  core.List<core.Map<core.String, core.Object>> details;
+  /**
+   * A developer-facing error message, which should be in English. Any
+   * user-facing error message should be localized and sent in the
+   * google.rpc.Status.details field, or localized by the client.
+   */
+  core.String message;
+
+  Status();
+
+  Status.fromJson(core.Map _json) {
+    if (_json.containsKey("code")) {
+      code = _json["code"];
+    }
+    if (_json.containsKey("details")) {
+      details = _json["details"];
+    }
+    if (_json.containsKey("message")) {
+      message = _json["message"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (code != null) {
+      _json["code"] = code;
+    }
+    if (details != null) {
+      _json["details"] = details;
+    }
+    if (message != null) {
+      _json["message"] = message;
+    }
+    return _json;
+  }
+}
+
+/**
+ * Configuration for traffic splitting for versions within a single service.
+ * Traffic splitting allows traffic directed to the service to be assigned to
+ * one of several versions in a fractional way, enabling experiments and
+ * canarying new builds, for example.
+ */
+class TrafficSplit {
+  /**
+   * Mapping from service version IDs within the service to fractional (0.000,
+   * 1] allocations of traffic for that version. Each version may only be
+   * specified once, but some versions in the service may not have any traffic
+   * allocation. Services that have traffic allocated in this field may not be
+   * deleted until the service is deleted, or their traffic allocation is
+   * removed. Allocations must sum to 1. Supports precision up to two decimal
+   * places for IP-based splits and up to three decimal places for cookie-based
+   * splits.
+   */
+  core.Map<core.String, core.double> allocations;
+  /**
+   * Which mechanism should be used as a selector when choosing a version to
+   * send a request to. The traffic selection algorithm will be stable for
+   * either type until allocations are changed.
+   * Possible string values are:
+   * - "UNSPECIFIED" : A UNSPECIFIED.
+   * - "COOKIE" : A COOKIE.
+   * - "IP" : A IP.
+   */
+  core.String shardBy;
+
+  TrafficSplit();
+
+  TrafficSplit.fromJson(core.Map _json) {
+    if (_json.containsKey("allocations")) {
+      allocations = _json["allocations"];
+    }
+    if (_json.containsKey("shardBy")) {
+      shardBy = _json["shardBy"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (allocations != null) {
+      _json["allocations"] = allocations;
+    }
+    if (shardBy != null) {
+      _json["shardBy"] = shardBy;
+    }
+    return _json;
+  }
+}
+
+/** Rules to match an HTTP request and dispatch that request to a service. */
+class UrlDispatchRule {
+  /**
+   * The domain name to match on. Supports '*' (glob) wildcarding on the
+   * left-hand side of a '.'. If empty, all domains will be matched (the same as
+   * '*').
+   */
+  core.String domain;
+  /**
+   * The pathname within the host. This must start with a '/'. A single '*'
+   * (glob) can be included at the end of the path. The sum of the lengths of
+   * the domain and path may not exceed 100 characters.
+   */
+  core.String path;
+  /**
+   * The resource id of a Service in this application that should service the
+   * matched request. The Service must already exist. Example: "default".
+   */
+  core.String service;
+
+  UrlDispatchRule();
+
+  UrlDispatchRule.fromJson(core.Map _json) {
+    if (_json.containsKey("domain")) {
+      domain = _json["domain"];
+    }
+    if (_json.containsKey("path")) {
+      path = _json["path"];
+    }
+    if (_json.containsKey("service")) {
+      service = _json["service"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (domain != null) {
+      _json["domain"] = domain;
+    }
+    if (path != null) {
+      _json["path"] = path;
+    }
+    if (service != null) {
+      _json["service"] = service;
+    }
+    return _json;
+  }
+}
+
+/**
+ * A URL pattern and description of how it should be handled. App Engine can
+ * handle URLs by executing application code, or by serving static files
+ * uploaded with the code, such as images, CSS or JavaScript.
+ */
+class UrlMap {
+  /** Use API Endpoints to handle requests. */
+  ApiEndpointHandler apiEndpoint;
+  /**
+   * For users not logged in, how to handle access to resources with required
+   * login. Defaults to "redirect".
+   * Possible string values are:
+   * - "AUTH_FAIL_ACTION_UNSPECIFIED" : A AUTH_FAIL_ACTION_UNSPECIFIED.
+   * - "AUTH_FAIL_ACTION_REDIRECT" : A AUTH_FAIL_ACTION_REDIRECT.
+   * - "AUTH_FAIL_ACTION_UNAUTHORIZED" : A AUTH_FAIL_ACTION_UNAUTHORIZED.
+   */
+  core.String authFailAction;
+  /**
+   * What level of login is required to access this resource.
+   * Possible string values are:
+   * - "LOGIN_UNSPECIFIED" : A LOGIN_UNSPECIFIED.
+   * - "LOGIN_OPTIONAL" : A LOGIN_OPTIONAL.
+   * - "LOGIN_ADMIN" : A LOGIN_ADMIN.
+   * - "LOGIN_REQUIRED" : A LOGIN_REQUIRED.
+   */
+  core.String login;
+  /**
+   * `30x` code to use when performing redirects for the `secure` field. A `302`
+   * is used by default.
+   * Possible string values are:
+   * - "REDIRECT_HTTP_RESPONSE_CODE_UNSPECIFIED" : A
+   * REDIRECT_HTTP_RESPONSE_CODE_UNSPECIFIED.
+   * - "REDIRECT_HTTP_RESPONSE_CODE_301" : A REDIRECT_HTTP_RESPONSE_CODE_301.
+   * - "REDIRECT_HTTP_RESPONSE_CODE_302" : A REDIRECT_HTTP_RESPONSE_CODE_302.
+   * - "REDIRECT_HTTP_RESPONSE_CODE_303" : A REDIRECT_HTTP_RESPONSE_CODE_303.
+   * - "REDIRECT_HTTP_RESPONSE_CODE_307" : A REDIRECT_HTTP_RESPONSE_CODE_307.
+   */
+  core.String redirectHttpResponseCode;
+  /** Executes a script to handle the request that matches the URL pattern. */
+  ScriptHandler script;
+  /**
+   * Configures whether security (HTTPS) should be enforced for this URL.
+   * Possible string values are:
+   * - "SECURE_UNSPECIFIED" : A SECURE_UNSPECIFIED.
+   * - "SECURE_DEFAULT" : A SECURE_DEFAULT.
+   * - "SECURE_NEVER" : A SECURE_NEVER.
+   * - "SECURE_OPTIONAL" : A SECURE_OPTIONAL.
+   * - "SECURE_ALWAYS" : A SECURE_ALWAYS.
+   */
+  core.String securityLevel;
+  /** Returns the contents of a file, such as an image, as the response. */
+  StaticFilesHandler staticFiles;
+  /**
+   * A URL prefix. This value uses regular expression syntax (and so regexp
+   * special characters must be escaped), but it should not contain groupings.
+   * All URLs that begin with this prefix are handled by this handler, using the
+   * portion of the URL after the prefix as part of the file path. This is
+   * always required.
+   */
+  core.String urlRegex;
+
+  UrlMap();
+
+  UrlMap.fromJson(core.Map _json) {
+    if (_json.containsKey("apiEndpoint")) {
+      apiEndpoint = new ApiEndpointHandler.fromJson(_json["apiEndpoint"]);
+    }
+    if (_json.containsKey("authFailAction")) {
+      authFailAction = _json["authFailAction"];
+    }
+    if (_json.containsKey("login")) {
+      login = _json["login"];
+    }
+    if (_json.containsKey("redirectHttpResponseCode")) {
+      redirectHttpResponseCode = _json["redirectHttpResponseCode"];
+    }
+    if (_json.containsKey("script")) {
+      script = new ScriptHandler.fromJson(_json["script"]);
+    }
+    if (_json.containsKey("securityLevel")) {
+      securityLevel = _json["securityLevel"];
+    }
+    if (_json.containsKey("staticFiles")) {
+      staticFiles = new StaticFilesHandler.fromJson(_json["staticFiles"]);
+    }
+    if (_json.containsKey("urlRegex")) {
+      urlRegex = _json["urlRegex"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (apiEndpoint != null) {
+      _json["apiEndpoint"] = (apiEndpoint).toJson();
+    }
+    if (authFailAction != null) {
+      _json["authFailAction"] = authFailAction;
+    }
+    if (login != null) {
+      _json["login"] = login;
+    }
+    if (redirectHttpResponseCode != null) {
+      _json["redirectHttpResponseCode"] = redirectHttpResponseCode;
+    }
+    if (script != null) {
+      _json["script"] = (script).toJson();
+    }
+    if (securityLevel != null) {
+      _json["securityLevel"] = securityLevel;
+    }
+    if (staticFiles != null) {
+      _json["staticFiles"] = (staticFiles).toJson();
+    }
+    if (urlRegex != null) {
+      _json["urlRegex"] = urlRegex;
+    }
+    return _json;
+  }
+}
+
+/**
+ * A Version is a specific set of source code and configuration files deployed
+ * to a service.
+ */
+class Version {
+  /**
+   * Serving configuration for Google Cloud Endpoints. Only returned in `GET`
+   * requests if `view=FULL` is set. May only be set on create requests; once
+   * created, is immutable.
+   */
+  ApiConfigHandler apiConfig;
+  /**
+   * Automatic scaling is the scaling policy that App Engine has used since its
+   * inception. It is based on request rate, response latencies, and other
+   * application metrics.
+   */
+  AutomaticScaling automaticScaling;
+  /**
+   * A service with basic scaling will create an instance when the application
+   * receives a request. The instance will be turned down when the app becomes
+   * idle. Basic scaling is ideal for work that is intermittent or driven by
+   * user activity.
+   */
+  BasicScaling basicScaling;
+  /** Beta settings supplied to the application via metadata. */
+  core.Map<core.String, core.String> betaSettings;
+  /**
+   * Creation time of this version. This will be between the start and end times
+   * of the operation that creates this version. @OutputOnly
+   */
+  core.String creationTime;
+  /**
+   * The length of time a static file served by a static file handler ought to
+   * be cached by web proxies and browsers, if the handler does not specify its
+   * own expiration. Only returned in `GET` requests if `view=FULL` is set. May
+   * only be set on create requests; once created, is immutable.
+   */
+  core.String defaultExpiration;
+  /** The email address of the user who created this version. @OutputOnly */
+  core.String deployer;
+  /**
+   * Code and application artifacts that make up this version. Only returned in
+   * `GET` requests if `view=FULL` is set. May only be set on create requests;
+   * once created, is immutable.
+   */
+  Deployment deployment;
+  /**
+   * Total size of version files hosted on App Engine disk in bytes. @OutputOnly
+   */
+  core.String diskUsageBytes;
+  /**
+   * The App Engine execution environment to use for this version. Default: "1"
+   */
+  core.String env;
+  /**
+   * Environment variables made available to the application. Only returned in
+   * `GET` requests if `view=FULL` is set. May only be set on create requests;
+   * once created, is immutable.
+   */
+  core.Map<core.String, core.String> envVariables;
+  /**
+   * Custom static error pages instead of these generic error pages, (limit 10
+   * KB/page) Only returned in `GET` requests if `view=FULL` is set. May only be
+   * set on create requests; once created, is immutable.
+   */
+  core.List<ErrorHandler> errorHandlers;
+  /**
+   * An ordered list of URL Matching patterns that should be applied to incoming
+   * requests. The first matching URL consumes the request, and subsequent
+   * handlers are not attempted. Only returned in `GET` requests if `view=FULL`
+   * is set. May only be set on create requests; once created, is immutable.
+   */
+  core.List<UrlMap> handlers;
+  /**
+   * Configure health checking for the VM instances. Unhealthy VM instances will
+   * be stopped and replaced with new instances. Only returned in `GET` requests
+   * if `view=FULL` is set. May only be set on create requests; once created, is
+   * immutable.
+   */
+  HealthCheck healthCheck;
+  /**
+   * The relative name/path of the Version within the service. Example: "v1".
+   * Version specifiers can contain lowercase letters, digits, and hyphens. It
+   * cannot begin with the prefix `ah-` and the names `default` and `latest` are
+   * reserved and cannot be used.
+   */
+  core.String id;
+  /**
+   * Before an application can receive email or XMPP messages, the application
+   * must be configured to enable the service.
+   */
+  core.List<core.String> inboundServices;
+  /**
+   * The instance class to use to run this app. Valid values for
+   * AutomaticScaling are `[F1, F2, F4, F4_1G]`. Valid values for ManualScaling
+   * and BasicScaling are `[B1, B2, B4, B8, B4_1G]`. Default: "F1" for
+   * AutomaticScaling, "B1" for ManualScaling and BasicScaling
+   */
+  core.String instanceClass;
+  /**
+   * Configuration for Python runtime third-party libraries required by the
+   * application. Only returned in `GET` requests if `view=FULL` is set. May
+   * only be set on create requests; once created, is immutable.
+   */
+  core.List<Library> libraries;
+  /**
+   * A service with manual scaling runs continuously, allowing you to perform
+   * complex initialization and rely on the state of its memory over time.
+   */
+  ManualScaling manualScaling;
+  /**
+   * The full path to the Version resource in the API. Example:
+   * "apps/myapp/services/default/versions/v1". @OutputOnly
+   */
+  core.String name;
+  /** Used to specify extra network settings (for VM runtimes only). */
+  Network network;
+  /**
+   * Go only. Files that match this pattern will not be built into the app. May
+   * only be set on create requests.
+   */
+  core.String nobuildFilesRegex;
+  /**
+   * Used to specify how many machine resources an app version needs (for VM
+   * runtimes only).
+   */
+  Resources resources;
+  /** The desired runtime. Values can include python27, java7, go, etc. */
+  core.String runtime;
+  /**
+   * The current serving status of this version. Only `SERVING` versions will
+   * have instances created or billed for. If this field is unset when a version
+   * is created, `SERVING` status will be assumed. It is an error to explicitly
+   * set this field to `SERVING_STATUS_UNSPECIFIED`.
+   * Possible string values are:
+   * - "SERVING_STATUS_UNSPECIFIED" : A SERVING_STATUS_UNSPECIFIED.
+   * - "SERVING" : A SERVING.
+   * - "STOPPED" : A STOPPED.
+   */
+  core.String servingStatus;
+  /** If true, multiple requests can be dispatched to the app at once. */
+  core.bool threadsafe;
+  /** Whether to deploy this app in a VM container. */
+  core.bool vm;
+
+  Version();
+
+  Version.fromJson(core.Map _json) {
+    if (_json.containsKey("apiConfig")) {
+      apiConfig = new ApiConfigHandler.fromJson(_json["apiConfig"]);
+    }
+    if (_json.containsKey("automaticScaling")) {
+      automaticScaling = new AutomaticScaling.fromJson(_json["automaticScaling"]);
+    }
+    if (_json.containsKey("basicScaling")) {
+      basicScaling = new BasicScaling.fromJson(_json["basicScaling"]);
+    }
+    if (_json.containsKey("betaSettings")) {
+      betaSettings = _json["betaSettings"];
+    }
+    if (_json.containsKey("creationTime")) {
+      creationTime = _json["creationTime"];
+    }
+    if (_json.containsKey("defaultExpiration")) {
+      defaultExpiration = _json["defaultExpiration"];
+    }
+    if (_json.containsKey("deployer")) {
+      deployer = _json["deployer"];
+    }
+    if (_json.containsKey("deployment")) {
+      deployment = new Deployment.fromJson(_json["deployment"]);
+    }
+    if (_json.containsKey("diskUsageBytes")) {
+      diskUsageBytes = _json["diskUsageBytes"];
+    }
+    if (_json.containsKey("env")) {
+      env = _json["env"];
+    }
+    if (_json.containsKey("envVariables")) {
+      envVariables = _json["envVariables"];
+    }
+    if (_json.containsKey("errorHandlers")) {
+      errorHandlers = _json["errorHandlers"].map((value) => new ErrorHandler.fromJson(value)).toList();
+    }
+    if (_json.containsKey("handlers")) {
+      handlers = _json["handlers"].map((value) => new UrlMap.fromJson(value)).toList();
+    }
+    if (_json.containsKey("healthCheck")) {
+      healthCheck = new HealthCheck.fromJson(_json["healthCheck"]);
+    }
+    if (_json.containsKey("id")) {
+      id = _json["id"];
+    }
+    if (_json.containsKey("inboundServices")) {
+      inboundServices = _json["inboundServices"];
+    }
+    if (_json.containsKey("instanceClass")) {
+      instanceClass = _json["instanceClass"];
+    }
+    if (_json.containsKey("libraries")) {
+      libraries = _json["libraries"].map((value) => new Library.fromJson(value)).toList();
+    }
+    if (_json.containsKey("manualScaling")) {
+      manualScaling = new ManualScaling.fromJson(_json["manualScaling"]);
+    }
+    if (_json.containsKey("name")) {
+      name = _json["name"];
+    }
+    if (_json.containsKey("network")) {
+      network = new Network.fromJson(_json["network"]);
+    }
+    if (_json.containsKey("nobuildFilesRegex")) {
+      nobuildFilesRegex = _json["nobuildFilesRegex"];
+    }
+    if (_json.containsKey("resources")) {
+      resources = new Resources.fromJson(_json["resources"]);
+    }
+    if (_json.containsKey("runtime")) {
+      runtime = _json["runtime"];
+    }
+    if (_json.containsKey("servingStatus")) {
+      servingStatus = _json["servingStatus"];
+    }
+    if (_json.containsKey("threadsafe")) {
+      threadsafe = _json["threadsafe"];
+    }
+    if (_json.containsKey("vm")) {
+      vm = _json["vm"];
+    }
+  }
+
+  core.Map toJson() {
+    var _json = new core.Map();
+    if (apiConfig != null) {
+      _json["apiConfig"] = (apiConfig).toJson();
+    }
+    if (automaticScaling != null) {
+      _json["automaticScaling"] = (automaticScaling).toJson();
+    }
+    if (basicScaling != null) {
+      _json["basicScaling"] = (basicScaling).toJson();
+    }
+    if (betaSettings != null) {
+      _json["betaSettings"] = betaSettings;
+    }
+    if (creationTime != null) {
+      _json["creationTime"] = creationTime;
+    }
+    if (defaultExpiration != null) {
+      _json["defaultExpiration"] = defaultExpiration;
+    }
+    if (deployer != null) {
+      _json["deployer"] = deployer;
+    }
+    if (deployment != null) {
+      _json["deployment"] = (deployment).toJson();
+    }
+    if (diskUsageBytes != null) {
+      _json["diskUsageBytes"] = diskUsageBytes;
+    }
+    if (env != null) {
+      _json["env"] = env;
+    }
+    if (envVariables != null) {
+      _json["envVariables"] = envVariables;
+    }
+    if (errorHandlers != null) {
+      _json["errorHandlers"] = errorHandlers.map((value) => (value).toJson()).toList();
+    }
+    if (handlers != null) {
+      _json["handlers"] = handlers.map((value) => (value).toJson()).toList();
+    }
+    if (healthCheck != null) {
+      _json["healthCheck"] = (healthCheck).toJson();
+    }
+    if (id != null) {
+      _json["id"] = id;
+    }
+    if (inboundServices != null) {
+      _json["inboundServices"] = inboundServices;
+    }
+    if (instanceClass != null) {
+      _json["instanceClass"] = instanceClass;
+    }
+    if (libraries != null) {
+      _json["libraries"] = libraries.map((value) => (value).toJson()).toList();
+    }
+    if (manualScaling != null) {
+      _json["manualScaling"] = (manualScaling).toJson();
+    }
+    if (name != null) {
+      _json["name"] = name;
+    }
+    if (network != null) {
+      _json["network"] = (network).toJson();
+    }
+    if (nobuildFilesRegex != null) {
+      _json["nobuildFilesRegex"] = nobuildFilesRegex;
+    }
+    if (resources != null) {
+      _json["resources"] = (resources).toJson();
+    }
+    if (runtime != null) {
+      _json["runtime"] = runtime;
+    }
+    if (servingStatus != null) {
+      _json["servingStatus"] = servingStatus;
+    }
+    if (threadsafe != null) {
+      _json["threadsafe"] = threadsafe;
+    }
+    if (vm != null) {
+      _json["vm"] = vm;
+    }
+    return _json;
+  }
+}