@googleapis/storagetransfer 8.0.1 → 10.0.0

package/build/v1.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
 import { Readable } from 'stream';
 export declare namespace storagetransfer_v1 {
@@ -182,6 +181,10 @@ export declare namespace storagetransfer_v1 {
          * Optional. The Resource name of a secret in Secret Manager. The Azure SAS token must be stored in Secret Manager in JSON format: { "sas_token" : "SAS_TOKEN" \} GoogleServiceAccount must be granted `roles/secretmanager.secretAccessor` for the resource. See [Configure access to a source: Microsoft Azure Blob Storage] (https://cloud.google.com/storage-transfer/docs/source-microsoft-azure#secret_manager) for more information. If `credentials_secret` is specified, do not specify azure_credentials. Format: `projects/{project_number\}/secrets/{secret_name\}`
          */
         credentialsSecret?: string | null;
+        /**
+         * Optional. Federated identity config of a user registered Azure application. If `federated_identity_config` is specified, do not specify azure_credentials or credentials_secret.
+         */
+        federatedIdentityConfig?: Schema$FederatedIdentityConfig;
         /**
          * Root path to transfer objects. Must be an empty string or full path name that ends with a '/'. This field is treated as an object prefix. As such, it should generally not begin with a '/'.
          */
@@ -241,11 +244,11 @@ export declare namespace storagetransfer_v1 {
      */
     export interface Schema$ErrorLogEntry {
         /**
-         * A list of messages that carry the error details.
+         * Optional. A list of messages that carry the error details.
          */
         errorDetails?: string[] | null;
         /**
-         * Required. A URL that refers to the target (a data source, a data sink, or an object) with which the error is associated.
+         * Output only. A URL that refers to the target (a data source, a data sink, or an object) with which the error is associated.
          */
         url?: string | null;
     }
@@ -283,6 +286,19 @@ export declare namespace storagetransfer_v1 {
          */
         name?: string | null;
     }
+    /**
+     * The identity of an Azure application through which Storage Transfer Service can authenticate requests using Azure workload identity federation. Storage Transfer Service can issue requests to Azure Storage through registered Azure applications, eliminating the need to pass credentials to Storage Transfer Service directly. To configure federated identity, see [Configure access to Microsoft Azure Storage](https://cloud.google.com/storage-transfer/docs/source-microsoft-azure#option_3_authenticate_using_federated_identity).
+     */
+    export interface Schema$FederatedIdentityConfig {
+        /**
+         * Required. The client (application) ID of the application with federated credentials.
+         */
+        clientId?: string | null;
+        /**
+         * Required. The tenant (directory) ID of the application with federated credentials.
+         */
+        tenantId?: string | null;
+    }
     /**
      * In a GcsData resource, an object's name is the Cloud Storage object's name and its "last modification time" refers to the object's `updated` property of Cloud Storage objects, which changes when the content or the metadata of the object is updated.
      */
@@ -780,7 +796,7 @@ export declare namespace storagetransfer_v1 {
          */
         schedule?: Schema$Schedule;
         /**
-         * Optional. The service account to be used to access resources in the consumer project in the transfer job. We accept `email` or `uniqueId` for the service account. Service account format is projects/-/serviceAccounts/{ACCOUNT_EMAIL_OR_UNIQUEID\} See https://cloud.google.com/iam/docs/reference/credentials/rest/v1/projects.serviceAccounts/generateAccessToken#path-parameters for details. Caller requires the following IAM permission on the specified service account: `iam.serviceAccounts.actAs`. project-PROJECT_NUMBER@storage-transfer-service.iam.gserviceaccount.com requires the following IAM permission on the specified service account: `iam.serviceAccounts.getAccessToken`
+         * Optional. The user-managed service account to which to delegate service agent permissions. You can grant Cloud Storage bucket permissions to this service account instead of to the Transfer Service service agent. Format is `projects/-/serviceAccounts/ACCOUNT_EMAIL_OR_UNIQUEID` Either the service account email (`SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com`) or the unique ID (`123456789012345678901`) are accepted in the string. The `-` wildcard character is required; replacing it with a project ID is invalid. See https://cloud.google.com//storage-transfer/docs/delegate-service-agent-permissions for required permissions.
          */
         serviceAccount?: string | null;
         /**
@@ -880,23 +896,23 @@ export declare namespace storagetransfer_v1 {
      */
     export interface Schema$TransferSpec {
         /**
-         * An AWS S3 compatible data source.
+         * Optional. An AWS S3 compatible data source.
          */
         awsS3CompatibleDataSource?: Schema$AwsS3CompatibleData;
         /**
-         * An AWS S3 data source.
+         * Optional. An AWS S3 data source.
          */
         awsS3DataSource?: Schema$AwsS3Data;
         /**
-         * An Azure Blob Storage data source.
+         * Optional. An Azure Blob Storage data source.
          */
         azureBlobStorageDataSource?: Schema$AzureBlobStorageData;
         /**
-         * A Cloud Storage data sink.
+         * Optional. A Cloud Storage data sink.
          */
         gcsDataSink?: Schema$GcsData;
         /**
-         * A Cloud Storage data source.
+         * Optional. A Cloud Storage data source.
          */
         gcsDataSource?: Schema$GcsData;
         /**
@@ -904,11 +920,11 @@ export declare namespace storagetransfer_v1 {
          */
         gcsIntermediateDataLocation?: Schema$GcsData;
         /**
-         * An HDFS cluster data source.
+         * Optional. An HDFS cluster data source.
          */
         hdfsDataSource?: Schema$HdfsData;
         /**
-         * An HTTP URL data source.
+         * Optional. An HTTP URL data source.
          */
         httpDataSource?: Schema$HttpData;
         /**
@@ -916,11 +932,11 @@ export declare namespace storagetransfer_v1 {
          */
         objectConditions?: Schema$ObjectConditions;
         /**
-         * A POSIX Filesystem data sink.
+         * Optional. A POSIX Filesystem data sink.
          */
         posixDataSink?: Schema$PosixFilesystem;
         /**
-         * A POSIX Filesystem data source.
+         * Optional. A POSIX Filesystem data source.
          */
         posixDataSource?: Schema$PosixFilesystem;
         /**
@@ -962,6 +978,53 @@ export declare namespace storagetransfer_v1 {
         constructor(context: APIRequestContext);
         /**
          * 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 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.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.googleServiceAccounts.get({
+         *     // Required. The ID of the Google Cloud project that the Google service account is associated with.
+         *     projectId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountEmail": "my_accountEmail",
+         *   //   "subjectId": "my_subjectId"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -991,6 +1054,68 @@ export declare namespace storagetransfer_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates an agent pool resource.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.projects.agentPools.create({
+         *     // Required. The ID of the agent pool to create. The `agent_pool_id` must meet the following requirements: * Length of 128 characters or less. * Not start with the string `goog`. * Start with a lowercase ASCII character, followed by: * Zero or more: lowercase Latin alphabet characters, numerals, hyphens (`-`), periods (`.`), underscores (`_`), or tildes (`~`). * One or more numerals or lowercase ASCII characters. As expressed by the regular expression: `^(?!goog)[a-z]([a-z0-9-._~]*[a-z0-9])?$`.
+         *     agentPoolId: 'placeholder-value',
+         *     // Required. The ID of the Google Cloud project that owns the agent pool.
+         *     projectId: '[^/]+',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "bandwidthLimit": {},
+         *       //   "displayName": "my_displayName",
+         *       //   "name": "my_name",
+         *       //   "state": "my_state"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "bandwidthLimit": {},
+         *   //   "displayName": "my_displayName",
+         *   //   "name": "my_name",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1005,6 +1130,50 @@ export declare namespace storagetransfer_v1 {
         create(callback: BodyResponseCallback<Schema$AgentPool>): void;
         /**
          * Deletes an agent pool.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.projects.agentPools.delete({
+         *     // Required. The name of the agent pool to delete.
+         *     name: 'projects/my-project/agentPools/my-agentPool',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1019,6 +1188,55 @@ export declare namespace storagetransfer_v1 {
         delete(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Gets an agent pool.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.projects.agentPools.get({
+         *     // Required. The name of the agent pool to get.
+         *     name: 'projects/my-project/agentPools/my-agentPool',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "bandwidthLimit": {},
+         *   //   "displayName": "my_displayName",
+         *   //   "name": "my_name",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1033,6 +1251,59 @@ export declare namespace storagetransfer_v1 {
         get(callback: BodyResponseCallback<Schema$AgentPool>): void;
         /**
          * Lists agent pools.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.projects.agentPools.list({
+         *     // An optional list of query parameters specified as JSON text in the form of: `{"agentPoolNames":["agentpool1","agentpool2",...]\}` Since `agentPoolNames` support multiple values, its values must be specified with array notation. When the filter is either empty or not provided, the list returns all agent pools for the project.
+         *     filter: 'placeholder-value',
+         *     // The list page size. The max allowed value is `256`.
+         *     pageSize: 'placeholder-value',
+         *     // The list page token.
+         *     pageToken: 'placeholder-value',
+         *     // Required. The ID of the Google Cloud project that owns the job.
+         *     projectId: '[^/]+',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "agentPools": [],
+         *   //   "nextPageToken": "my_nextPageToken"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1047,6 +1318,68 @@ export declare namespace storagetransfer_v1 {
         list(callback: BodyResponseCallback<Schema$ListAgentPoolsResponse>): void;
         /**
          * Updates an existing agent pool resource.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.projects.agentPools.patch({
+         *     // Required. Specifies a unique string that identifies the agent pool. Format: `projects/{project_id\}/agentPools/{agent_pool_id\}`
+         *     name: 'projects/my-project/agentPools/my-agentPool',
+         *     // The [field mask] (https://developers.google.com/protocol-buffers/docs/reference/google.protobuf) of the fields in `agentPool` to update in this request. The following `agentPool` fields can be updated: * display_name * bandwidth_limit
+         *     updateMask: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "bandwidthLimit": {},
+         *       //   "displayName": "my_displayName",
+         *       //   "name": "my_name",
+         *       //   "state": "my_state"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "bandwidthLimit": {},
+         *   //   "displayName": "my_displayName",
+         *   //   "name": "my_name",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1123,6 +1456,85 @@ export declare namespace storagetransfer_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a transfer job that runs periodically.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferJobs.create({
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "creationTime": "my_creationTime",
+         *       //   "deletionTime": "my_deletionTime",
+         *       //   "description": "my_description",
+         *       //   "eventStream": {},
+         *       //   "lastModificationTime": "my_lastModificationTime",
+         *       //   "latestOperationName": "my_latestOperationName",
+         *       //   "loggingConfig": {},
+         *       //   "name": "my_name",
+         *       //   "notificationConfig": {},
+         *       //   "projectId": "my_projectId",
+         *       //   "replicationSpec": {},
+         *       //   "schedule": {},
+         *       //   "serviceAccount": "my_serviceAccount",
+         *       //   "status": "my_status",
+         *       //   "transferSpec": {}
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "creationTime": "my_creationTime",
+         *   //   "deletionTime": "my_deletionTime",
+         *   //   "description": "my_description",
+         *   //   "eventStream": {},
+         *   //   "lastModificationTime": "my_lastModificationTime",
+         *   //   "latestOperationName": "my_latestOperationName",
+         *   //   "loggingConfig": {},
+         *   //   "name": "my_name",
+         *   //   "notificationConfig": {},
+         *   //   "projectId": "my_projectId",
+         *   //   "replicationSpec": {},
+         *   //   "schedule": {},
+         *   //   "serviceAccount": "my_serviceAccount",
+         *   //   "status": "my_status",
+         *   //   "transferSpec": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1137,6 +1549,52 @@ export declare namespace storagetransfer_v1 {
         create(callback: BodyResponseCallback<Schema$TransferJob>): void;
         /**
          * Deletes a transfer job. Deleting a transfer job sets its status to DELETED.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferJobs.delete({
+         *     // Required. The job to delete.
+         *     jobName: 'transferJobs/.*',
+         *     // Required. The ID of the Google Cloud project that owns the job.
+         *     projectId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1151,6 +1609,68 @@ export declare namespace storagetransfer_v1 {
         delete(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Gets a transfer job.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferJobs.get({
+         *     // Required. The job to get.
+         *     jobName: 'transferJobs/.*',
+         *     // Required. The ID of the Google Cloud project that owns the job.
+         *     projectId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "creationTime": "my_creationTime",
+         *   //   "deletionTime": "my_deletionTime",
+         *   //   "description": "my_description",
+         *   //   "eventStream": {},
+         *   //   "lastModificationTime": "my_lastModificationTime",
+         *   //   "latestOperationName": "my_latestOperationName",
+         *   //   "loggingConfig": {},
+         *   //   "name": "my_name",
+         *   //   "notificationConfig": {},
+         *   //   "projectId": "my_projectId",
+         *   //   "replicationSpec": {},
+         *   //   "schedule": {},
+         *   //   "serviceAccount": "my_serviceAccount",
+         *   //   "status": "my_status",
+         *   //   "transferSpec": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1165,6 +1685,57 @@ export declare namespace storagetransfer_v1 {
         get(callback: BodyResponseCallback<Schema$TransferJob>): void;
         /**
          * Lists transfer jobs.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferJobs.list({
+         *     // Required. A list of query parameters specified as JSON text in the form of: ``` { "projectId":"my_project_id", "jobNames":["jobid1","jobid2",...], "jobStatuses":["status1","status2",...], "dataBackend":"QUERY_REPLICATION_CONFIGS", "sourceBucket":"source-bucket-name", "sinkBucket":"sink-bucket-name", \} ``` The JSON formatting in the example is for display only; provide the query parameters without spaces or line breaks. * `projectId` is required. * Since `jobNames` and `jobStatuses` support multiple values, their values must be specified with array notation. `jobNames` and `jobStatuses` are optional. Valid values are case-insensitive: * ENABLED * DISABLED * DELETED * Specify `"dataBackend":"QUERY_REPLICATION_CONFIGS"` to return a list of cross-bucket replication jobs. * Limit the results to jobs from a particular bucket with `sourceBucket` and/or to a particular bucket with `sinkBucket`.
+         *     filter: 'placeholder-value',
+         *     // The list page size. The max allowed value is 256.
+         *     pageSize: 'placeholder-value',
+         *     // The list page token.
+         *     pageToken: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "transferJobs": []
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1179,6 +1750,76 @@ export declare namespace storagetransfer_v1 {
         list(callback: BodyResponseCallback<Schema$ListTransferJobsResponse>): void;
         /**
          * Updates a transfer job. Updating a job's transfer spec does not affect transfer operations that are running already. **Note:** The job's status field can be modified using this RPC (for example, to set a job's status to DELETED, DISABLED, or ENABLED).
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferJobs.patch({
+         *     // Required. The name of job to update.
+         *     jobName: 'transferJobs/.*',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "projectId": "my_projectId",
+         *       //   "transferJob": {},
+         *       //   "updateTransferJobFieldMask": "my_updateTransferJobFieldMask"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "creationTime": "my_creationTime",
+         *   //   "deletionTime": "my_deletionTime",
+         *   //   "description": "my_description",
+         *   //   "eventStream": {},
+         *   //   "lastModificationTime": "my_lastModificationTime",
+         *   //   "latestOperationName": "my_latestOperationName",
+         *   //   "loggingConfig": {},
+         *   //   "name": "my_name",
+         *   //   "notificationConfig": {},
+         *   //   "projectId": "my_projectId",
+         *   //   "replicationSpec": {},
+         *   //   "schedule": {},
+         *   //   "serviceAccount": "my_serviceAccount",
+         *   //   "status": "my_status",
+         *   //   "transferSpec": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1193,6 +1834,64 @@ export declare namespace storagetransfer_v1 {
         patch(callback: BodyResponseCallback<Schema$TransferJob>): void;
         /**
          * Starts a new operation for the specified transfer job. A `TransferJob` has a maximum of one active `TransferOperation`. If this method is called while a `TransferOperation` is active, an error is returned.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferJobs.run({
+         *     // Required. The name of the transfer job.
+         *     jobName: 'transferJobs/.*',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "projectId": "my_projectId"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1271,6 +1970,56 @@ export declare namespace storagetransfer_v1 {
         constructor(context: APIRequestContext);
         /**
          * Cancels a transfer. Use the transferOperations.get method to check if the cancellation succeeded or if the operation completed despite the `cancel` request. When you cancel an operation, the currently running transfer is interrupted. For recurring transfer jobs, the next instance of the transfer job will still run. For example, if your job is configured to run every day at 1pm and you cancel Monday's operation at 1:05pm, Monday's transfer will stop. However, a transfer job will still be attempted on Tuesday. This applies only to currently running operations. If an operation is not currently running, `cancel` does nothing. *Caution:* Canceling a transfer job can leave your data in an unknown state. We recommend that you restore the state at both the destination and the source after the `cancel` request completes so that your data is in a consistent state. When you cancel a job, the next job computes a delta of files and may repair any inconsistent state. For instance, if you run a job every day, and today's job found 10 new files and transferred five files before you canceled the job, tomorrow's transfer operation will compute a new delta with the five files that were not copied today plus any new files discovered tomorrow.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferOperations.cancel({
+         *     // The name of the operation resource to be cancelled.
+         *     name: 'transferOperations/.*',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1285,6 +2034,56 @@ export declare namespace storagetransfer_v1 {
         cancel(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * 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.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferOperations.get({
+         *     // The name of the operation resource.
+         *     name: 'transferOperations/.*',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1299,6 +2098,59 @@ export declare namespace storagetransfer_v1 {
         get(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Lists transfer operations. Operations are ordered by their creation time in reverse chronological order.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferOperations.list({
+         *     // Required. A list of query parameters specified as JSON text in the form of: `{"projectId":"my_project_id", "jobNames":["jobid1","jobid2",...], "jobNamePattern": "job_name_pattern", "operationNames":["opid1","opid2",...], "operationNamePattern": "operation_name_pattern", "minCreationTime": "min_creation_time", "maxCreationTime": "max_creation_time", "transferStatuses":["status1","status2",...]\}` Since `jobNames`, `operationNames`, and `transferStatuses` support multiple values, they must be specified with array notation. `projectId` is the only argument that is required. If specified, `jobNamePattern` and `operationNamePattern` must match the full job or operation name respectively. '*' is a wildcard matching 0 or more characters. `minCreationTime` and `maxCreationTime` should be timestamps encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. The valid values for `transferStatuses` are case-insensitive: IN_PROGRESS, PAUSED, SUCCESS, FAILED, and ABORTED.
+         *     filter: 'placeholder-value',
+         *     // Required. The name of the type being listed; must be `transferOperations`.
+         *     name: 'transferOperations',
+         *     // The list page size. The max allowed value is 256.
+         *     pageSize: 'placeholder-value',
+         *     // The list page token.
+         *     pageToken: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "operations": []
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1313,6 +2165,56 @@ export declare namespace storagetransfer_v1 {
         list(callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
         /**
          * Pauses a transfer operation.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferOperations.pause({
+         *     // Required. The name of the transfer operation.
+         *     name: 'transferOperations/.*',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1327,6 +2229,56 @@ export declare namespace storagetransfer_v1 {
         pause(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Resumes a transfer operation that is paused.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/storagetransfer.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const storagetransfer = google.storagetransfer('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: ['https://www.googleapis.com/auth/cloud-platform'],
+         *   });
+         *
+         *   // Acquire an auth client, and bind it to all future calls
+         *   const authClient = await auth.getClient();
+         *   google.options({auth: authClient});
+         *
+         *   // Do the magic
+         *   const res = await storagetransfer.transferOperations.resume({
+         *     // Required. The name of the transfer operation.
+         *     name: 'transferOperations/.*',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.