Api-roll 48: 2017-04-18

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;
@@ skipping 10 matching lines @@
 class StoragetransferApi {
   /** 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);
-  V1ResourceApi get v1 => new V1ResourceApi(_requester);
 
   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;
 
   /**
-   * 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 Developers
-   * 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
+   * 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 Developers Console project that the
-   * Google service account is associated with. Required.
+   * [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) {
@@ skipping 66 matching lines @@
                                        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/.*$".
+   * [jobName] - The job to get.
+   * Required.
+   * Value must have pattern "^transferJobs/.+$".
    *
-   * [projectId] - The ID of the Google Developers Console project that owns the
-   * job. Required.
+   * [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}) {
@@ skipping 21 matching lines @@
                                        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.
    *
-   * [pageToken] - The list page token.
+   * [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`.
    *
    * 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.int pageSize, core.String pageToken}) {
+  async.Future<ListTransferJobsResponse> list({core.String pageToken, core.int pageSize, core.String filter}) {
     var _url = null;
     var _queryParams = new core.Map();
     var _uploadMedia = null;
     var _uploadOptions = null;
     var _downloadOptions = commons.DownloadOptions.Metadata;
     var _body = null;
 
-    if (filter != null) {
-      _queryParams["filter"] = [filter];
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
     }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
-    if (pageToken != null) {
-      _queryParams["pageToken"] = [pageToken];
+    if (filter != null) {
+      _queryParams["filter"] = [filter];
     }
 
     _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));
   }
 
   /**
    * 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.
+   * 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/.*$".
+   * [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) {
@@ skipping 32 matching lines @@
   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/.*$".
+   * 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) {
@@ skipping 19 matching lines @@
                                        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/.*$".
+   * 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) {
@@ skipping 14 matching lines @@
                                        "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
+   * 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/.*$".
+   * 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) {
@@ skipping 15 matching lines @@
                                        body: _body,
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Operation.fromJson(data));
   }
 
   /**
    * Lists operations that match the specified filter in the request. If the
-   * server doesn't support this method, it returns `UNIMPLEMENTED`. NOTE: the
-   * `name` binding below allows API services to override the binding to use
-   * different resource name schemes, such as `users / * /operations`.
+   * server doesn't support this method, it returns `UNIMPLEMENTED`.
+   *
+   * NOTE: the `name` binding below allows API services to override the binding
+   * to use different resource name schemes, such as `users / * /operations`.
    *
    * Request parameters:
    *
    * [name] - The value `transferOperations`.
    * Value must have pattern "^transferOperations$".
    *
-   * [filter] - The standard list filter.
+   * [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.
    *
-   * [pageSize] - The standard list page size.
+   * [pageToken] - The list page token.
    *
-   * [pageToken] - The standard list page token.
+   * [pageSize] - The list page size. The max allowed value is 256.
    *
    * 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 filter, core.int pageSize, core.String pageToken}) {
+  async.Future<ListOperationsResponse> list(core.String name, {core.String filter, core.String pageToken, core.int pageSize}) {
     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 (filter != null) {
       _queryParams["filter"] = [filter];
     }
+    if (pageToken != null) {
+      _queryParams["pageToken"] = [pageToken];
+    }
     if (pageSize != null) {
       _queryParams["pageSize"] = ["${pageSize}"];
     }
-    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);
     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/.*$".
+   * [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) {
@@ skipping 23 matching lines @@
     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/.*$".
+   * [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) {
@@ skipping 19 matching lines @@
                                        queryParams: _queryParams,
                                        uploadOptions: _uploadOptions,
                                        uploadMedia: _uploadMedia,
                                        downloadOptions: _downloadOptions);
     return _response.then((data) => new Empty.fromJson(data));
   }
 
 }
 
 
-class V1ResourceApi {
-  final commons.ApiRequester _requester;
-
-  V1ResourceApi(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 Developers
-   * 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 Developers 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> getGoogleServiceAccount({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) {
-      _queryParams["projectId"] = [projectId];
-    }
-
-    _url = 'v1:getGoogleServiceAccount';
-
-    var _response = _requester.request(_url,
-                                       "GET",
-                                       body: _body,
-                                       queryParams: _queryParams,
-                                       uploadOptions: _uploadOptions,
-                                       uploadMedia: _uploadMedia,
-                                       downloadOptions: _downloadOptions);
-    return _response.then((data) => new GoogleServiceAccount.fromJson(data));
-  }
-
-}
-
-
 
 /**
- * AWS access key (see [AWS Security
+ * 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. */
+  /**
+   * AWS access key ID.
+   * Required.
+   */
   core.String accessKeyId;
   /**
    * AWS secret access key. This field is not returned in RPC responses.
    * Required.
    */
   core.String secretAccessKey;
 
   AwsAccessKey();
 
   AwsAccessKey.fromJson(core.Map _json) {
@@ skipping 11 matching lines @@
       _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.
+   * 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
+   * 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"]);
@@ skipping 10 matching lines @@
     }
     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][google.type.TimeOfDay] and
- * `google.protobuf.Timestamp`.
+ * 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 sigificant.
+   * if specifying a year/month where the day is not significant.
    */
   core.int day;
-  /** Month of year of date. 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 9,999, 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")) {
@@ skipping 14 matching lines @@
     }
     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 `{}`.
+ * 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) {
   }
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
   }
 }
 
 /** An entry describing an error that has occurred. */
 class ErrorLogEntry {
   /** 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 toJson() {
     var _json = new core.Map();
     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" : A OK.
-   * - "CANCELLED" : A CANCELLED.
-   * - "UNKNOWN" : A UNKNOWN.
-   * - "INVALID_ARGUMENT" : A INVALID_ARGUMENT.
-   * - "DEADLINE_EXCEEDED" : A DEADLINE_EXCEEDED.
-   * - "NOT_FOUND" : A NOT_FOUND.
-   * - "ALREADY_EXISTS" : A ALREADY_EXISTS.
-   * - "PERMISSION_DENIED" : A PERMISSION_DENIED.
-   * - "UNAUTHENTICATED" : A UNAUTHENTICATED.
-   * - "RESOURCE_EXHAUSTED" : A RESOURCE_EXHAUSTED.
-   * - "FAILED_PRECONDITION" : A FAILED_PRECONDITION.
-   * - "ABORTED" : A ABORTED.
-   * - "OUT_OF_RANGE" : A OUT_OF_RANGE.
-   * - "UNIMPLEMENTED" : A UNIMPLEMENTED.
-   * - "INTERNAL" : A INTERNAL.
-   * - "UNAVAILABLE" : A UNAVAILABLE.
-   * - "DATA_LOSS" : A DATA_LOSS.
+   * - "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. */
   core.List<ErrorLogEntry> errorLogEntries;
 
   ErrorSummary();
 
   ErrorSummary.fromJson(core.Map _json) {
     if (_json.containsKey("errorCode")) {
       errorCode = _json["errorCode"];
     }
@@ skipping 20 matching lines @@
   }
 }
 
 /**
  * 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
+   * 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"];
@@ skipping 26 matching lines @@
     var _json = new core.Map();
     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 * Length * MD5 - This field is
- * a base64-encoded MD5 hash of the object An HTTP URL that points to the object
- * to be transferred. It must be a valid URL with URL scheme HTTP or HTTPS. When
- * an object with URL `http(s)://hostname:port/` is transferred to the data
- * sink, the name of the object at the data sink is `/`. Length and MD5 provide
- * the size and the base64-encoded MD5 hash of the object. If Length does not
- * match the actual length of the object fetched, the object will not be
- * transferred. If MD5 does not match the MD5 computed from the transferred
- * bytes, the object transfer will fail. `lastModificationTime` is not available
- * in HttpData objects. The objects that the URL list points to must allow
- * public access. Storage Transfer Service obeys `robots.txt` rules and requires
- * the HTTP server to support Range requests and to return a Content-Length
+ * 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.
  */
 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 toJson() {
     var _json = new core.Map();
     if (listUrl != null) {
       _json["listUrl"] = listUrl;
     }
     return _json;
   }
 }
 
-/**
- * The response message for
- * [Operations.ListOperations][google.longrunning.Operations.ListOperations].
- */
+/** The response message for Operations.ListOperations. */
 class ListOperationsResponse {
   /** The standard List next-page token. */
   core.String nextPageToken;
   /** A list of operations that matches the specified filter in the request. */
   core.List<Operation> operations;
 
   ListOperationsResponse();
 
   ListOperationsResponse.fromJson(core.Map _json) {
     if (_json.containsKey("nextPageToken")) {
@@ skipping 43 matching lines @@
       _json["transferJobs"] = transferJobs.map((value) => (value).toJson()).toList();
     }
     return _json;
   }
 }
 
 /** Conditions that determine which objects will be transferred. */
 class ObjectConditions {
   /**
    * `excludePrefixes` must follow the requirements described for
-   * `includePrefixes`. The max size of `excludePrefixes` is 20.
+   * `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`
+   * 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. * 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 20.
+   *
+   * 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`.
    */
   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
+   * 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"];
     }
@@ skipping 25 matching lines @@
     return _json;
   }
 }
 
 /**
  * This resource represents a long-running operation that is the result of a
  * network API call.
  */
 class Operation {
   /**
-   * If the value is `false`, it means the operation is still in progress. If
-   * true, the operation is completed and the `result` 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. */
+  /** 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.
    */
   core.Map<core.String, core.Object> metadata;
   /**
    * The server-assigned name, which is only unique within the same service that
-   * originally returns it. If you use the default HTTP mapping above, the
-   * `name` should have the format of `operations/some/unique/name`.
+   * 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
+   * 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`.
+   * `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")) {
@@ skipping 58 matching lines @@
 
   core.Map toJson() {
     var _json = new core.Map();
     return _json;
   }
 }
 
 /** 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. 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, transfers are
-   * scheduled to start at midnight UTC.
+   * 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")) {
@@ skipping 14 matching lines @@
     }
     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][google.rpc.Code], but it may accept
- * additional error codes if needed. The error message should be a
- * developer-facing English message that helps developers *understand* and
- * *resolve* the error. If a localized user-facing error message is needed, put
- * the localized message in the error details or localize it in the client. The
- * optional error details may contain arbitrary information about the error.
- * There is a predefined set of error detail types in the package `google.rpc`
- * which can be used for common error conditions. # Language mapping The
- * `Status` message is the logical representation of the error model, but it is
- * not necessarily the actual wire format. When the `Status` message is exposed
- * in different client libraries and different wire protocols, it can be mapped
- * differently. For example, it will likely be mapped to some exceptions in
- * Java, but more likely mapped to some error codes in C. # Other uses The error
- * model and the `Status` message can be used in a variety of environments,
- * either with or without APIs, to provide a consistent developer experience
- * across different environments. Example uses of this error model include: -
- * Partial errors. If a service needs to return partial errors to the client, it
- * may embed the `Status` in the normal response to indicate the partial errors.
- * - Workflow errors. A typical workflow has multiple steps. Each step may have
- * a `Status` message for error reporting purpose. - Batch operations. If a
- * client uses batch request and batch response, the `Status` message should be
- * used directly inside batch response, one for each error sub-response. -
- * Asynchronous operations. If an API call embeds asynchronous operation results
- * in its response, the status of those operations should be represented
- * directly using the `Status` message. - Logging. If some API errors are stored
- * in logs, the message `Status` could be used directly after any stripping
- * needed for security/privacy reasons.
+ * different
+ * programming environments, including REST APIs and RPC APIs. It is used by
+ * [gRPC](https://github.com/grpc). The error model is designed to be:
+ *
+ * - Simple to use and understand for most users
+ * - Flexible enough to meet unexpected needs
+ *
+ * # Overview
+ *
+ * The `Status` message contains three pieces of data: error code, error
+ * message,
+ * and error details. The error code should be an enum value of
+ * google.rpc.Code, but it may accept additional error codes if needed.  The
+ * error message should be a developer-facing English message that helps
+ * developers *understand* and *resolve* the error. If a localized user-facing
+ * error message is needed, put the localized message in the error details or
+ * localize it in the client. The optional error details may contain arbitrary
+ * information about the error. There is a predefined set of error detail types
+ * in the package `google.rpc` which can be used for common error conditions.
+ *
+ * # Language mapping
+ *
+ * The `Status` message is the logical representation of the error model, but it
+ * is not necessarily the actual wire format. When the `Status` message is
+ * exposed in different client libraries and different wire protocols, it can be
+ * mapped differently. For example, it will likely be mapped to some exceptions
+ * in Java, but more likely mapped to some error codes in C.
+ *
+ * # Other uses
+ *
+ * The error model and the `Status` message can be used in a variety of
+ * environments, either with or without APIs, to provide a
+ * consistent developer experience across different environments.
+ *
+ * Example uses of this error model include:
+ *
+ * - Partial errors. If a service needs to return partial errors to the client,
+ *     it may embed the `Status` in the normal response to indicate the partial
+ *     errors.
+ *
+ * - Workflow errors. A typical workflow has multiple steps. Each step may
+ *     have a `Status` message for error reporting purpose.
+ *
+ * - Batch operations. If a client uses batch request and batch response, the
+ *     `Status` message should be used directly inside batch response, one for
+ *     each error sub-response.
+ *
+ * - Asynchronous operations. If an API call embeds asynchronous operation
+ *     results in its response, the status of those operations should be
+ *     represented directly using the `Status` message.
+ *
+ * - Logging. If some API errors are stored in logs, the message `Status` could
+ * be used directly after any stripping needed for security/privacy reasons.
  */
 class Status {
-  /**
-   * The status code, which should be an enum value of
-   * [google.rpc.Code][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 will be a common set
-   * of message types for APIs to use.
+   * A list of messages that carry the error details.  There will be a
+   * common set of message types for APIs to use.
    *
    * The values for Object must be JSON objects. It can consist of `num`,
    * `String`, `bool` and `null` as well as `Map` and `List` values.
    */
   core.List<core.Map<core.String, core.Object>> details;
   /**
    * A developer-facing error message, which should be in English. Any
    * user-facing error message should be localized and sent in the
-   * [google.rpc.Status.details][google.rpc.Status.details] field, or localized
-   * by the client.
+   * 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")) {
@@ skipping 14 matching lines @@
     }
     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 chose to allow leap seconds. Related
- * types are [google.type.Date][google.type.Date] and
- * `google.protobuf.Timestamp`.
+ * 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.
    */
   core.int hours;
   /** 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. */
@@ skipping 45 matching lines @@
 class TransferCounters {
   /** Bytes that are copied to the data sink. */
   core.String bytesCopiedToSink;
   /** Bytes that are deleted from the data sink. */
   core.String bytesDeletedFromSink;
   /** Bytes that are deleted from the data source. */
   core.String bytesDeletedFromSource;
   /** 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. */
   core.String bytesFoundOnlyFromSink;
   /** 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.
    */
@@ skipping 139 matching lines @@
   /** 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.
    */
   core.String description;
   /** 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
+   * 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 Developers Console project that owns the job.
+   * 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.
+   * `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" : A STATUS_UNSPECIFIED.
-   * - "ENABLED" : A ENABLED.
-   * - "DISABLED" : A DISABLED.
-   * - "DELETED" : A DELETED.
+   * - "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 58 matching lines @@
 class TransferOperation {
   /** Information about the progress of the transfer operation. */
   TransferCounters counters;
   /** End time of this transfer execution. */
   core.String endTime;
   /** Summarizes errors encountered with sample error log entries. */
   core.List<ErrorSummary> errorBreakdowns;
   /** A globally unique ID assigned by the system. */
   core.String name;
   /**
-   * The ID of the Google Developers Console project that owns the operation.
+   * The ID of the Google Cloud Platform Console project that owns the
+   * operation.
    * Required.
    */
   core.String projectId;
   /** Start time of this transfer execution. */
   core.String startTime;
   /**
    * Status of the transfer operation.
    * Possible string values are:
-   * - "STATUS_UNSPECIFIED" : A STATUS_UNSPECIFIED.
-   * - "IN_PROGRESS" : A IN_PROGRESS.
-   * - "PAUSED" : A PAUSED.
-   * - "SUCCESS" : A SUCCESS.
-   * - "FAILED" : A FAILED.
-   * - "ABORTED" : A ABORTED.
+   * - "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. */
   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"];
@@ skipping 48 matching lines @@
       _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.
    */
   core.bool deleteObjectsFromSourceAfterTransfer;
   /** Whether objects that exist only in the sink should be deleted. */
   core.bool deleteObjectsUniqueInSink;
   /** Whether overwriting objects that already exist in the sink is allowed. */
@@ skipping 33 matching lines @@
   /** An AWS S3 data source. */
   AwsS3Data awsS3DataSource;
   /** A Google Cloud Storage data sink. */
   GcsData gcsDataSink;
   /** A Google Cloud Storage data source. */
   GcsData gcsDataSource;
   /** 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.
+   * 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.
    */
   TransferOptions transferOptions;
 
   TransferSpec();
@@ skipping 39 matching lines @@
     if (transferOptions != null) {
       _json["transferOptions"] = (transferOptions).toJson();
     }
     return _json;
   }
 }
 
 /** Request passed to UpdateTransferJob. */
 class UpdateTransferJobRequest {
   /**
-   * The ID of the Google Developers Console project that owns the job.
+   * The ID of the Google Cloud Platform Console project that owns the job.
    * Required.
    */
   core.String projectId;
-  /** The job to update. Required. */
+  /**
+   * The job to update.
+   * 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`
+   * 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")) {
@@ skipping 14 matching lines @@
     }
     if (transferJob != null) {
       _json["transferJob"] = (transferJob).toJson();
     }
     if (updateTransferJobFieldMask != null) {
       _json["updateTransferJobFieldMask"] = updateTransferJobFieldMask;
     }
     return _json;
   }
 }