Api-Roll 54: 2017-09-11

generated/googleapis/lib/storagetransfer/v1.dart

 // This is a generated file (see the discoveryapis_generator project).
 
 library googleapis.storagetransfer.v1;
 
 import 'dart:core' as core;
 import 'dart:async' as async;
 import 'dart:convert' as convert;
 
 import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
 import 'package:http/http.dart' as http;
 
-export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' show
-    ApiRequestError, DetailedApiRequestError;
+export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
+    show ApiRequestError, DetailedApiRequestError;
 
 const core.String USER_AGENT = 'dart-api-client storagetransfer/v1';
 
-/**
- * Transfers data from external data sources to a Google Cloud Storage bucket or
- * between Google Cloud Storage buckets.
- */
+/// Transfers data from external data sources to a Google Cloud Storage bucket
+/// or between Google Cloud Storage buckets.
 class StoragetransferApi {
-  /** View and manage your data across Google Cloud Platform services */
-  static const CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform";
-
+  /// View and manage your data across Google Cloud Platform services
+  static const CloudPlatformScope =
+      "https://www.googleapis.com/auth/cloud-platform";
 
   final commons.ApiRequester _requester;
 
-  GoogleServiceAccountsResourceApi get googleServiceAccounts => new GoogleServiceAccountsResourceApi(_requester);
-  TransferJobsResourceApi get transferJobs => new TransferJobsResourceApi(_requester);
-  TransferOperationsResourceApi get transferOperations => new TransferOperationsResourceApi(_requester);
+  GoogleServiceAccountsResourceApi get googleServiceAccounts =>
+      new GoogleServiceAccountsResourceApi(_requester);
+  TransferJobsResourceApi get transferJobs =>
+      new TransferJobsResourceApi(_requester);
+  TransferOperationsResourceApi get transferOperations =>
+      new TransferOperationsResourceApi(_requester);
 
-  StoragetransferApi(http.Client client, {core.String rootUrl: "https://storagetransfer.googleapis.com/", core.String servicePath: ""}) :
-      _requester = new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
+  StoragetransferApi(http.Client client,
+      {core.String rootUrl: "https://storagetransfer.googleapis.com/",
+      core.String servicePath: ""})
+      : _requester =
+            new commons.ApiRequester(client, rootUrl, servicePath, USER_AGENT);
 }
 
-
 class GoogleServiceAccountsResourceApi {
   final commons.ApiRequester _requester;
 
-  GoogleServiceAccountsResourceApi(commons.ApiRequester client) : 
-      _requester = client;
+  GoogleServiceAccountsResourceApi(commons.ApiRequester client)
+      : _requester = client;
 
-  /**
-   * Returns the Google service account that is used by Storage Transfer
-   * Service to access buckets in the project where transfers
-   * run or in other projects. Each Google service account is associated
-   * with one Google Cloud Platform Console project. Users
-   * should add this service account to the Google Cloud Storage bucket
-   * ACLs to grant access to Storage Transfer Service. This service
-   * account is created and owned by Storage Transfer Service and can
-   * only be used by Storage Transfer Service.
-   *
-   * Request parameters:
-   *
-   * [projectId] - The ID of the Google Cloud Platform Console project that the
-   * Google service
-   * account is associated with.
-   * Required.
-   *
-   * Completes with a [GoogleServiceAccount].
-   *
-   * 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.
-   */
+  /// Returns the Google service account that is used by Storage Transfer
+  /// Service to access buckets in the project where transfers
+  /// run or in other projects. Each Google service account is associated
+  /// with one Google Cloud Platform Console project. Users
+  /// should add this service account to the Google Cloud Storage bucket
+  /// ACLs to grant access to Storage Transfer Service. This service
+  /// account is created and owned by Storage Transfer Service and can
+  /// only be used by Storage Transfer Service.
+  ///
+  /// Request parameters:
+  ///
+  /// [projectId] - The ID of the Google Cloud Platform Console project that
+  /// the Google service
+  /// account is associated with.
+  /// Required.
+  ///
+  /// Completes with a [GoogleServiceAccount].
+  ///
+  /// 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<GoogleServiceAccount> get(core.String projectId) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (projectId == null) {
       throw new core.ArgumentError("Parameter projectId is required.");
     }
 
-    _url = 'v1/googleServiceAccounts/' + commons.Escaper.ecapeVariable('$projectId');
+    _url = 'v1/googleServiceAccounts/' +
+        commons.Escaper.ecapeVariable('$projectId');
 
-    var _response = _requester.request(_url,
-                                       "GET",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "GET",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new GoogleServiceAccount.fromJson(data));
   }
-
 }
 
-
 class TransferJobsResourceApi {
   final commons.ApiRequester _requester;
 
-  TransferJobsResourceApi(commons.ApiRequester client) : 
-      _requester = client;
+  TransferJobsResourceApi(commons.ApiRequester client) : _requester = client;
 
-  /**
-   * Creates a transfer job that runs periodically.
-   *
-   * [request] - The metadata request object.
-   *
-   * Request parameters:
-   *
-   * Completes with a [TransferJob].
-   *
-   * 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.
-   */
+  /// Creates a transfer job that runs periodically.
+  ///
+  /// [request] - The metadata request object.
+  ///
+  /// Request parameters:
+  ///
+  /// Completes with a [TransferJob].
+  ///
+  /// 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<TransferJob> create(TransferJob request) {
     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());
     }
 
     _url = 'v1/transferJobs';
 
-    var _response = _requester.request(_url,
-                                       "POST",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "POST",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new TransferJob.fromJson(data));
   }
 
-  /**
-   * Gets a transfer job.
-   *
-   * Request parameters:
-   *
-   * [jobName] - The job to get.
-   * Required.
-   * Value must have pattern "^transferJobs/.+$".
-   *
-   * [projectId] - The ID of the Google Cloud Platform Console project that owns
-   * the job.
-   * Required.
-   *
-   * Completes with a [TransferJob].
-   *
-   * 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.
-   */
+  /// Gets a transfer job.
+  ///
+  /// Request parameters:
+  ///
+  /// [jobName] - The job to get.
+  /// Required.
+  /// Value must have pattern "^transferJobs/.+$".
+  ///
+  /// [projectId] - The ID of the Google Cloud Platform Console project that
+  /// owns the job.
+  /// Required.
+  ///
+  /// Completes with a [TransferJob].
+  ///
+  /// 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<TransferJob> get(core.String jobName, {core.String projectId}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (jobName == null) {
       throw new core.ArgumentError("Parameter jobName is required.");
     }
     if (projectId != null) {
       _queryParams["projectId"] = [projectId];
     }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$jobName');
 
-    var _response = _requester.request(_url,
-                                       "GET",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "GET",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new TransferJob.fromJson(data));
   }
 
-  /**
-   * Lists transfer jobs.
-   *
-   * Request parameters:
-   *
-   * [filter] - A list of query parameters specified as JSON text in the form of
-   * {"project_id":"my_project_id",
-   * "job_names":["jobid1","jobid2",...],
-   * "job_statuses":["status1","status2",...]}.
-   * Since `job_names` and `job_statuses` support multiple values, their values
-   * must be specified with array notation. `project_id` is required.
-   * `job_names`
-   * and `job_statuses` are optional.  The valid values for `job_statuses` are
-   * case-insensitive: `ENABLED`, `DISABLED`, and `DELETED`.
-   *
-   * [pageToken] - The list page token.
-   *
-   * [pageSize] - The list page size. The max allowed value is 256.
-   *
-   * Completes with a [ListTransferJobsResponse].
-   *
-   * 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<ListTransferJobsResponse> list({core.String filter, core.String pageToken, core.int pageSize}) {
+  /// Lists transfer jobs.
+  ///
+  /// Request parameters:
+  ///
+  /// [pageSize] - The list page size. The max allowed value is 256.
+  ///
+  /// [filter] - A list of query parameters specified as JSON text in the form
+  /// of
+  /// {"project_id":"my_project_id",
+  /// "job_names":["jobid1","jobid2",...],
+  /// "job_statuses":["status1","status2",...]}.
+  /// Since `job_names` and `job_statuses` support multiple values, their
+  /// values
+  /// must be specified with array notation. `project_id` is required.
+  /// `job_names`
+  /// and `job_statuses` are optional.  The valid values for `job_statuses` are
+  /// case-insensitive: `ENABLED`, `DISABLED`, and `DELETED`.
+  ///
+  /// [pageToken] - The list page token.
+  ///
+  /// Completes with a [ListTransferJobsResponse].
+  ///
+  /// 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<ListTransferJobsResponse> list(
+      {core.int pageSize, core.String filter, 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 (pageSize != null) {
+      _queryParams["pageSize"] = ["${pageSize}"];
+    }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
     if (pageToken != null) {
       _queryParams["pageToken"] = [pageToken];
     }
-    if (pageSize != null) {
-      _queryParams["pageSize"] = ["${pageSize}"];
-    }
 
     _url = 'v1/transferJobs';
 
-    var _response = _requester.request(_url,
-                                       "GET",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
-    return _response.then((data) => new ListTransferJobsResponse.fromJson(data));
+    var _response = _requester.request(_url, "GET",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
+    return _response
+        .then((data) => new ListTransferJobsResponse.fromJson(data));
   }
 
-  /**
-   * Updates a transfer job. Updating a job's transfer spec does not affect
-   * transfer operations that are running already. Updating the scheduling
-   * of a job is not allowed.
-   *
-   * [request] - The metadata request object.
-   *
-   * Request parameters:
-   *
-   * [jobName] - The name of job to update.
-   * Required.
-   * Value must have pattern "^transferJobs/.+$".
-   *
-   * Completes with a [TransferJob].
-   *
-   * 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<TransferJob> patch(UpdateTransferJobRequest request, core.String jobName) {
+  /// Updates a transfer job. Updating a job's transfer spec does not affect
+  /// transfer operations that are running already. Updating the scheduling
+  /// of a job is not allowed.
+  ///
+  /// [request] - The metadata request object.
+  ///
+  /// Request parameters:
+  ///
+  /// [jobName] - The name of job to update.
+  /// Required.
+  /// Value must have pattern "^transferJobs/.+$".
+  ///
+  /// Completes with a [TransferJob].
+  ///
+  /// 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<TransferJob> patch(
+      UpdateTransferJobRequest request, core.String jobName) {
     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 (jobName == null) {
       throw new core.ArgumentError("Parameter jobName is required.");
     }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$jobName');
 
-    var _response = _requester.request(_url,
-                                       "PATCH",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "PATCH",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new TransferJob.fromJson(data));
   }
-
 }
 
-
 class TransferOperationsResourceApi {
   final commons.ApiRequester _requester;
 
-  TransferOperationsResourceApi(commons.ApiRequester client) : 
-      _requester = client;
+  TransferOperationsResourceApi(commons.ApiRequester client)
+      : _requester = client;
 
-  /**
-   * Cancels a transfer. Use the get method to check whether the cancellation
-   * succeeded or whether the operation completed despite cancellation.
-   *
-   * Request parameters:
-   *
-   * [name] - The name of the operation resource to be cancelled.
-   * Value must have pattern "^transferOperations/.+$".
-   *
-   * Completes with a [Empty].
-   *
-   * 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.
-   */
+  /// Cancels a transfer. Use the get method to check whether the cancellation
+  /// succeeded or whether the operation completed despite cancellation.
+  ///
+  /// Request parameters:
+  ///
+  /// [name] - The name of the operation resource to be cancelled.
+  /// Value must have pattern "^transferOperations/.+$".
+  ///
+  /// Completes with a [Empty].
+  ///
+  /// 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<Empty> cancel(core.String name) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name') + ':cancel';
 
-    var _response = _requester.request(_url,
-                                       "POST",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "POST",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
-  /**
-   * This method is not supported and the server returns `UNIMPLEMENTED`.
-   *
-   * Request parameters:
-   *
-   * [name] - The name of the operation resource to be deleted.
-   * Value must have pattern "^transferOperations/.+$".
-   *
-   * Completes with a [Empty].
-   *
-   * 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.
-   */
+  /// This method is not supported and the server returns `UNIMPLEMENTED`.
+  ///
+  /// Request parameters:
+  ///
+  /// [name] - The name of the operation resource to be deleted.
+  /// Value must have pattern "^transferOperations/.+$".
+  ///
+  /// Completes with a [Empty].
+  ///
+  /// 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<Empty> delete(core.String name) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
 
-    var _response = _requester.request(_url,
-                                       "DELETE",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "DELETE",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
-  /**
-   * 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:
-   *
-   * [name] - The name of the operation resource.
-   * Value must have pattern "^transferOperations/.+$".
-   *
-   * 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.
-   */
+  /// 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:
+  ///
+  /// [name] - The name of the operation resource.
+  /// Value must have pattern "^transferOperations/.+$".
+  ///
+  /// 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 name) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
     if (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
 
-    var _response = _requester.request(_url,
-                                       "GET",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    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 allows API services to override the binding
-   * to use different resource name schemes, such as `users / * /operations`. To
-   * override the binding, API services can add a binding such as
-   * `"/v1/{name=users / * }/operations"` to their service configuration.
-   * For backwards compatibility, the default name includes the operations
-   * collection id, however overriding users must ensure the name binding
-   * is the parent resource, without the operations collection id.
-   *
-   * Request parameters:
-   *
-   * [name] - The value `transferOperations`.
-   * Value must have pattern "^transferOperations$".
-   *
-   * [pageToken] - The list page token.
-   *
-   * [pageSize] - The list page size. The max allowed value is 256.
-   *
-   * [filter] - A list of query parameters specified as JSON text in the form of
-   * {\"project_id\" : \"my_project_id\", \"job_names\" : [\"jobid1\",
-   * \"jobid2\",...], \"operation_names\" : [\"opid1\", \"opid2\",...],
-   * \"transfer_statuses\":[\"status1\", \"status2\",...]}. Since `job_names`,
-   * `operation_names`, and `transfer_statuses` support multiple values, they
-   * must be specified with array notation. `job_names`, `operation_names`, and
-   * `transfer_statuses` are optional.
-   *
-   * 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 name, {core.String pageToken, core.int pageSize, core.String filter}) {
+  /// 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 allows API services to override the binding
+  /// to use different resource name schemes, such as `users / * /operations`.
+  /// To
+  /// override the binding, API services can add a binding such as
+  /// `"/v1/{name=users / * }/operations"` to their service configuration.
+  /// For backwards compatibility, the default name includes the operations
+  /// collection id, however overriding users must ensure the name binding
+  /// is the parent resource, without the operations collection id.
+  ///
+  /// Request parameters:
+  ///
+  /// [name] - The value `transferOperations`.
+  /// Value must have pattern "^transferOperations$".
+  ///
+  /// [pageSize] - The list page size. The max allowed value is 256.
+  ///
+  /// [filter] - A list of query parameters specified as JSON text in the form
+  /// of {\"project_id\" : \"my_project_id\", \"job_names\" : [\"jobid1\",
+  /// \"jobid2\",...], \"operation_names\" : [\"opid1\", \"opid2\",...],
+  /// \"transfer_statuses\":[\"status1\", \"status2\",...]}. Since `job_names`,
+  /// `operation_names`, and `transfer_statuses` support multiple values, they
+  /// must be specified with array notation. `job_names`, `operation_names`,
+  /// and `transfer_statuses` are optional.
+  ///
+  /// [pageToken] - The 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 name,
+      {core.int pageSize, core.String filter, 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 (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
-    }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
     if (filter != null) {
       _queryParams["filter"] = [filter];
     }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
 
-    var _response = _requester.request(_url,
-                                       "GET",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "GET",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new ListOperationsResponse.fromJson(data));
   }
 
-  /**
-   * Pauses a transfer operation.
-   *
-   * [request] - The metadata request object.
-   *
-   * Request parameters:
-   *
-   * [name] - The name of the transfer operation.
-   * Required.
-   * Value must have pattern "^transferOperations/.+$".
-   *
-   * Completes with a [Empty].
-   *
-   * 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<Empty> pause(PauseTransferOperationRequest request, core.String name) {
+  /// Pauses a transfer operation.
+  ///
+  /// [request] - The metadata request object.
+  ///
+  /// Request parameters:
+  ///
+  /// [name] - The name of the transfer operation.
+  /// Required.
+  /// Value must have pattern "^transferOperations/.+$".
+  ///
+  /// Completes with a [Empty].
+  ///
+  /// 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<Empty> pause(
+      PauseTransferOperationRequest request, core.String name) {
     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 (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name') + ':pause';
 
-    var _response = _requester.request(_url,
-                                       "POST",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "POST",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
-  /**
-   * Resumes a transfer operation that is paused.
-   *
-   * [request] - The metadata request object.
-   *
-   * Request parameters:
-   *
-   * [name] - The name of the transfer operation.
-   * Required.
-   * Value must have pattern "^transferOperations/.+$".
-   *
-   * Completes with a [Empty].
-   *
-   * 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<Empty> resume(ResumeTransferOperationRequest request, core.String name) {
+  /// Resumes a transfer operation that is paused.
+  ///
+  /// [request] - The metadata request object.
+  ///
+  /// Request parameters:
+  ///
+  /// [name] - The name of the transfer operation.
+  /// Required.
+  /// Value must have pattern "^transferOperations/.+$".
+  ///
+  /// Completes with a [Empty].
+  ///
+  /// 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<Empty> resume(
+      ResumeTransferOperationRequest request, core.String name) {
     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 (name == null) {
       throw new core.ArgumentError("Parameter name is required.");
     }
 
     _url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name') + ':resume';
 
-    var _response = _requester.request(_url,
-                                       "POST",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
+    var _response = _requester.request(_url, "POST",
+        body: _body,
+        queryParams: _queryParams,
+        uploadOptions: _uploadOptions,
+        uploadMedia: _uploadMedia,
+        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
-
 }
 
+/// AWS access key (see
+/// [AWS Security
+/// Credentials](http://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html)).
+class AwsAccessKey {
+  /// AWS access key ID.
+  /// Required.
+  core.String accessKeyId;
 
-
-/**
- * AWS access key (see
- * [AWS Security
- * Credentials](http://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html)).
- */
-class AwsAccessKey {
-  /**
-   * AWS access key ID.
-   * Required.
-   */
-  core.String accessKeyId;
-  /**
-   * AWS secret access key. This field is not returned in RPC responses.
-   * Required.
-   */
+  /// AWS secret access key. This field is not returned in RPC responses.
+  /// Required.
   core.String secretAccessKey;
 
   AwsAccessKey();
 
   AwsAccessKey.fromJson(core.Map _json) {
     if (_json.containsKey("accessKeyId")) {
       accessKeyId = _json["accessKeyId"];
     }
     if (_json.containsKey("secretAccessKey")) {
       secretAccessKey = _json["secretAccessKey"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (accessKeyId != null) {
       _json["accessKeyId"] = accessKeyId;
     }
     if (secretAccessKey != null) {
       _json["secretAccessKey"] = secretAccessKey;
     }
     return _json;
   }
 }
 
-/**
- * An AwsS3Data can be a data source, but not a data sink.
- * In an AwsS3Data, an object's name is the S3 object's key name.
- */
+/// An AwsS3Data can be a data source, but not a data sink.
+/// In an AwsS3Data, an object's name is the S3 object's key name.
 class AwsS3Data {
-  /**
-   * AWS access key used to sign the API requests to the AWS S3 bucket.
-   * Permissions on the bucket must be granted to the access ID of the
-   * AWS access key.
-   * Required.
-   */
+  /// AWS access key used to sign the API requests to the AWS S3 bucket.
+  /// Permissions on the bucket must be granted to the access ID of the
+  /// AWS access key.
+  /// Required.
   AwsAccessKey awsAccessKey;
-  /**
-   * S3 Bucket name (see
-   * [Creating a
-   * bucket](http://docs.aws.amazon.com/AmazonS3/latest/dev/create-bucket-get-location-example.html)).
-   * Required.
-   */
+
+  /// S3 Bucket name (see
+  /// [Creating a
+  /// bucket](http://docs.aws.amazon.com/AmazonS3/latest/dev/create-bucket-get-location-example.html)).
+  /// Required.
   core.String bucketName;
 
   AwsS3Data();
 
   AwsS3Data.fromJson(core.Map _json) {
     if (_json.containsKey("awsAccessKey")) {
       awsAccessKey = new AwsAccessKey.fromJson(_json["awsAccessKey"]);
     }
     if (_json.containsKey("bucketName")) {
       bucketName = _json["bucketName"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (awsAccessKey != null) {
       _json["awsAccessKey"] = (awsAccessKey).toJson();
     }
     if (bucketName != null) {
       _json["bucketName"] = bucketName;
     }
     return _json;
   }
 }
 
-/**
- * Represents a whole calendar date, e.g. date of birth. The time of day and
- * time zone are either specified elsewhere or are not significant. The date
- * is relative to the Proleptic Gregorian Calendar. The day may be 0 to
- * represent a year and month where the day is not significant, e.g. credit card
- * expiration date. The year may be 0 to represent a month and day independent
- * of year, e.g. anniversary date. Related types are google.type.TimeOfDay
- * and `google.protobuf.Timestamp`.
- */
+/// Represents a whole calendar date, e.g. date of birth. The time of day and
+/// time zone are either specified elsewhere or are not significant. The date
+/// is relative to the Proleptic Gregorian Calendar. The day may be 0 to
+/// represent a year and month where the day is not significant, e.g. credit
+/// card
+/// expiration date. The year may be 0 to represent a month and day independent
+/// of year, e.g. anniversary date. Related types are google.type.TimeOfDay
+/// and `google.protobuf.Timestamp`.
 class Date {
-  /**
-   * Day of month. Must be from 1 to 31 and valid for the year and month, or 0
-   * if specifying a year/month where the day is not significant.
-   */
+  /// Day of month. Must be from 1 to 31 and valid for the year and month, or 0
+  /// if specifying a year/month where the day is not significant.
   core.int day;
-  /** Month of year. Must be from 1 to 12. */
+
+  /// Month of year. Must be from 1 to 12.
   core.int month;
-  /**
-   * Year of date. Must be from 1 to 9999, or 0 if specifying a date without
-   * a year.
-   */
+
+  /// Year of date. Must be from 1 to 9999, or 0 if specifying a date without
+  /// a year.
   core.int year;
 
   Date();
 
   Date.fromJson(core.Map _json) {
     if (_json.containsKey("day")) {
       day = _json["day"];
     }
     if (_json.containsKey("month")) {
       month = _json["month"];
     }
     if (_json.containsKey("year")) {
       year = _json["year"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (day != null) {
       _json["day"] = day;
     }
     if (month != null) {
       _json["month"] = month;
     }
     if (year != null) {
       _json["year"] = year;
     }
     return _json;
   }
 }
 
-/**
- * A generic empty message that you can re-use to avoid defining duplicated
- * empty messages in your APIs. A typical example is to use it as the request
- * or the response type of an API method. For instance:
- *
- *     service Foo {
- *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
- *     }
- *
- * The JSON representation for `Empty` is empty JSON object `{}`.
- */
+/// A generic empty message that you can re-use to avoid defining duplicated
+/// empty messages in your APIs. A typical example is to use it as the request
+/// or the response type of an API method. For instance:
+///
+///     service Foo {
+///       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+///     }
+///
+/// The JSON representation for `Empty` is empty JSON object `{}`.
 class Empty {
-
   Empty();
 
-  Empty.fromJson(core.Map _json) {
-  }
+  Empty.fromJson(core.Map _json) {}
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     return _json;
   }
 }
 
-/** An entry describing an error that has occurred. */
+/// An entry describing an error that has occurred.
 class ErrorLogEntry {
-  /** A list of messages that carry the error details. */
+  /// A list of messages that carry the error details.
   core.List<core.String> errorDetails;
-  /**
-   * A URL that refers to the target (a data source, a data sink,
-   * or an object) with which the error is associated.
-   * Required.
-   */
+
+  /// A URL that refers to the target (a data source, a data sink,
+  /// or an object) with which the error is associated.
+  /// Required.
   core.String url;
 
   ErrorLogEntry();
 
   ErrorLogEntry.fromJson(core.Map _json) {
     if (_json.containsKey("errorDetails")) {
       errorDetails = _json["errorDetails"];
     }
     if (_json.containsKey("url")) {
       url = _json["url"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (errorDetails != null) {
       _json["errorDetails"] = errorDetails;
     }
     if (url != null) {
       _json["url"] = url;
     }
     return _json;
   }
 }
 
-/**
- * A summary of errors by error code, plus a count and sample error log
- * entries.
- */
+/// A summary of errors by error code, plus a count and sample error log
+/// entries.
 class ErrorSummary {
-  /**
-   * Required.
-   * Possible string values are:
-   * - "OK" : Not an error; returned on success
-   *
-   * HTTP Mapping: 200 OK
-   * - "CANCELLED" : The operation was cancelled, typically by the caller.
-   *
-   * HTTP Mapping: 499 Client Closed Request
-   * - "UNKNOWN" : Unknown error.  For example, this error may be returned when
-   * a `Status` value received from another address space belongs to
-   * an error space that is not known in this address space.  Also
-   * errors raised by APIs that do not return enough error information
-   * may be converted to this error.
-   *
-   * HTTP Mapping: 500 Internal Server Error
-   * - "INVALID_ARGUMENT" : The client specified an invalid argument.  Note that
-   * this differs
-   * from `FAILED_PRECONDITION`.  `INVALID_ARGUMENT` indicates arguments
-   * that are problematic regardless of the state of the system
-   * (e.g., a malformed file name).
-   *
-   * HTTP Mapping: 400 Bad Request
-   * - "DEADLINE_EXCEEDED" : The deadline expired before the operation could
-   * complete. For operations
-   * that change the state of the system, this error may be returned
-   * even if the operation has completed successfully.  For example, a
-   * successful response from a server could have been delayed long
-   * enough for the deadline to expire.
-   *
-   * HTTP Mapping: 504 Gateway Timeout
-   * - "NOT_FOUND" : Some requested entity (e.g., file or directory) was not
-   * found.
-   *
-   * Note to server developers: if a request is denied for an entire class
-   * of users, such as gradual feature rollout or undocumented whitelist,
-   * `NOT_FOUND` may be used. If a request is denied for some users within
-   * a class of users, such as user-based access control, `PERMISSION_DENIED`
-   * must be used.
-   *
-   * HTTP Mapping: 404 Not Found
-   * - "ALREADY_EXISTS" : The entity that a client attempted to create (e.g.,
-   * file or directory)
-   * already exists.
-   *
-   * HTTP Mapping: 409 Conflict
-   * - "PERMISSION_DENIED" : The caller does not have permission to execute the
-   * specified
-   * operation. `PERMISSION_DENIED` must not be used for rejections
-   * caused by exhausting some resource (use `RESOURCE_EXHAUSTED`
-   * instead for those errors). `PERMISSION_DENIED` must not be
-   * used if the caller can not be identified (use `UNAUTHENTICATED`
-   * instead for those errors). This error code does not imply the
-   * request is valid or the requested entity exists or satisfies
-   * other pre-conditions.
-   *
-   * HTTP Mapping: 403 Forbidden
-   * - "UNAUTHENTICATED" : The request does not have valid authentication
-   * credentials for the
-   * operation.
-   *
-   * HTTP Mapping: 401 Unauthorized
-   * - "RESOURCE_EXHAUSTED" : Some resource has been exhausted, perhaps a
-   * per-user quota, or
-   * perhaps the entire file system is out of space.
-   *
-   * HTTP Mapping: 429 Too Many Requests
-   * - "FAILED_PRECONDITION" : The operation was rejected because the system is
-   * not in a state
-   * required for the operation's execution.  For example, the directory
-   * to be deleted is non-empty, an rmdir operation is applied to
-   * a non-directory, etc.
-   *
-   * Service implementors can use the following guidelines to decide
-   * between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:
-   *  (a) Use `UNAVAILABLE` if the client can retry just the failing call.
-   *  (b) Use `ABORTED` if the client should retry at a higher level
-   *      (e.g., when a client-specified test-and-set fails, indicating the
-   *      client should restart a read-modify-write sequence).
-   *  (c) Use `FAILED_PRECONDITION` if the client should not retry until
-   *      the system state has been explicitly fixed.  E.g., if an "rmdir"
-   *      fails because the directory is non-empty, `FAILED_PRECONDITION`
-   *      should be returned since the client should not retry unless
-   *      the files are deleted from the directory.
-   *
-   * HTTP Mapping: 400 Bad Request
-   * - "ABORTED" : The operation was aborted, typically due to a concurrency
-   * issue such as
-   * a sequencer check failure or transaction abort.
-   *
-   * See the guidelines above for deciding between `FAILED_PRECONDITION`,
-   * `ABORTED`, and `UNAVAILABLE`.
-   *
-   * HTTP Mapping: 409 Conflict
-   * - "OUT_OF_RANGE" : The operation was attempted past the valid range.  E.g.,
-   * seeking or
-   * reading past end-of-file.
-   *
-   * Unlike `INVALID_ARGUMENT`, this error indicates a problem that may
-   * be fixed if the system state changes. For example, a 32-bit file
-   * system will generate `INVALID_ARGUMENT` if asked to read at an
-   * offset that is not in the range [0,2^32-1], but it will generate
-   * `OUT_OF_RANGE` if asked to read from an offset past the current
-   * file size.
-   *
-   * There is a fair bit of overlap between `FAILED_PRECONDITION` and
-   * `OUT_OF_RANGE`.  We recommend using `OUT_OF_RANGE` (the more specific
-   * error) when it applies so that callers who are iterating through
-   * a space can easily look for an `OUT_OF_RANGE` error to detect when
-   * they are done.
-   *
-   * HTTP Mapping: 400 Bad Request
-   * - "UNIMPLEMENTED" : The operation is not implemented or is not
-   * supported/enabled in this
-   * service.
-   *
-   * HTTP Mapping: 501 Not Implemented
-   * - "INTERNAL" : Internal errors.  This means that some invariants expected
-   * by the
-   * underlying system have been broken.  This error code is reserved
-   * for serious errors.
-   *
-   * HTTP Mapping: 500 Internal Server Error
-   * - "UNAVAILABLE" : The service is currently unavailable.  This is most
-   * likely a
-   * transient condition, which can be corrected by retrying with
-   * a backoff.
-   *
-   * See the guidelines above for deciding between `FAILED_PRECONDITION`,
-   * `ABORTED`, and `UNAVAILABLE`.
-   *
-   * HTTP Mapping: 503 Service Unavailable
-   * - "DATA_LOSS" : Unrecoverable data loss or corruption.
-   *
-   * HTTP Mapping: 500 Internal Server Error
-   */
+  /// Required.
+  /// Possible string values are:
+  /// - "OK" : Not an error; returned on success
+  ///
+  /// HTTP Mapping: 200 OK
+  /// - "CANCELLED" : The operation was cancelled, typically by the caller.
+  ///
+  /// HTTP Mapping: 499 Client Closed Request
+  /// - "UNKNOWN" : Unknown error.  For example, this error may be returned
+  /// when
+  /// a `Status` value received from another address space belongs to
+  /// an error space that is not known in this address space.  Also
+  /// errors raised by APIs that do not return enough error information
+  /// may be converted to this error.
+  ///
+  /// HTTP Mapping: 500 Internal Server Error
+  /// - "INVALID_ARGUMENT" : The client specified an invalid argument.  Note
+  /// that this differs
+  /// from `FAILED_PRECONDITION`.  `INVALID_ARGUMENT` indicates arguments
+  /// that are problematic regardless of the state of the system
+  /// (e.g., a malformed file name).
+  ///
+  /// HTTP Mapping: 400 Bad Request
+  /// - "DEADLINE_EXCEEDED" : The deadline expired before the operation could
+  /// complete. For operations
+  /// that change the state of the system, this error may be returned
+  /// even if the operation has completed successfully.  For example, a
+  /// successful response from a server could have been delayed long
+  /// enough for the deadline to expire.
+  ///
+  /// HTTP Mapping: 504 Gateway Timeout
+  /// - "NOT_FOUND" : Some requested entity (e.g., file or directory) was not
+  /// found.
+  ///
+  /// Note to server developers: if a request is denied for an entire class
+  /// of users, such as gradual feature rollout or undocumented whitelist,
+  /// `NOT_FOUND` may be used. If a request is denied for some users within
+  /// a class of users, such as user-based access control, `PERMISSION_DENIED`
+  /// must be used.
+  ///
+  /// HTTP Mapping: 404 Not Found
+  /// - "ALREADY_EXISTS" : The entity that a client attempted to create (e.g.,
+  /// file or directory)
+  /// already exists.
+  ///
+  /// HTTP Mapping: 409 Conflict
+  /// - "PERMISSION_DENIED" : The caller does not have permission to execute
+  /// the specified
+  /// operation. `PERMISSION_DENIED` must not be used for rejections
+  /// caused by exhausting some resource (use `RESOURCE_EXHAUSTED`
+  /// instead for those errors). `PERMISSION_DENIED` must not be
+  /// used if the caller can not be identified (use `UNAUTHENTICATED`
+  /// instead for those errors). This error code does not imply the
+  /// request is valid or the requested entity exists or satisfies
+  /// other pre-conditions.
+  ///
+  /// HTTP Mapping: 403 Forbidden
+  /// - "UNAUTHENTICATED" : The request does not have valid authentication
+  /// credentials for the
+  /// operation.
+  ///
+  /// HTTP Mapping: 401 Unauthorized
+  /// - "RESOURCE_EXHAUSTED" : Some resource has been exhausted, perhaps a
+  /// per-user quota, or
+  /// perhaps the entire file system is out of space.
+  ///
+  /// HTTP Mapping: 429 Too Many Requests
+  /// - "FAILED_PRECONDITION" : The operation was rejected because the system
+  /// is not in a state
+  /// required for the operation's execution.  For example, the directory
+  /// to be deleted is non-empty, an rmdir operation is applied to
+  /// a non-directory, etc.
+  ///
+  /// Service implementors can use the following guidelines to decide
+  /// between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`:
+  ///  (a) Use `UNAVAILABLE` if the client can retry just the failing call.
+  ///  (b) Use `ABORTED` if the client should retry at a higher level
+  ///      (e.g., when a client-specified test-and-set fails, indicating the
+  ///      client should restart a read-modify-write sequence).
+  ///  (c) Use `FAILED_PRECONDITION` if the client should not retry until
+  ///      the system state has been explicitly fixed.  E.g., if an "rmdir"
+  ///      fails because the directory is non-empty, `FAILED_PRECONDITION`
+  ///      should be returned since the client should not retry unless
+  ///      the files are deleted from the directory.
+  ///
+  /// HTTP Mapping: 400 Bad Request
+  /// - "ABORTED" : The operation was aborted, typically due to a concurrency
+  /// issue such as
+  /// a sequencer check failure or transaction abort.
+  ///
+  /// See the guidelines above for deciding between `FAILED_PRECONDITION`,
+  /// `ABORTED`, and `UNAVAILABLE`.
+  ///
+  /// HTTP Mapping: 409 Conflict
+  /// - "OUT_OF_RANGE" : The operation was attempted past the valid range.
+  /// E.g., seeking or
+  /// reading past end-of-file.
+  ///
+  /// Unlike `INVALID_ARGUMENT`, this error indicates a problem that may
+  /// be fixed if the system state changes. For example, a 32-bit file
+  /// system will generate `INVALID_ARGUMENT` if asked to read at an
+  /// offset that is not in the range [0,2^32-1], but it will generate
+  /// `OUT_OF_RANGE` if asked to read from an offset past the current
+  /// file size.
+  ///
+  /// There is a fair bit of overlap between `FAILED_PRECONDITION` and
+  /// `OUT_OF_RANGE`.  We recommend using `OUT_OF_RANGE` (the more specific
+  /// error) when it applies so that callers who are iterating through
+  /// a space can easily look for an `OUT_OF_RANGE` error to detect when
+  /// they are done.
+  ///
+  /// HTTP Mapping: 400 Bad Request
+  /// - "UNIMPLEMENTED" : The operation is not implemented or is not
+  /// supported/enabled in this
+  /// service.
+  ///
+  /// HTTP Mapping: 501 Not Implemented
+  /// - "INTERNAL" : Internal errors.  This means that some invariants expected
+  /// by the
+  /// underlying system have been broken.  This error code is reserved
+  /// for serious errors.
+  ///
+  /// HTTP Mapping: 500 Internal Server Error
+  /// - "UNAVAILABLE" : The service is currently unavailable.  This is most
+  /// likely a
+  /// transient condition, which can be corrected by retrying with
+  /// a backoff.
+  ///
+  /// See the guidelines above for deciding between `FAILED_PRECONDITION`,
+  /// `ABORTED`, and `UNAVAILABLE`.
+  ///
+  /// HTTP Mapping: 503 Service Unavailable
+  /// - "DATA_LOSS" : Unrecoverable data loss or corruption.
+  ///
+  /// HTTP Mapping: 500 Internal Server Error
   core.String errorCode;
-  /**
-   * Count of this type of error.
-   * Required.
-   */
+
+  /// Count of this type of error.
+  /// Required.
   core.String errorCount;
-  /** Error samples. */
+
+  /// Error samples.
   core.List<ErrorLogEntry> errorLogEntries;
 
   ErrorSummary();
 
   ErrorSummary.fromJson(core.Map _json) {
     if (_json.containsKey("errorCode")) {
       errorCode = _json["errorCode"];
     }
     if (_json.containsKey("errorCount")) {
       errorCount = _json["errorCount"];
     }
     if (_json.containsKey("errorLogEntries")) {
-      errorLogEntries = _json["errorLogEntries"].map((value) => new ErrorLogEntry.fromJson(value)).toList();
+      errorLogEntries = _json["errorLogEntries"]
+          .map((value) => new ErrorLogEntry.fromJson(value))
+          .toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (errorCode != null) {
       _json["errorCode"] = errorCode;
     }
     if (errorCount != null) {
       _json["errorCount"] = errorCount;
     }
     if (errorLogEntries != null) {
-      _json["errorLogEntries"] = errorLogEntries.map((value) => (value).toJson()).toList();
+      _json["errorLogEntries"] =
+          errorLogEntries.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/**
- * In a GcsData, an object's name is the Google Cloud Storage object's name and
- * its `lastModificationTime` refers to the object's updated time, which changes
- * when the content or the metadata of the object is updated.
- */
+/// In a GcsData, an object's name is the Google Cloud Storage object's name
+/// and
+/// its `lastModificationTime` refers to the object's updated time, which
+/// changes
+/// when the content or the metadata of the object is updated.
 class GcsData {
-  /**
-   * Google Cloud Storage bucket name (see
-   * [Bucket Name
-   * Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
-   * Required.
-   */
+  /// Google Cloud Storage bucket name (see
+  /// [Bucket Name
+  /// Requirements](https://cloud.google.com/storage/docs/bucket-naming#requirements)).
+  /// Required.
   core.String bucketName;
 
   GcsData();
 
   GcsData.fromJson(core.Map _json) {
     if (_json.containsKey("bucketName")) {
       bucketName = _json["bucketName"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (bucketName != null) {
       _json["bucketName"] = bucketName;
     }
     return _json;
   }
 }
 
-/** Google service account */
+/// Google service account
 class GoogleServiceAccount {
-  /** Required. */
+  /// Required.
   core.String accountEmail;
 
   GoogleServiceAccount();
 
   GoogleServiceAccount.fromJson(core.Map _json) {
     if (_json.containsKey("accountEmail")) {
       accountEmail = _json["accountEmail"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (accountEmail != null) {
       _json["accountEmail"] = accountEmail;
     }
     return _json;
   }
 }
 
-/**
- * An HttpData specifies a list of objects on the web to be transferred over
- * HTTP.  The information of the objects to be transferred is contained in a
- * file referenced by a URL. The first line in the file must be
- * "TsvHttpData-1.0", which specifies the format of the file.  Subsequent lines
- * specify the information of the list of objects, one object per list entry.
- * Each entry has the following tab-delimited fields:
- *
- * * HTTP URL - The location of the object.
- *
- * * Length - The size of the object in bytes.
- *
- * * MD5 - The base64-encoded MD5 hash of the object.
- *
- * For an example of a valid TSV file, see
- * [Transferring data from
- * URLs](https://cloud.google.com/storage/transfer/#urls)
- *
- * When transferring data based on a URL list, keep the following in mind:
- *
- * * When an object located at `http(s)://hostname:port/<URL-path>` is
- * transferred
- * to a data sink, the name of the object at the data sink is
- * `<hostname>/<URL-path>`.
- *
- * * If the specified size of an object does not match the actual size of the
- * object fetched, the object will not be transferred.
- *
- * * If the specified MD5 does not match the MD5 computed from the transferred
- * bytes, the object transfer will fail. For more information, see
- * [Generating MD5 hashes](https://cloud.google.com/storage/transfer/#md5)
- *
- * * Ensure that each URL you specify is publicly accessible. For
- * example, in Google Cloud Storage you can
- * [share an object publicly]
- * (https://cloud.google.com/storage/docs/cloud-console#_sharingdata) and get
- * a link to it.
- *
- * * Storage Transfer Service obeys `robots.txt` rules and requires the source
- * HTTP server to support `Range` requests and to return a `Content-Length`
- * header in each response.
- *
- * * [ObjectConditions](#ObjectConditions) have no effect when filtering objects
- * to transfer.
- */
+/// An HttpData specifies a list of objects on the web to be transferred over
+/// HTTP.  The information of the objects to be transferred is contained in a
+/// file referenced by a URL. The first line in the file must be
+/// "TsvHttpData-1.0", which specifies the format of the file.  Subsequent
+/// lines
+/// specify the information of the list of objects, one object per list entry.
+/// Each entry has the following tab-delimited fields:
+///
+/// * HTTP URL - The location of the object.
+///
+/// * Length - The size of the object in bytes.
+///
+/// * MD5 - The base64-encoded MD5 hash of the object.
+///
+/// For an example of a valid TSV file, see
+/// [Transferring data from
+/// URLs](https://cloud.google.com/storage/transfer/create-url-list).
+///
+/// When transferring data based on a URL list, keep the following in mind:
+///
+/// * When an object located at `http(s)://hostname:port/<URL-path>` is
+/// transferred
+/// to a data sink, the name of the object at the data sink is
+/// `<hostname>/<URL-path>`.
+///
+/// * If the specified size of an object does not match the actual size of the
+/// object fetched, the object will not be transferred.
+///
+/// * If the specified MD5 does not match the MD5 computed from the transferred
+/// bytes, the object transfer will fail. For more information, see
+/// [Generating MD5 hashes](https://cloud.google.com/storage/transfer/#md5)
+///
+/// * Ensure that each URL you specify is publicly accessible. For
+/// example, in Google Cloud Storage you can
+/// [share an object publicly]
+/// (https://cloud.google.com/storage/docs/cloud-console#_sharingdata) and get
+/// a link to it.
+///
+/// * Storage Transfer Service obeys `robots.txt` rules and requires the source
+/// HTTP server to support `Range` requests and to return a `Content-Length`
+/// header in each response.
+///
+/// * [ObjectConditions](#ObjectConditions) have no effect when filtering
+/// objects
+/// to transfer.
 class HttpData {
-  /**
-   * The URL that points to the file that stores the object list entries.
-   * This file must allow public access.  Currently, only URLs with HTTP and
-   * HTTPS schemes are supported.
-   * Required.
-   */
+  /// The URL that points to the file that stores the object list entries.
+  /// This file must allow public access.  Currently, only URLs with HTTP and
+  /// HTTPS schemes are supported.
+  /// Required.
   core.String listUrl;
 
   HttpData();
 
   HttpData.fromJson(core.Map _json) {
     if (_json.containsKey("listUrl")) {
       listUrl = _json["listUrl"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (listUrl != null) {
       _json["listUrl"] = listUrl;
     }
     return _json;
   }
 }
 
-/** The response message for Operations.ListOperations. */
+/// The response message for Operations.ListOperations.
 class ListOperationsResponse {
-  /** The standard List next-page token. */
+  /// The standard List next-page token.
   core.String nextPageToken;
-  /** A list of operations that matches the specified filter in the request. */
+
+  /// 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();
+      operations = _json["operations"]
+          .map((value) => new Operation.fromJson(value))
+          .toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (operations != null) {
-      _json["operations"] = operations.map((value) => (value).toJson()).toList();
+      _json["operations"] =
+          operations.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** Response from ListTransferJobs. */
+/// Response from ListTransferJobs.
 class ListTransferJobsResponse {
-  /** The list next page token. */
+  /// The list next page token.
   core.String nextPageToken;
-  /** A list of transfer jobs. */
+
+  /// A list of transfer jobs.
   core.List<TransferJob> transferJobs;
 
   ListTransferJobsResponse();
 
   ListTransferJobsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("nextPageToken")) {
       nextPageToken = _json["nextPageToken"];
     }
     if (_json.containsKey("transferJobs")) {
-      transferJobs = _json["transferJobs"].map((value) => new TransferJob.fromJson(value)).toList();
+      transferJobs = _json["transferJobs"]
+          .map((value) => new TransferJob.fromJson(value))
+          .toList();
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (nextPageToken != null) {
       _json["nextPageToken"] = nextPageToken;
     }
     if (transferJobs != null) {
-      _json["transferJobs"] = transferJobs.map((value) => (value).toJson()).toList();
+      _json["transferJobs"] =
+          transferJobs.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
-/** Conditions that determine which objects will be transferred. */
+/// Conditions that determine which objects will be transferred.
 class ObjectConditions {
-  /**
-   * `excludePrefixes` must follow the requirements described for
-   * `includePrefixes`.
-   *
-   * The max size of `excludePrefixes` is 1000.
-   */
+  /// `excludePrefixes` must follow the requirements described for
+  /// `includePrefixes`.
+  ///
+  /// The max size of `excludePrefixes` is 1000.
   core.List<core.String> excludePrefixes;
-  /**
-   * If `includePrefixes` is specified, objects that satisfy the object
-   * conditions must have names that start with one of the `includePrefixes`
-   * and that do not start with any of the `excludePrefixes`. If
-   * `includePrefixes`
-   * is not specified, all objects except those that have names starting with
-   * one of the `excludePrefixes` must satisfy the object conditions.
-   *
-   * Requirements:
-   *
-   *   * Each include-prefix and exclude-prefix can contain any sequence of
-   *     Unicode characters, of max length 1024 bytes when UTF8-encoded, and
-   *     must not contain Carriage Return or Line Feed characters.  Wildcard
-   *     matching and regular expression matching are not supported.
-   *
-   *   * Each include-prefix and exclude-prefix must omit the leading slash.
-   *     For example, to include the `requests.gz` object in a transfer from
-   *     `s3://my-aws-bucket/logs/y=2015/requests.gz`, specify the include
-   *     prefix as `logs/y=2015/requests.gz`.
-   *
-   *   * None of the include-prefix or the exclude-prefix values can be empty,
-   *     if specified.
-   *
-   *   * Each include-prefix must include a distinct portion of the object
-   *     namespace, i.e., no include-prefix may be a prefix of another
-   *     include-prefix.
-   *
-   *   * Each exclude-prefix must exclude a distinct portion of the object
-   *     namespace, i.e., no exclude-prefix may be a prefix of another
-   *     exclude-prefix.
-   *
-   *   * If `includePrefixes` is specified, then each exclude-prefix must start
-   *     with the value of a path explicitly included by `includePrefixes`.
-   *
-   * The max size of `includePrefixes` is 1000.
-   */
+
+  /// If `includePrefixes` is specified, objects that satisfy the object
+  /// conditions must have names that start with one of the `includePrefixes`
+  /// and that do not start with any of the `excludePrefixes`. If
+  /// `includePrefixes`
+  /// is not specified, all objects except those that have names starting with
+  /// one of the `excludePrefixes` must satisfy the object conditions.
+  ///
+  /// Requirements:
+  ///
+  ///   * Each include-prefix and exclude-prefix can contain any sequence of
+  ///     Unicode characters, of max length 1024 bytes when UTF8-encoded, and
+  ///     must not contain Carriage Return or Line Feed characters.  Wildcard
+  ///     matching and regular expression matching are not supported.
+  ///
+  ///   * Each include-prefix and exclude-prefix must omit the leading slash.
+  ///     For example, to include the `requests.gz` object in a transfer from
+  ///     `s3://my-aws-bucket/logs/y=2015/requests.gz`, specify the include
+  ///     prefix as `logs/y=2015/requests.gz`.
+  ///
+  /// * None of the include-prefix or the exclude-prefix values can be empty,
+  ///     if specified.
+  ///
+  ///   * Each include-prefix must include a distinct portion of the object
+  ///     namespace, i.e., no include-prefix may be a prefix of another
+  ///     include-prefix.
+  ///
+  ///   * Each exclude-prefix must exclude a distinct portion of the object
+  ///     namespace, i.e., no exclude-prefix may be a prefix of another
+  ///     exclude-prefix.
+  ///
+  /// * If `includePrefixes` is specified, then each exclude-prefix must start
+  ///     with the value of a path explicitly included by `includePrefixes`.
+  ///
+  /// The max size of `includePrefixes` is 1000.
   core.List<core.String> includePrefixes;
-  /**
-   * `maxTimeElapsedSinceLastModification` is the complement to
-   * `minTimeElapsedSinceLastModification`.
-   */
+
+  /// `maxTimeElapsedSinceLastModification` is the complement to
+  /// `minTimeElapsedSinceLastModification`.
   core.String maxTimeElapsedSinceLastModification;
-  /**
-   * If unspecified, `minTimeElapsedSinceLastModification` takes a zero value
-   * and `maxTimeElapsedSinceLastModification` takes the maximum possible
-   * value of Duration. Objects that satisfy the object conditions
-   * must either have a `lastModificationTime` greater or equal to
-   * `NOW` - `maxTimeElapsedSinceLastModification` and less than
-   * `NOW` - `minTimeElapsedSinceLastModification`, or not have a
-   * `lastModificationTime`.
-   */
+
+  /// If unspecified, `minTimeElapsedSinceLastModification` takes a zero value
+  /// and `maxTimeElapsedSinceLastModification` takes the maximum possible
+  /// value of Duration. Objects that satisfy the object conditions
+  /// must either have a `lastModificationTime` greater or equal to
+  /// `NOW` - `maxTimeElapsedSinceLastModification` and less than
+  /// `NOW` - `minTimeElapsedSinceLastModification`, or not have a
+  /// `lastModificationTime`.
   core.String minTimeElapsedSinceLastModification;
 
   ObjectConditions();
 
   ObjectConditions.fromJson(core.Map _json) {
     if (_json.containsKey("excludePrefixes")) {
       excludePrefixes = _json["excludePrefixes"];
     }
     if (_json.containsKey("includePrefixes")) {
       includePrefixes = _json["includePrefixes"];
     }
     if (_json.containsKey("maxTimeElapsedSinceLastModification")) {
-      maxTimeElapsedSinceLastModification = _json["maxTimeElapsedSinceLastModification"];
+      maxTimeElapsedSinceLastModification =
+          _json["maxTimeElapsedSinceLastModification"];
     }
     if (_json.containsKey("minTimeElapsedSinceLastModification")) {
-      minTimeElapsedSinceLastModification = _json["minTimeElapsedSinceLastModification"];
+      minTimeElapsedSinceLastModification =
+          _json["minTimeElapsedSinceLastModification"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (excludePrefixes != null) {
       _json["excludePrefixes"] = excludePrefixes;
     }
     if (includePrefixes != null) {
       _json["includePrefixes"] = includePrefixes;
     }
     if (maxTimeElapsedSinceLastModification != null) {
-      _json["maxTimeElapsedSinceLastModification"] = maxTimeElapsedSinceLastModification;
+      _json["maxTimeElapsedSinceLastModification"] =
+          maxTimeElapsedSinceLastModification;
     }
     if (minTimeElapsedSinceLastModification != null) {
-      _json["minTimeElapsedSinceLastModification"] = minTimeElapsedSinceLastModification;
+      _json["minTimeElapsedSinceLastModification"] =
+          minTimeElapsedSinceLastModification;
     }
     return _json;
   }
 }
 
-/**
- * This resource represents a long-running operation that is the result of a
- * network API call.
- */
+/// 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.
-   */
+  /// 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 or cancellation. */
+
+  /// The error result of the operation in case of failure or cancellation.
   Status error;
-  /**
-   * Represents the transfer operation object.
-   *
-   * The values for Object must be JSON objects. It can consist of `num`,
-   * `String`, `bool` and `null` as well as `Map` and `List` values.
-   */
+
+  /// Represents the transfer operation object.
+  ///
+  /// 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, the `name`
-   * should have the format of `transferOperations/some/unique/name`.
-   */
+
+  /// The server-assigned name, which is only unique within the same service
+  /// that originally returns it. If you use the default HTTP mapping, the
+  /// `name` should have the format of `transferOperations/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.
-   */
+
+  /// 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<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     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;
   }
 }
 
-/** Request passed to PauseTransferOperation. */
+/// Request passed to PauseTransferOperation.
 class PauseTransferOperationRequest {
-
   PauseTransferOperationRequest();
 
-  PauseTransferOperationRequest.fromJson(core.Map _json) {
-  }
+  PauseTransferOperationRequest.fromJson(core.Map _json) {}
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     return _json;
   }
 }
 
-/** Request passed to ResumeTransferOperation. */
+/// Request passed to ResumeTransferOperation.
 class ResumeTransferOperationRequest {
-
   ResumeTransferOperationRequest();
 
-  ResumeTransferOperationRequest.fromJson(core.Map _json) {
-  }
+  ResumeTransferOperationRequest.fromJson(core.Map _json) {}
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     return _json;
   }
 }
 
-/** Transfers can be scheduled to recur or to run just once. */
+/// Transfers can be scheduled to recur or to run just once.
 class Schedule {
-  /**
-   * The last day the recurring transfer will be run. If `scheduleEndDate`
-   * is the same as `scheduleStartDate`, the transfer will be executed only
-   * once.
-   */
+  /// The last day the recurring transfer will be run. If `scheduleEndDate`
+  /// is the same as `scheduleStartDate`, the transfer will be executed only
+  /// once.
   Date scheduleEndDate;
-  /**
-   * The first day the recurring transfer is scheduled to run. If
-   * `scheduleStartDate` is in the past, the transfer will run for the first
-   * time on the following day.
-   * Required.
-   */
+
+  /// The first day the recurring transfer is scheduled to run. If
+  /// `scheduleStartDate` is in the past, the transfer will run for the first
+  /// time on the following day.
+  /// Required.
   Date scheduleStartDate;
-  /**
-   * The time in UTC at which the transfer will be scheduled to start in a day.
-   * Transfers may start later than this time. If not specified, recurring and
-   * one-time transfers that are scheduled to run today will run immediately;
-   * recurring transfers that are scheduled to run on a future date will start
-   * at approximately midnight UTC on that date. Note that when configuring a
-   * transfer with the Cloud Platform Console, the transfer's start time in a
-   * day is specified in your local timezone.
-   */
+
+  /// The time in UTC at which the transfer will be scheduled to start in a
+  /// day.
+  /// Transfers may start later than this time. If not specified, recurring and
+  /// one-time transfers that are scheduled to run today will run immediately;
+  /// recurring transfers that are scheduled to run on a future date will start
+  /// at approximately midnight UTC on that date. Note that when configuring a
+  /// transfer with the Cloud Platform Console, the transfer's start time in a
+  /// day is specified in your local timezone.
   TimeOfDay startTimeOfDay;
 
   Schedule();
 
   Schedule.fromJson(core.Map _json) {
     if (_json.containsKey("scheduleEndDate")) {
       scheduleEndDate = new Date.fromJson(_json["scheduleEndDate"]);
     }
     if (_json.containsKey("scheduleStartDate")) {
       scheduleStartDate = new Date.fromJson(_json["scheduleStartDate"]);
     }
     if (_json.containsKey("startTimeOfDay")) {
       startTimeOfDay = new TimeOfDay.fromJson(_json["startTimeOfDay"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (scheduleEndDate != null) {
       _json["scheduleEndDate"] = (scheduleEndDate).toJson();
     }
     if (scheduleStartDate != null) {
       _json["scheduleStartDate"] = (scheduleStartDate).toJson();
     }
     if (startTimeOfDay != null) {
       _json["startTimeOfDay"] = (startTimeOfDay).toJson();
     }
     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` that 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.
- *
- * - 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.
- */
+/// 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` that 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.
+///
+/// - 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. */
+  /// 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 is 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.
-   */
+
+  /// A list of messages that carry the error details.  There is 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.
-   */
+
+  /// 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<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (code != null) {
       _json["code"] = code;
     }
     if (details != null) {
       _json["details"] = details;
     }
     if (message != null) {
       _json["message"] = message;
     }
     return _json;
   }
 }
 
-/**
- * Represents a time of day. The date and time zone are either not significant
- * or are specified elsewhere. An API may choose to allow leap seconds. Related
- * types are google.type.Date and `google.protobuf.Timestamp`.
- */
+/// Represents a time of day. The date and time zone are either not significant
+/// or are specified elsewhere. An API may choose to allow leap seconds.
+/// Related
+/// types are google.type.Date and `google.protobuf.Timestamp`.
 class TimeOfDay {
-  /**
-   * Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
-   * to allow the value "24:00:00" for scenarios like business closing time.
-   */
+  /// Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
+  /// to allow the value "24:00:00" for scenarios like business closing time.
   core.int hours;
-  /** Minutes of hour of day. Must be from 0 to 59. */
+
+  /// Minutes of hour of day. Must be from 0 to 59.
   core.int minutes;
-  /** Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999. */
+
+  /// Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
   core.int nanos;
-  /**
-   * Seconds of minutes of the time. Must normally be from 0 to 59. An API may
-   * allow the value 60 if it allows leap-seconds.
-   */
+
+  /// Seconds of minutes of the time. Must normally be from 0 to 59. An API may
+  /// allow the value 60 if it allows leap-seconds.
   core.int seconds;
 
   TimeOfDay();
 
   TimeOfDay.fromJson(core.Map _json) {
     if (_json.containsKey("hours")) {
       hours = _json["hours"];
     }
     if (_json.containsKey("minutes")) {
       minutes = _json["minutes"];
     }
     if (_json.containsKey("nanos")) {
       nanos = _json["nanos"];
     }
     if (_json.containsKey("seconds")) {
       seconds = _json["seconds"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (hours != null) {
       _json["hours"] = hours;
     }
     if (minutes != null) {
       _json["minutes"] = minutes;
     }
     if (nanos != null) {
       _json["nanos"] = nanos;
     }
     if (seconds != null) {
       _json["seconds"] = seconds;
     }
     return _json;
   }
 }
 
-/**
- * A collection of counters that report the progress of a transfer operation.
- */
+/// A collection of counters that report the progress of a transfer operation.
 class TransferCounters {
-  /** Bytes that are copied to the data sink. */
+  /// Bytes that are copied to the data sink.
   core.String bytesCopiedToSink;
-  /** Bytes that are deleted from the data sink. */
+
+  /// Bytes that are deleted from the data sink.
   core.String bytesDeletedFromSink;
-  /** Bytes that are deleted from the data source. */
+
+  /// Bytes that are deleted from the data source.
   core.String bytesDeletedFromSource;
-  /** Bytes that failed to be deleted from the data sink. */
+
+  /// Bytes that failed to be deleted from the data sink.
   core.String bytesFailedToDeleteFromSink;
-  /**
-   * Bytes found in the data source that are scheduled to be transferred,
-   * which will be copied, excluded based on conditions, or skipped due to
-   * failures.
-   */
+
+  /// Bytes found in the data source that are scheduled to be transferred,
+  /// which will be copied, excluded based on conditions, or skipped due to
+  /// failures.
   core.String bytesFoundFromSource;
-  /** Bytes found only in the data sink that are scheduled to be deleted. */
+
+  /// Bytes found only in the data sink that are scheduled to be deleted.
   core.String bytesFoundOnlyFromSink;
-  /** Bytes in the data source that failed during the transfer. */
+
+  /// Bytes in the data source that failed during the transfer.
   core.String bytesFromSourceFailed;
-  /**
-   * Bytes in the data source that are not transferred because they already
-   * exist in the data sink.
-   */
+
+  /// Bytes in the data source that are not transferred because they already
+  /// exist in the data sink.
   core.String bytesFromSourceSkippedBySync;
-  /** Objects that are copied to the data sink. */
+
+  /// Objects that are copied to the data sink.
   core.String objectsCopiedToSink;
-  /** Objects that are deleted from the data sink. */
+
+  /// Objects that are deleted from the data sink.
   core.String objectsDeletedFromSink;
-  /** Objects that are deleted from the data source. */
+
+  /// Objects that are deleted from the data source.
   core.String objectsDeletedFromSource;
-  /** Objects that failed to be deleted from the data sink. */
+
+  /// Objects that failed to be deleted from the data sink.
   core.String objectsFailedToDeleteFromSink;
-  /**
-   * Objects found in the data source that are scheduled to be transferred,
-   * which will be copied, excluded based on conditions, or skipped due to
-   * failures.
-   */
+
+  /// Objects found in the data source that are scheduled to be transferred,
+  /// which will be copied, excluded based on conditions, or skipped due to
+  /// failures.
   core.String objectsFoundFromSource;
-  /** Objects found only in the data sink that are scheduled to be deleted. */
+
+  /// Objects found only in the data sink that are scheduled to be deleted.
   core.String objectsFoundOnlyFromSink;
-  /** Objects in the data source that failed during the transfer. */
+
+  /// Objects in the data source that failed during the transfer.
   core.String objectsFromSourceFailed;
-  /**
-   * Objects in the data source that are not transferred because they already
-   * exist in the data sink.
-   */
+
+  /// Objects in the data source that are not transferred because they already
+  /// exist in the data sink.
   core.String objectsFromSourceSkippedBySync;
 
   TransferCounters();
 
   TransferCounters.fromJson(core.Map _json) {
     if (_json.containsKey("bytesCopiedToSink")) {
       bytesCopiedToSink = _json["bytesCopiedToSink"];
     }
     if (_json.containsKey("bytesDeletedFromSink")) {
       bytesDeletedFromSink = _json["bytesDeletedFromSink"];
@@ skipping 36 matching lines @@
     }
     if (_json.containsKey("objectsFromSourceFailed")) {
       objectsFromSourceFailed = _json["objectsFromSourceFailed"];
     }
     if (_json.containsKey("objectsFromSourceSkippedBySync")) {
       objectsFromSourceSkippedBySync = _json["objectsFromSourceSkippedBySync"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (bytesCopiedToSink != null) {
       _json["bytesCopiedToSink"] = bytesCopiedToSink;
     }
     if (bytesDeletedFromSink != null) {
       _json["bytesDeletedFromSink"] = bytesDeletedFromSink;
     }
     if (bytesDeletedFromSource != null) {
       _json["bytesDeletedFromSource"] = bytesDeletedFromSource;
     }
     if (bytesFailedToDeleteFromSink != null) {
@@ skipping 32 matching lines @@
     if (objectsFromSourceFailed != null) {
       _json["objectsFromSourceFailed"] = objectsFromSourceFailed;
     }
     if (objectsFromSourceSkippedBySync != null) {
       _json["objectsFromSourceSkippedBySync"] = objectsFromSourceSkippedBySync;
     }
     return _json;
   }
 }
 
-/**
- * This resource represents the configuration of a transfer job that runs
- * periodically.
- */
+/// This resource represents the configuration of a transfer job that runs
+/// periodically.
 class TransferJob {
-  /** This field cannot be changed by user requests. */
+  /// This field cannot be changed by user requests.
   core.String creationTime;
-  /** This field cannot be changed by user requests. */
+
+  /// This field cannot be changed by user requests.
   core.String deletionTime;
-  /**
-   * A description provided by the user for the job. Its max length is 1024
-   * bytes when Unicode-encoded.
-   */
+
+  /// A description provided by the user for the job. Its max length is 1024
+  /// bytes when Unicode-encoded.
   core.String description;
-  /** This field cannot be changed by user requests. */
+
+  /// This field cannot be changed by user requests.
   core.String lastModificationTime;
-  /**
-   * A globally unique name assigned by Storage Transfer Service when the
-   * job is created. This field should be left empty in requests to create a new
-   * transfer job; otherwise, the requests result in an `INVALID_ARGUMENT`
-   * error.
-   */
+
+  /// A globally unique name assigned by Storage Transfer Service when the
+  /// job is created. This field should be left empty in requests to create a
+  /// new
+  /// transfer job; otherwise, the requests result in an `INVALID_ARGUMENT`
+  /// error.
   core.String name;
-  /**
-   * The ID of the Google Cloud Platform Console project that owns the job.
-   * Required.
-   */
+
+  /// The ID of the Google Cloud Platform Console project that owns the job.
+  /// Required.
   core.String projectId;
-  /**
-   * Schedule specification.
-   * Required.
-   */
+
+  /// Schedule specification.
+  /// Required.
   Schedule schedule;
-  /**
-   * Status of the job. This value MUST be specified for
-   * `CreateTransferJobRequests`.
-   *
-   * NOTE: The effect of the new job status takes place during a subsequent job
-   * run. For example, if you change the job status from `ENABLED` to
-   * `DISABLED`, and an operation spawned by the transfer is running, the status
-   * change would not affect the current operation.
-   * Possible string values are:
-   * - "STATUS_UNSPECIFIED" : Zero is an illegal value.
-   * - "ENABLED" : New transfers will be performed based on the schedule.
-   * - "DISABLED" : New transfers will not be scheduled.
-   * - "DELETED" : This is a soft delete state. After a transfer job is set to
-   * this
-   * state, the job and all the transfer executions are subject to
-   * garbage collection.
-   */
+
+  /// Status of the job. This value MUST be specified for
+  /// `CreateTransferJobRequests`.
+  ///
+  /// NOTE: The effect of the new job status takes place during a subsequent
+  /// job
+  /// run. For example, if you change the job status from `ENABLED` to
+  /// `DISABLED`, and an operation spawned by the transfer is running, the
+  /// status
+  /// change would not affect the current operation.
+  /// Possible string values are:
+  /// - "STATUS_UNSPECIFIED" : Zero is an illegal value.
+  /// - "ENABLED" : New transfers will be performed based on the schedule.
+  /// - "DISABLED" : New transfers will not be scheduled.
+  /// - "DELETED" : This is a soft delete state. After a transfer job is set to
+  /// this
+  /// state, the job and all the transfer executions are subject to
+  /// garbage collection.
   core.String status;
-  /**
-   * Transfer specification.
-   * Required.
-   */
+
+  /// Transfer specification.
+  /// Required.
   TransferSpec transferSpec;
 
   TransferJob();
 
   TransferJob.fromJson(core.Map _json) {
     if (_json.containsKey("creationTime")) {
       creationTime = _json["creationTime"];
     }
     if (_json.containsKey("deletionTime")) {
       deletionTime = _json["deletionTime"];
@@ skipping 15 matching lines @@
     }
     if (_json.containsKey("status")) {
       status = _json["status"];
     }
     if (_json.containsKey("transferSpec")) {
       transferSpec = new TransferSpec.fromJson(_json["transferSpec"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (creationTime != null) {
       _json["creationTime"] = creationTime;
     }
     if (deletionTime != null) {
       _json["deletionTime"] = deletionTime;
     }
     if (description != null) {
       _json["description"] = description;
     }
     if (lastModificationTime != null) {
@@ skipping 11 matching lines @@
     if (status != null) {
       _json["status"] = status;
     }
     if (transferSpec != null) {
       _json["transferSpec"] = (transferSpec).toJson();
     }
     return _json;
   }
 }
 
-/** A description of the execution of a transfer. */
+/// A description of the execution of a transfer.
 class TransferOperation {
-  /** Information about the progress of the transfer operation. */
+  /// Information about the progress of the transfer operation.
   TransferCounters counters;
-  /** End time of this transfer execution. */
+
+  /// End time of this transfer execution.
   core.String endTime;
-  /** Summarizes errors encountered with sample error log entries. */
+
+  /// Summarizes errors encountered with sample error log entries.
   core.List<ErrorSummary> errorBreakdowns;
-  /** A globally unique ID assigned by the system. */
+
+  /// A globally unique ID assigned by the system.
   core.String name;
-  /**
-   * The ID of the Google Cloud Platform Console project that owns the
-   * operation.
-   * Required.
-   */
+
+  /// The ID of the Google Cloud Platform Console project that owns the
+  /// operation.
+  /// Required.
   core.String projectId;
-  /** Start time of this transfer execution. */
+
+  /// Start time of this transfer execution.
   core.String startTime;
-  /**
-   * Status of the transfer operation.
-   * Possible string values are:
-   * - "STATUS_UNSPECIFIED" : Zero is an illegal value.
-   * - "IN_PROGRESS" : In progress.
-   * - "PAUSED" : Paused.
-   * - "SUCCESS" : Completed successfully.
-   * - "FAILED" : Terminated due to an unrecoverable failure.
-   * - "ABORTED" : Aborted by the user.
-   */
+
+  /// Status of the transfer operation.
+  /// Possible string values are:
+  /// - "STATUS_UNSPECIFIED" : Zero is an illegal value.
+  /// - "IN_PROGRESS" : In progress.
+  /// - "PAUSED" : Paused.
+  /// - "SUCCESS" : Completed successfully.
+  /// - "FAILED" : Terminated due to an unrecoverable failure.
+  /// - "ABORTED" : Aborted by the user.
   core.String status;
-  /** The name of the transfer job that triggers this transfer operation. */
+
+  /// The name of the transfer job that triggers this transfer operation.
   core.String transferJobName;
-  /**
-   * Transfer specification.
-   * Required.
-   */
+
+  /// Transfer specification.
+  /// Required.
   TransferSpec transferSpec;
 
   TransferOperation();
 
   TransferOperation.fromJson(core.Map _json) {
     if (_json.containsKey("counters")) {
       counters = new TransferCounters.fromJson(_json["counters"]);
     }
     if (_json.containsKey("endTime")) {
       endTime = _json["endTime"];
     }
     if (_json.containsKey("errorBreakdowns")) {
-      errorBreakdowns = _json["errorBreakdowns"].map((value) => new ErrorSummary.fromJson(value)).toList();
+      errorBreakdowns = _json["errorBreakdowns"]
+          .map((value) => new ErrorSummary.fromJson(value))
+          .toList();
     }
     if (_json.containsKey("name")) {
       name = _json["name"];
     }
     if (_json.containsKey("projectId")) {
       projectId = _json["projectId"];
     }
     if (_json.containsKey("startTime")) {
       startTime = _json["startTime"];
     }
     if (_json.containsKey("status")) {
       status = _json["status"];
     }
     if (_json.containsKey("transferJobName")) {
       transferJobName = _json["transferJobName"];
     }
     if (_json.containsKey("transferSpec")) {
       transferSpec = new TransferSpec.fromJson(_json["transferSpec"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (counters != null) {
       _json["counters"] = (counters).toJson();
     }
     if (endTime != null) {
       _json["endTime"] = endTime;
     }
     if (errorBreakdowns != null) {
-      _json["errorBreakdowns"] = errorBreakdowns.map((value) => (value).toJson()).toList();
+      _json["errorBreakdowns"] =
+          errorBreakdowns.map((value) => (value).toJson()).toList();
     }
     if (name != null) {
       _json["name"] = name;
     }
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     if (startTime != null) {
       _json["startTime"] = startTime;
     }
     if (status != null) {
       _json["status"] = status;
     }
     if (transferJobName != null) {
       _json["transferJobName"] = transferJobName;
     }
     if (transferSpec != null) {
       _json["transferSpec"] = (transferSpec).toJson();
     }
     return _json;
   }
 }
 
-/**
- * TransferOptions uses three boolean parameters to define the actions
- * to be performed on objects in a transfer.
- */
+/// TransferOptions uses three boolean parameters to define the actions
+/// to be performed on objects in a transfer.
 class TransferOptions {
-  /**
-   * Whether objects should be deleted from the source after they are
-   * transferred to the sink.  Note that this option and
-   * `deleteObjectsUniqueInSink` are mutually exclusive.
-   */
+  /// Whether objects should be deleted from the source after they are
+  /// transferred to the sink.  Note that this option and
+  /// `deleteObjectsUniqueInSink` are mutually exclusive.
   core.bool deleteObjectsFromSourceAfterTransfer;
-  /**
-   * Whether objects that exist only in the sink should be deleted.  Note that
-   * this option and `deleteObjectsFromSourceAfterTransfer` are mutually
-   * exclusive.
-   */
+
+  /// Whether objects that exist only in the sink should be deleted.  Note that
+  /// this option and `deleteObjectsFromSourceAfterTransfer` are mutually
+  /// exclusive.
   core.bool deleteObjectsUniqueInSink;
-  /** Whether overwriting objects that already exist in the sink is allowed. */
+
+  /// Whether overwriting objects that already exist in the sink is allowed.
   core.bool overwriteObjectsAlreadyExistingInSink;
 
   TransferOptions();
 
   TransferOptions.fromJson(core.Map _json) {
     if (_json.containsKey("deleteObjectsFromSourceAfterTransfer")) {
-      deleteObjectsFromSourceAfterTransfer = _json["deleteObjectsFromSourceAfterTransfer"];
+      deleteObjectsFromSourceAfterTransfer =
+          _json["deleteObjectsFromSourceAfterTransfer"];
     }
     if (_json.containsKey("deleteObjectsUniqueInSink")) {
       deleteObjectsUniqueInSink = _json["deleteObjectsUniqueInSink"];
     }
     if (_json.containsKey("overwriteObjectsAlreadyExistingInSink")) {
-      overwriteObjectsAlreadyExistingInSink = _json["overwriteObjectsAlreadyExistingInSink"];
+      overwriteObjectsAlreadyExistingInSink =
+          _json["overwriteObjectsAlreadyExistingInSink"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (deleteObjectsFromSourceAfterTransfer != null) {
-      _json["deleteObjectsFromSourceAfterTransfer"] = deleteObjectsFromSourceAfterTransfer;
+      _json["deleteObjectsFromSourceAfterTransfer"] =
+          deleteObjectsFromSourceAfterTransfer;
     }
     if (deleteObjectsUniqueInSink != null) {
       _json["deleteObjectsUniqueInSink"] = deleteObjectsUniqueInSink;
     }
     if (overwriteObjectsAlreadyExistingInSink != null) {
-      _json["overwriteObjectsAlreadyExistingInSink"] = overwriteObjectsAlreadyExistingInSink;
+      _json["overwriteObjectsAlreadyExistingInSink"] =
+          overwriteObjectsAlreadyExistingInSink;
     }
     return _json;
   }
 }
 
-/** Configuration for running a transfer. */
+/// Configuration for running a transfer.
 class TransferSpec {
-  /** An AWS S3 data source. */
+  /// An AWS S3 data source.
   AwsS3Data awsS3DataSource;
-  /** A Google Cloud Storage data sink. */
+
+  /// A Google Cloud Storage data sink.
   GcsData gcsDataSink;
-  /** A Google Cloud Storage data source. */
+
+  /// A Google Cloud Storage data source.
   GcsData gcsDataSource;
-  /** An HTTP URL data source. */
+
+  /// An HTTP URL data source.
   HttpData httpDataSource;
-  /**
-   * Only objects that satisfy these object conditions are included in the set
-   * of data source and data sink objects.  Object conditions based on
-   * objects' `lastModificationTime` do not exclude objects in a data sink.
-   */
+
+  /// Only objects that satisfy these object conditions are included in the set
+  /// of data source and data sink objects.  Object conditions based on
+  /// objects' `lastModificationTime` do not exclude objects in a data sink.
   ObjectConditions objectConditions;
-  /**
-   * If the option `deleteObjectsUniqueInSink` is `true`, object conditions
-   * based on objects' `lastModificationTime` are ignored and do not exclude
-   * objects in a data source or a data sink.
-   */
+
+  /// If the option `deleteObjectsUniqueInSink` is `true`, object conditions
+  /// based on objects' `lastModificationTime` are ignored and do not exclude
+  /// objects in a data source or a data sink.
   TransferOptions transferOptions;
 
   TransferSpec();
 
   TransferSpec.fromJson(core.Map _json) {
     if (_json.containsKey("awsS3DataSource")) {
       awsS3DataSource = new AwsS3Data.fromJson(_json["awsS3DataSource"]);
     }
     if (_json.containsKey("gcsDataSink")) {
       gcsDataSink = new GcsData.fromJson(_json["gcsDataSink"]);
     }
     if (_json.containsKey("gcsDataSource")) {
       gcsDataSource = new GcsData.fromJson(_json["gcsDataSource"]);
     }
     if (_json.containsKey("httpDataSource")) {
       httpDataSource = new HttpData.fromJson(_json["httpDataSource"]);
     }
     if (_json.containsKey("objectConditions")) {
-      objectConditions = new ObjectConditions.fromJson(_json["objectConditions"]);
+      objectConditions =
+          new ObjectConditions.fromJson(_json["objectConditions"]);
     }
     if (_json.containsKey("transferOptions")) {
       transferOptions = new TransferOptions.fromJson(_json["transferOptions"]);
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (awsS3DataSource != null) {
       _json["awsS3DataSource"] = (awsS3DataSource).toJson();
     }
     if (gcsDataSink != null) {
       _json["gcsDataSink"] = (gcsDataSink).toJson();
     }
     if (gcsDataSource != null) {
       _json["gcsDataSource"] = (gcsDataSource).toJson();
     }
     if (httpDataSource != null) {
       _json["httpDataSource"] = (httpDataSource).toJson();
     }
     if (objectConditions != null) {
       _json["objectConditions"] = (objectConditions).toJson();
     }
     if (transferOptions != null) {
       _json["transferOptions"] = (transferOptions).toJson();
     }
     return _json;
   }
 }
 
-/** Request passed to UpdateTransferJob. */
+/// Request passed to UpdateTransferJob.
 class UpdateTransferJobRequest {
-  /**
-   * The ID of the Google Cloud Platform Console project that owns the job.
-   * Required.
-   */
+  /// The ID of the Google Cloud Platform Console project that owns the job.
+  /// Required.
   core.String projectId;
-  /**
-   * The job to update. `transferJob` is expected to specify only three fields:
-   * `description`, `transferSpec`, and `status`.  An UpdateTransferJobRequest
-   * that specifies other fields will be rejected with an error
-   * `INVALID_ARGUMENT`.
-   * Required.
-   */
+
+  /// The job to update. `transferJob` is expected to specify only three
+  /// fields:
+  /// `description`, `transferSpec`, and `status`.  An UpdateTransferJobRequest
+  /// that specifies other fields will be rejected with an error
+  /// `INVALID_ARGUMENT`.
+  /// Required.
   TransferJob transferJob;
-  /**
-   * The field mask of the fields in `transferJob` that are to be updated in
-   * this request.  Fields in `transferJob` that can be updated are:
-   * `description`, `transferSpec`, and `status`.  To update the `transferSpec`
-   * of the job, a complete transfer specification has to be provided. An
-   * incomplete specification which misses any required fields will be rejected
-   * with the error `INVALID_ARGUMENT`.
-   */
+
+  /// The field mask of the fields in `transferJob` that are to be updated in
+  /// this request.  Fields in `transferJob` that can be updated are:
+  /// `description`, `transferSpec`, and `status`.  To update the
+  /// `transferSpec`
+  /// of the job, a complete transfer specification has to be provided. An
+  /// incomplete specification which misses any required fields will be
+  /// rejected
+  /// with the error `INVALID_ARGUMENT`.
   core.String updateTransferJobFieldMask;
 
   UpdateTransferJobRequest();
 
   UpdateTransferJobRequest.fromJson(core.Map _json) {
     if (_json.containsKey("projectId")) {
       projectId = _json["projectId"];
     }
     if (_json.containsKey("transferJob")) {
       transferJob = new TransferJob.fromJson(_json["transferJob"]);
     }
     if (_json.containsKey("updateTransferJobFieldMask")) {
       updateTransferJobFieldMask = _json["updateTransferJobFieldMask"];
     }
   }
 
   core.Map<core.String, core.Object> toJson() {
-    final core.Map<core.String, core.Object> _json = new core.Map<core.String, core.Object>();
+    final core.Map<core.String, core.Object> _json =
+        new core.Map<core.String, core.Object>();
     if (projectId != null) {
       _json["projectId"] = projectId;
     }
     if (transferJob != null) {
       _json["transferJob"] = (transferJob).toJson();
     }
     if (updateTransferJobFieldMask != null) {
       _json["updateTransferJobFieldMask"] = updateTransferJobFieldMask;
     }
     return _json;
   }
 }