@googleapis/tagmanager 10.0.0 → 12.0.1

package/build/v1.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
 import { Readable } from 'stream';
 export declare namespace tagmanager_v1 {
     export interface Options extends GlobalOptions {
@@ -818,42 +818,204 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Gets a GTM Account.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.manage.accounts',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "shareData": false
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Get, options?: MethodOptions): GaxiosPromise<Schema$Account>;
+        get(params: Params$Resource$Accounts$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Account>>;
         get(params: Params$Resource$Accounts$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Get, options: MethodOptions | BodyResponseCallback<Schema$Account>, callback: BodyResponseCallback<Schema$Account>): void;
         get(params: Params$Resource$Accounts$Get, callback: BodyResponseCallback<Schema$Account>): void;
         get(callback: BodyResponseCallback<Schema$Account>): void;
         /**
          * Lists all GTM Accounts that a user has access to.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.manage.accounts',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.list({});
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accounts": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$List, options?: MethodOptions): GaxiosPromise<Schema$ListAccountsResponse>;
+        list(params: Params$Resource$Accounts$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListAccountsResponse>>;
         list(params: Params$Resource$Accounts$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$List, options: MethodOptions | BodyResponseCallback<Schema$ListAccountsResponse>, callback: BodyResponseCallback<Schema$ListAccountsResponse>): void;
         list(params: Params$Resource$Accounts$List, callback: BodyResponseCallback<Schema$ListAccountsResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListAccountsResponse>): void;
         /**
          * Updates a GTM Account.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.manage.accounts'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the account in storage.
+         *     fingerprint: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "name": "my_name",
+         *       //   "shareData": false
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "shareData": false
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Update, options?: MethodOptions): GaxiosPromise<Schema$Account>;
+        update(params: Params$Resource$Accounts$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Account>>;
         update(params: Params$Resource$Accounts$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Update, options: MethodOptions | BodyResponseCallback<Schema$Account>, callback: BodyResponseCallback<Schema$Account>): void;
         update(params: Params$Resource$Accounts$Update, callback: BodyResponseCallback<Schema$Account>): void;
@@ -894,70 +1056,375 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.create({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "containerId": "my_containerId",
+         *       //   "domainName": [],
+         *       //   "enabledBuiltInVariable": [],
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "name": "my_name",
+         *       //   "notes": "my_notes",
+         *       //   "publicId": "my_publicId",
+         *       //   "timeZoneCountryId": "my_timeZoneCountryId",
+         *       //   "timeZoneId": "my_timeZoneId",
+         *       //   "usageContext": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "domainName": [],
+         *   //   "enabledBuiltInVariable": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "publicId": "my_publicId",
+         *   //   "timeZoneCountryId": "my_timeZoneCountryId",
+         *   //   "timeZoneId": "my_timeZoneId",
+         *   //   "usageContext": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Accounts$Containers$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Accounts$Containers$Create, options?: MethodOptions): GaxiosPromise<Schema$Container>;
+        create(params: Params$Resource$Accounts$Containers$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Accounts$Containers$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Container>>;
         create(params: Params$Resource$Accounts$Containers$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Accounts$Containers$Create, options: MethodOptions | BodyResponseCallback<Schema$Container>, callback: BodyResponseCallback<Schema$Container>): void;
         create(params: Params$Resource$Accounts$Containers$Create, callback: BodyResponseCallback<Schema$Container>): void;
         create(callback: BodyResponseCallback<Schema$Container>): void;
         /**
          * Deletes a Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.delete.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.delete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Accounts$Containers$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Accounts$Containers$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Accounts$Containers$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Accounts$Containers$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Accounts$Containers$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Accounts$Containers$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Accounts$Containers$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Gets a Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "domainName": [],
+         *   //   "enabledBuiltInVariable": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "publicId": "my_publicId",
+         *   //   "timeZoneCountryId": "my_timeZoneCountryId",
+         *   //   "timeZoneId": "my_timeZoneId",
+         *   //   "usageContext": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Containers$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Containers$Get, options?: MethodOptions): GaxiosPromise<Schema$Container>;
+        get(params: Params$Resource$Accounts$Containers$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Containers$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Container>>;
         get(params: Params$Resource$Accounts$Containers$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Containers$Get, options: MethodOptions | BodyResponseCallback<Schema$Container>, callback: BodyResponseCallback<Schema$Container>): void;
         get(params: Params$Resource$Accounts$Containers$Get, callback: BodyResponseCallback<Schema$Container>): void;
         get(callback: BodyResponseCallback<Schema$Container>): void;
         /**
          * Lists all Containers that belongs to a GTM Account.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "containers": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Containers$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Containers$List, options?: MethodOptions): GaxiosPromise<Schema$ListContainersResponse>;
+        list(params: Params$Resource$Accounts$Containers$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Containers$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListContainersResponse>>;
         list(params: Params$Resource$Accounts$Containers$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Containers$List, options: MethodOptions | BodyResponseCallback<Schema$ListContainersResponse>, callback: BodyResponseCallback<Schema$ListContainersResponse>): void;
         list(params: Params$Resource$Accounts$Containers$List, callback: BodyResponseCallback<Schema$ListContainersResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListContainersResponse>): void;
         /**
          * Updates a Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the container in storage.
+         *     fingerprint: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "containerId": "my_containerId",
+         *       //   "domainName": [],
+         *       //   "enabledBuiltInVariable": [],
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "name": "my_name",
+         *       //   "notes": "my_notes",
+         *       //   "publicId": "my_publicId",
+         *       //   "timeZoneCountryId": "my_timeZoneCountryId",
+         *       //   "timeZoneId": "my_timeZoneId",
+         *       //   "usageContext": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "domainName": [],
+         *   //   "enabledBuiltInVariable": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "publicId": "my_publicId",
+         *   //   "timeZoneCountryId": "my_timeZoneCountryId",
+         *   //   "timeZoneId": "my_timeZoneId",
+         *   //   "usageContext": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Update, options?: MethodOptions): GaxiosPromise<Schema$Container>;
+        update(params: Params$Resource$Accounts$Containers$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Container>>;
         update(params: Params$Resource$Accounts$Containers$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Update, options: MethodOptions | BodyResponseCallback<Schema$Container>, callback: BodyResponseCallback<Schema$Container>): void;
         update(params: Params$Resource$Accounts$Containers$Update, callback: BodyResponseCallback<Schema$Container>): void;
@@ -1022,70 +1489,390 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a GTM Environment.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.environments.create({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "authorizationCode": "my_authorizationCode",
+         *       //   "authorizationTimestampMs": "my_authorizationTimestampMs",
+         *       //   "containerId": "my_containerId",
+         *       //   "containerVersionId": "my_containerVersionId",
+         *       //   "description": "my_description",
+         *       //   "enableDebug": false,
+         *       //   "environmentId": "my_environmentId",
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "name": "my_name",
+         *       //   "type": "my_type",
+         *       //   "url": "my_url"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "authorizationCode": "my_authorizationCode",
+         *   //   "authorizationTimestampMs": "my_authorizationTimestampMs",
+         *   //   "containerId": "my_containerId",
+         *   //   "containerVersionId": "my_containerVersionId",
+         *   //   "description": "my_description",
+         *   //   "enableDebug": false,
+         *   //   "environmentId": "my_environmentId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "type": "my_type",
+         *   //   "url": "my_url"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Accounts$Containers$Environments$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Accounts$Containers$Environments$Create, options?: MethodOptions): GaxiosPromise<Schema$Environment>;
+        create(params: Params$Resource$Accounts$Containers$Environments$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Accounts$Containers$Environments$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Environment>>;
         create(params: Params$Resource$Accounts$Containers$Environments$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Accounts$Containers$Environments$Create, options: MethodOptions | BodyResponseCallback<Schema$Environment>, callback: BodyResponseCallback<Schema$Environment>): void;
         create(params: Params$Resource$Accounts$Containers$Environments$Create, callback: BodyResponseCallback<Schema$Environment>): void;
         create(callback: BodyResponseCallback<Schema$Environment>): void;
         /**
          * Deletes a GTM Environment.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.environments.delete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Environment ID.
+         *     environmentId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Accounts$Containers$Environments$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Accounts$Containers$Environments$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Accounts$Containers$Environments$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Accounts$Containers$Environments$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Accounts$Containers$Environments$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Accounts$Containers$Environments$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Accounts$Containers$Environments$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Gets a GTM Environment.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.environments.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Environment ID.
+         *     environmentId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "authorizationCode": "my_authorizationCode",
+         *   //   "authorizationTimestampMs": "my_authorizationTimestampMs",
+         *   //   "containerId": "my_containerId",
+         *   //   "containerVersionId": "my_containerVersionId",
+         *   //   "description": "my_description",
+         *   //   "enableDebug": false,
+         *   //   "environmentId": "my_environmentId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "type": "my_type",
+         *   //   "url": "my_url"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Containers$Environments$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Containers$Environments$Get, options?: MethodOptions): GaxiosPromise<Schema$Environment>;
+        get(params: Params$Resource$Accounts$Containers$Environments$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Containers$Environments$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Environment>>;
         get(params: Params$Resource$Accounts$Containers$Environments$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Containers$Environments$Get, options: MethodOptions | BodyResponseCallback<Schema$Environment>, callback: BodyResponseCallback<Schema$Environment>): void;
         get(params: Params$Resource$Accounts$Containers$Environments$Get, callback: BodyResponseCallback<Schema$Environment>): void;
         get(callback: BodyResponseCallback<Schema$Environment>): void;
         /**
          * Lists all GTM Environments of a GTM Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.environments.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "environments": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Containers$Environments$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Containers$Environments$List, options?: MethodOptions): GaxiosPromise<Schema$ListEnvironmentsResponse>;
+        list(params: Params$Resource$Accounts$Containers$Environments$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Containers$Environments$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListEnvironmentsResponse>>;
         list(params: Params$Resource$Accounts$Containers$Environments$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Containers$Environments$List, options: MethodOptions | BodyResponseCallback<Schema$ListEnvironmentsResponse>, callback: BodyResponseCallback<Schema$ListEnvironmentsResponse>): void;
         list(params: Params$Resource$Accounts$Containers$Environments$List, callback: BodyResponseCallback<Schema$ListEnvironmentsResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListEnvironmentsResponse>): void;
         /**
          * Updates a GTM Environment.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.environments.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Environment ID.
+         *     environmentId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the environment in storage.
+         *     fingerprint: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "authorizationCode": "my_authorizationCode",
+         *       //   "authorizationTimestampMs": "my_authorizationTimestampMs",
+         *       //   "containerId": "my_containerId",
+         *       //   "containerVersionId": "my_containerVersionId",
+         *       //   "description": "my_description",
+         *       //   "enableDebug": false,
+         *       //   "environmentId": "my_environmentId",
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "name": "my_name",
+         *       //   "type": "my_type",
+         *       //   "url": "my_url"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "authorizationCode": "my_authorizationCode",
+         *   //   "authorizationTimestampMs": "my_authorizationTimestampMs",
+         *   //   "containerId": "my_containerId",
+         *   //   "containerVersionId": "my_containerVersionId",
+         *   //   "description": "my_description",
+         *   //   "enableDebug": false,
+         *   //   "environmentId": "my_environmentId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "type": "my_type",
+         *   //   "url": "my_url"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Environments$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Environments$Update, options?: MethodOptions): GaxiosPromise<Schema$Environment>;
+        update(params: Params$Resource$Accounts$Containers$Environments$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Environments$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Environment>>;
         update(params: Params$Resource$Accounts$Containers$Environments$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Environments$Update, options: MethodOptions | BodyResponseCallback<Schema$Environment>, callback: BodyResponseCallback<Schema$Environment>): void;
         update(params: Params$Resource$Accounts$Containers$Environments$Update, callback: BodyResponseCallback<Schema$Environment>): void;
@@ -1171,70 +1958,355 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a GTM Folder.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.folders.create({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "containerId": "my_containerId",
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "folderId": "my_folderId",
+         *       //   "name": "my_name"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "folderId": "my_folderId",
+         *   //   "name": "my_name"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Accounts$Containers$Folders$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Accounts$Containers$Folders$Create, options?: MethodOptions): GaxiosPromise<Schema$Folder>;
+        create(params: Params$Resource$Accounts$Containers$Folders$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Accounts$Containers$Folders$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Folder>>;
         create(params: Params$Resource$Accounts$Containers$Folders$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Accounts$Containers$Folders$Create, options: MethodOptions | BodyResponseCallback<Schema$Folder>, callback: BodyResponseCallback<Schema$Folder>): void;
         create(params: Params$Resource$Accounts$Containers$Folders$Create, callback: BodyResponseCallback<Schema$Folder>): void;
         create(callback: BodyResponseCallback<Schema$Folder>): void;
         /**
          * Deletes a GTM Folder.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.folders.delete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Folder ID.
+         *     folderId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Accounts$Containers$Folders$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Accounts$Containers$Folders$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Accounts$Containers$Folders$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Accounts$Containers$Folders$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Accounts$Containers$Folders$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Accounts$Containers$Folders$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Accounts$Containers$Folders$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Gets a GTM Folder.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.folders.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Folder ID.
+         *     folderId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "folderId": "my_folderId",
+         *   //   "name": "my_name"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Containers$Folders$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Containers$Folders$Get, options?: MethodOptions): GaxiosPromise<Schema$Folder>;
+        get(params: Params$Resource$Accounts$Containers$Folders$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Containers$Folders$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Folder>>;
         get(params: Params$Resource$Accounts$Containers$Folders$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Containers$Folders$Get, options: MethodOptions | BodyResponseCallback<Schema$Folder>, callback: BodyResponseCallback<Schema$Folder>): void;
         get(params: Params$Resource$Accounts$Containers$Folders$Get, callback: BodyResponseCallback<Schema$Folder>): void;
         get(callback: BodyResponseCallback<Schema$Folder>): void;
         /**
          * Lists all GTM Folders of a Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.folders.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "folders": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Containers$Folders$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Containers$Folders$List, options?: MethodOptions): GaxiosPromise<Schema$ListFoldersResponse>;
+        list(params: Params$Resource$Accounts$Containers$Folders$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Containers$Folders$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListFoldersResponse>>;
         list(params: Params$Resource$Accounts$Containers$Folders$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Containers$Folders$List, options: MethodOptions | BodyResponseCallback<Schema$ListFoldersResponse>, callback: BodyResponseCallback<Schema$ListFoldersResponse>): void;
         list(params: Params$Resource$Accounts$Containers$Folders$List, callback: BodyResponseCallback<Schema$ListFoldersResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListFoldersResponse>): void;
         /**
          * Updates a GTM Folder.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.folders.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the folder in storage.
+         *     fingerprint: 'placeholder-value',
+         *     // The GTM Folder ID.
+         *     folderId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "containerId": "my_containerId",
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "folderId": "my_folderId",
+         *       //   "name": "my_name"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "folderId": "my_folderId",
+         *   //   "name": "my_name"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Folders$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Folders$Update, options?: MethodOptions): GaxiosPromise<Schema$Folder>;
+        update(params: Params$Resource$Accounts$Containers$Folders$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Folders$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Folder>>;
         update(params: Params$Resource$Accounts$Containers$Folders$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Folders$Update, options: MethodOptions | BodyResponseCallback<Schema$Folder>, callback: BodyResponseCallback<Schema$Folder>): void;
         update(params: Params$Resource$Accounts$Containers$Folders$Update, callback: BodyResponseCallback<Schema$Folder>): void;
@@ -1319,14 +2391,69 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * List all entities in a GTM Folder.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.folders.entities.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Folder ID.
+         *     folderId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "tag": [],
+         *   //   "trigger": [],
+         *   //   "variable": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Containers$Folders$Entities$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Containers$Folders$Entities$List, options?: MethodOptions): GaxiosPromise<Schema$FolderEntities>;
+        list(params: Params$Resource$Accounts$Containers$Folders$Entities$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Containers$Folders$Entities$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$FolderEntities>>;
         list(params: Params$Resource$Accounts$Containers$Folders$Entities$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Containers$Folders$Entities$List, options: MethodOptions | BodyResponseCallback<Schema$FolderEntities>, callback: BodyResponseCallback<Schema$FolderEntities>): void;
         list(params: Params$Resource$Accounts$Containers$Folders$Entities$List, callback: BodyResponseCallback<Schema$FolderEntities>): void;
@@ -1351,14 +2478,77 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Moves entities to a GTM Folder.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.move_folders.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Folder ID.
+         *     folderId: 'placeholder-value',
+         *     // The tags to be moved to the folder.
+         *     tagId: 'placeholder-value',
+         *     // The triggers to be moved to the folder.
+         *     triggerId: 'placeholder-value',
+         *     // The variables to be moved to the folder.
+         *     variableId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "containerId": "my_containerId",
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "folderId": "my_folderId",
+         *       //   "name": "my_name"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Move_folders$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Move_folders$Update, options?: MethodOptions): GaxiosPromise<void>;
+        update(params: Params$Resource$Accounts$Containers$Move_folders$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Move_folders$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         update(params: Params$Resource$Accounts$Containers$Move_folders$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Move_folders$Update, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         update(params: Params$Resource$Accounts$Containers$Move_folders$Update, callback: BodyResponseCallback<void>): void;
@@ -1399,14 +2589,95 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Re-generates the authorization code for a GTM Environment.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.publish'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.reauthorize_environments.update({
+         *       // The GTM Account ID.
+         *       accountId: 'placeholder-value',
+         *       // The GTM Container ID.
+         *       containerId: 'placeholder-value',
+         *       // The GTM Environment ID.
+         *       environmentId: 'placeholder-value',
+         *
+         *       // Request body metadata
+         *       requestBody: {
+         *         // request body parameters
+         *         // {
+         *         //   "accountId": "my_accountId",
+         *         //   "authorizationCode": "my_authorizationCode",
+         *         //   "authorizationTimestampMs": "my_authorizationTimestampMs",
+         *         //   "containerId": "my_containerId",
+         *         //   "containerVersionId": "my_containerVersionId",
+         *         //   "description": "my_description",
+         *         //   "enableDebug": false,
+         *         //   "environmentId": "my_environmentId",
+         *         //   "fingerprint": "my_fingerprint",
+         *         //   "name": "my_name",
+         *         //   "type": "my_type",
+         *         //   "url": "my_url"
+         *         // }
+         *       },
+         *     });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "authorizationCode": "my_authorizationCode",
+         *   //   "authorizationTimestampMs": "my_authorizationTimestampMs",
+         *   //   "containerId": "my_containerId",
+         *   //   "containerVersionId": "my_containerVersionId",
+         *   //   "description": "my_description",
+         *   //   "enableDebug": false,
+         *   //   "environmentId": "my_environmentId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "type": "my_type",
+         *   //   "url": "my_url"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Reauthorize_environments$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Reauthorize_environments$Update, options?: MethodOptions): GaxiosPromise<Schema$Environment>;
+        update(params: Params$Resource$Accounts$Containers$Reauthorize_environments$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Reauthorize_environments$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Environment>>;
         update(params: Params$Resource$Accounts$Containers$Reauthorize_environments$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Reauthorize_environments$Update, options: MethodOptions | BodyResponseCallback<Schema$Environment>, callback: BodyResponseCallback<Schema$Environment>): void;
         update(params: Params$Resource$Accounts$Containers$Reauthorize_environments$Update, callback: BodyResponseCallback<Schema$Environment>): void;
@@ -1435,70 +2706,425 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a GTM Tag.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.tags.create({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "blockingTriggerId": [],
+         *       //   "containerId": "my_containerId",
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "firingTriggerId": [],
+         *       //   "liveOnly": false,
+         *       //   "name": "my_name",
+         *       //   "notes": "my_notes",
+         *       //   "parameter": [],
+         *       //   "parentFolderId": "my_parentFolderId",
+         *       //   "paused": false,
+         *       //   "priority": {},
+         *       //   "scheduleEndMs": "my_scheduleEndMs",
+         *       //   "scheduleStartMs": "my_scheduleStartMs",
+         *       //   "setupTag": [],
+         *       //   "tagFiringOption": "my_tagFiringOption",
+         *       //   "tagId": "my_tagId",
+         *       //   "teardownTag": [],
+         *       //   "type": "my_type"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "blockingTriggerId": [],
+         *   //   "containerId": "my_containerId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "firingTriggerId": [],
+         *   //   "liveOnly": false,
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "paused": false,
+         *   //   "priority": {},
+         *   //   "scheduleEndMs": "my_scheduleEndMs",
+         *   //   "scheduleStartMs": "my_scheduleStartMs",
+         *   //   "setupTag": [],
+         *   //   "tagFiringOption": "my_tagFiringOption",
+         *   //   "tagId": "my_tagId",
+         *   //   "teardownTag": [],
+         *   //   "type": "my_type"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Accounts$Containers$Tags$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Accounts$Containers$Tags$Create, options?: MethodOptions): GaxiosPromise<Schema$Tag>;
+        create(params: Params$Resource$Accounts$Containers$Tags$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Accounts$Containers$Tags$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Tag>>;
         create(params: Params$Resource$Accounts$Containers$Tags$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Accounts$Containers$Tags$Create, options: MethodOptions | BodyResponseCallback<Schema$Tag>, callback: BodyResponseCallback<Schema$Tag>): void;
         create(params: Params$Resource$Accounts$Containers$Tags$Create, callback: BodyResponseCallback<Schema$Tag>): void;
         create(callback: BodyResponseCallback<Schema$Tag>): void;
         /**
          * Deletes a GTM Tag.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.tags.delete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Tag ID.
+         *     tagId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Accounts$Containers$Tags$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Accounts$Containers$Tags$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Accounts$Containers$Tags$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Accounts$Containers$Tags$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Accounts$Containers$Tags$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Accounts$Containers$Tags$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Accounts$Containers$Tags$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Gets a GTM Tag.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.tags.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Tag ID.
+         *     tagId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "blockingTriggerId": [],
+         *   //   "containerId": "my_containerId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "firingTriggerId": [],
+         *   //   "liveOnly": false,
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "paused": false,
+         *   //   "priority": {},
+         *   //   "scheduleEndMs": "my_scheduleEndMs",
+         *   //   "scheduleStartMs": "my_scheduleStartMs",
+         *   //   "setupTag": [],
+         *   //   "tagFiringOption": "my_tagFiringOption",
+         *   //   "tagId": "my_tagId",
+         *   //   "teardownTag": [],
+         *   //   "type": "my_type"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Containers$Tags$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Containers$Tags$Get, options?: MethodOptions): GaxiosPromise<Schema$Tag>;
+        get(params: Params$Resource$Accounts$Containers$Tags$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Containers$Tags$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Tag>>;
         get(params: Params$Resource$Accounts$Containers$Tags$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Containers$Tags$Get, options: MethodOptions | BodyResponseCallback<Schema$Tag>, callback: BodyResponseCallback<Schema$Tag>): void;
         get(params: Params$Resource$Accounts$Containers$Tags$Get, callback: BodyResponseCallback<Schema$Tag>): void;
         get(callback: BodyResponseCallback<Schema$Tag>): void;
         /**
          * Lists all GTM Tags of a Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.tags.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "tags": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Containers$Tags$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Containers$Tags$List, options?: MethodOptions): GaxiosPromise<Schema$ListTagsResponse>;
+        list(params: Params$Resource$Accounts$Containers$Tags$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Containers$Tags$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListTagsResponse>>;
         list(params: Params$Resource$Accounts$Containers$Tags$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Containers$Tags$List, options: MethodOptions | BodyResponseCallback<Schema$ListTagsResponse>, callback: BodyResponseCallback<Schema$ListTagsResponse>): void;
         list(params: Params$Resource$Accounts$Containers$Tags$List, callback: BodyResponseCallback<Schema$ListTagsResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListTagsResponse>): void;
         /**
          * Updates a GTM Tag.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.tags.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the tag in storage.
+         *     fingerprint: 'placeholder-value',
+         *     // The GTM Tag ID.
+         *     tagId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "blockingTriggerId": [],
+         *       //   "containerId": "my_containerId",
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "firingTriggerId": [],
+         *       //   "liveOnly": false,
+         *       //   "name": "my_name",
+         *       //   "notes": "my_notes",
+         *       //   "parameter": [],
+         *       //   "parentFolderId": "my_parentFolderId",
+         *       //   "paused": false,
+         *       //   "priority": {},
+         *       //   "scheduleEndMs": "my_scheduleEndMs",
+         *       //   "scheduleStartMs": "my_scheduleStartMs",
+         *       //   "setupTag": [],
+         *       //   "tagFiringOption": "my_tagFiringOption",
+         *       //   "tagId": "my_tagId",
+         *       //   "teardownTag": [],
+         *       //   "type": "my_type"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "blockingTriggerId": [],
+         *   //   "containerId": "my_containerId",
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "firingTriggerId": [],
+         *   //   "liveOnly": false,
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "paused": false,
+         *   //   "priority": {},
+         *   //   "scheduleEndMs": "my_scheduleEndMs",
+         *   //   "scheduleStartMs": "my_scheduleStartMs",
+         *   //   "setupTag": [],
+         *   //   "tagFiringOption": "my_tagFiringOption",
+         *   //   "tagId": "my_tagId",
+         *   //   "teardownTag": [],
+         *   //   "type": "my_type"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Tags$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Tags$Update, options?: MethodOptions): GaxiosPromise<Schema$Tag>;
+        update(params: Params$Resource$Accounts$Containers$Tags$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Tags$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Tag>>;
         update(params: Params$Resource$Accounts$Containers$Tags$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Tags$Update, options: MethodOptions | BodyResponseCallback<Schema$Tag>, callback: BodyResponseCallback<Schema$Tag>): void;
         update(params: Params$Resource$Accounts$Containers$Tags$Update, callback: BodyResponseCallback<Schema$Tag>): void;
@@ -1583,70 +3209,470 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a GTM Trigger.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.triggers.create({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "autoEventFilter": [],
+         *       //   "checkValidation": {},
+         *       //   "containerId": "my_containerId",
+         *       //   "continuousTimeMinMilliseconds": {},
+         *       //   "customEventFilter": [],
+         *       //   "eventName": {},
+         *       //   "filter": [],
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "horizontalScrollPercentageList": {},
+         *       //   "interval": {},
+         *       //   "intervalSeconds": {},
+         *       //   "limit": {},
+         *       //   "maxTimerLengthSeconds": {},
+         *       //   "name": "my_name",
+         *       //   "parameter": [],
+         *       //   "parentFolderId": "my_parentFolderId",
+         *       //   "selector": {},
+         *       //   "totalTimeMinMilliseconds": {},
+         *       //   "triggerId": "my_triggerId",
+         *       //   "type": "my_type",
+         *       //   "uniqueTriggerId": {},
+         *       //   "verticalScrollPercentageList": {},
+         *       //   "visibilitySelector": {},
+         *       //   "visiblePercentageMax": {},
+         *       //   "visiblePercentageMin": {},
+         *       //   "waitForTags": {},
+         *       //   "waitForTagsTimeout": {}
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "autoEventFilter": [],
+         *   //   "checkValidation": {},
+         *   //   "containerId": "my_containerId",
+         *   //   "continuousTimeMinMilliseconds": {},
+         *   //   "customEventFilter": [],
+         *   //   "eventName": {},
+         *   //   "filter": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "horizontalScrollPercentageList": {},
+         *   //   "interval": {},
+         *   //   "intervalSeconds": {},
+         *   //   "limit": {},
+         *   //   "maxTimerLengthSeconds": {},
+         *   //   "name": "my_name",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "selector": {},
+         *   //   "totalTimeMinMilliseconds": {},
+         *   //   "triggerId": "my_triggerId",
+         *   //   "type": "my_type",
+         *   //   "uniqueTriggerId": {},
+         *   //   "verticalScrollPercentageList": {},
+         *   //   "visibilitySelector": {},
+         *   //   "visiblePercentageMax": {},
+         *   //   "visiblePercentageMin": {},
+         *   //   "waitForTags": {},
+         *   //   "waitForTagsTimeout": {}
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Accounts$Containers$Triggers$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Accounts$Containers$Triggers$Create, options?: MethodOptions): GaxiosPromise<Schema$Trigger>;
+        create(params: Params$Resource$Accounts$Containers$Triggers$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Accounts$Containers$Triggers$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Trigger>>;
         create(params: Params$Resource$Accounts$Containers$Triggers$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Accounts$Containers$Triggers$Create, options: MethodOptions | BodyResponseCallback<Schema$Trigger>, callback: BodyResponseCallback<Schema$Trigger>): void;
         create(params: Params$Resource$Accounts$Containers$Triggers$Create, callback: BodyResponseCallback<Schema$Trigger>): void;
         create(callback: BodyResponseCallback<Schema$Trigger>): void;
         /**
          * Deletes a GTM Trigger.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.triggers.delete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Trigger ID.
+         *     triggerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Accounts$Containers$Triggers$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Accounts$Containers$Triggers$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Accounts$Containers$Triggers$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Accounts$Containers$Triggers$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Accounts$Containers$Triggers$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Accounts$Containers$Triggers$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Accounts$Containers$Triggers$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Gets a GTM Trigger.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.triggers.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Trigger ID.
+         *     triggerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "autoEventFilter": [],
+         *   //   "checkValidation": {},
+         *   //   "containerId": "my_containerId",
+         *   //   "continuousTimeMinMilliseconds": {},
+         *   //   "customEventFilter": [],
+         *   //   "eventName": {},
+         *   //   "filter": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "horizontalScrollPercentageList": {},
+         *   //   "interval": {},
+         *   //   "intervalSeconds": {},
+         *   //   "limit": {},
+         *   //   "maxTimerLengthSeconds": {},
+         *   //   "name": "my_name",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "selector": {},
+         *   //   "totalTimeMinMilliseconds": {},
+         *   //   "triggerId": "my_triggerId",
+         *   //   "type": "my_type",
+         *   //   "uniqueTriggerId": {},
+         *   //   "verticalScrollPercentageList": {},
+         *   //   "visibilitySelector": {},
+         *   //   "visiblePercentageMax": {},
+         *   //   "visiblePercentageMin": {},
+         *   //   "waitForTags": {},
+         *   //   "waitForTagsTimeout": {}
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Containers$Triggers$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Containers$Triggers$Get, options?: MethodOptions): GaxiosPromise<Schema$Trigger>;
+        get(params: Params$Resource$Accounts$Containers$Triggers$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Containers$Triggers$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Trigger>>;
         get(params: Params$Resource$Accounts$Containers$Triggers$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Containers$Triggers$Get, options: MethodOptions | BodyResponseCallback<Schema$Trigger>, callback: BodyResponseCallback<Schema$Trigger>): void;
         get(params: Params$Resource$Accounts$Containers$Triggers$Get, callback: BodyResponseCallback<Schema$Trigger>): void;
         get(callback: BodyResponseCallback<Schema$Trigger>): void;
         /**
          * Lists all GTM Triggers of a Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.triggers.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "triggers": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Containers$Triggers$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Containers$Triggers$List, options?: MethodOptions): GaxiosPromise<Schema$ListTriggersResponse>;
+        list(params: Params$Resource$Accounts$Containers$Triggers$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Containers$Triggers$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListTriggersResponse>>;
         list(params: Params$Resource$Accounts$Containers$Triggers$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Containers$Triggers$List, options: MethodOptions | BodyResponseCallback<Schema$ListTriggersResponse>, callback: BodyResponseCallback<Schema$ListTriggersResponse>): void;
         list(params: Params$Resource$Accounts$Containers$Triggers$List, callback: BodyResponseCallback<Schema$ListTriggersResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListTriggersResponse>): void;
         /**
          * Updates a GTM Trigger.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.triggers.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the trigger in storage.
+         *     fingerprint: 'placeholder-value',
+         *     // The GTM Trigger ID.
+         *     triggerId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "autoEventFilter": [],
+         *       //   "checkValidation": {},
+         *       //   "containerId": "my_containerId",
+         *       //   "continuousTimeMinMilliseconds": {},
+         *       //   "customEventFilter": [],
+         *       //   "eventName": {},
+         *       //   "filter": [],
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "horizontalScrollPercentageList": {},
+         *       //   "interval": {},
+         *       //   "intervalSeconds": {},
+         *       //   "limit": {},
+         *       //   "maxTimerLengthSeconds": {},
+         *       //   "name": "my_name",
+         *       //   "parameter": [],
+         *       //   "parentFolderId": "my_parentFolderId",
+         *       //   "selector": {},
+         *       //   "totalTimeMinMilliseconds": {},
+         *       //   "triggerId": "my_triggerId",
+         *       //   "type": "my_type",
+         *       //   "uniqueTriggerId": {},
+         *       //   "verticalScrollPercentageList": {},
+         *       //   "visibilitySelector": {},
+         *       //   "visiblePercentageMax": {},
+         *       //   "visiblePercentageMin": {},
+         *       //   "waitForTags": {},
+         *       //   "waitForTagsTimeout": {}
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "autoEventFilter": [],
+         *   //   "checkValidation": {},
+         *   //   "containerId": "my_containerId",
+         *   //   "continuousTimeMinMilliseconds": {},
+         *   //   "customEventFilter": [],
+         *   //   "eventName": {},
+         *   //   "filter": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "horizontalScrollPercentageList": {},
+         *   //   "interval": {},
+         *   //   "intervalSeconds": {},
+         *   //   "limit": {},
+         *   //   "maxTimerLengthSeconds": {},
+         *   //   "name": "my_name",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "selector": {},
+         *   //   "totalTimeMinMilliseconds": {},
+         *   //   "triggerId": "my_triggerId",
+         *   //   "type": "my_type",
+         *   //   "uniqueTriggerId": {},
+         *   //   "verticalScrollPercentageList": {},
+         *   //   "visibilitySelector": {},
+         *   //   "visiblePercentageMax": {},
+         *   //   "visiblePercentageMin": {},
+         *   //   "waitForTags": {},
+         *   //   "waitForTagsTimeout": {}
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Triggers$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Triggers$Update, options?: MethodOptions): GaxiosPromise<Schema$Trigger>;
+        update(params: Params$Resource$Accounts$Containers$Triggers$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Triggers$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Trigger>>;
         update(params: Params$Resource$Accounts$Containers$Triggers$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Triggers$Update, options: MethodOptions | BodyResponseCallback<Schema$Trigger>, callback: BodyResponseCallback<Schema$Trigger>): void;
         update(params: Params$Resource$Accounts$Containers$Triggers$Update, callback: BodyResponseCallback<Schema$Trigger>): void;
@@ -1731,70 +3757,395 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a GTM Variable.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.variables.create({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "containerId": "my_containerId",
+         *       //   "disablingTriggerId": [],
+         *       //   "enablingTriggerId": [],
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "name": "my_name",
+         *       //   "notes": "my_notes",
+         *       //   "parameter": [],
+         *       //   "parentFolderId": "my_parentFolderId",
+         *       //   "scheduleEndMs": "my_scheduleEndMs",
+         *       //   "scheduleStartMs": "my_scheduleStartMs",
+         *       //   "type": "my_type",
+         *       //   "variableId": "my_variableId"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "disablingTriggerId": [],
+         *   //   "enablingTriggerId": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "scheduleEndMs": "my_scheduleEndMs",
+         *   //   "scheduleStartMs": "my_scheduleStartMs",
+         *   //   "type": "my_type",
+         *   //   "variableId": "my_variableId"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Accounts$Containers$Variables$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Accounts$Containers$Variables$Create, options?: MethodOptions): GaxiosPromise<Schema$Variable>;
+        create(params: Params$Resource$Accounts$Containers$Variables$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Accounts$Containers$Variables$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Variable>>;
         create(params: Params$Resource$Accounts$Containers$Variables$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Accounts$Containers$Variables$Create, options: MethodOptions | BodyResponseCallback<Schema$Variable>, callback: BodyResponseCallback<Schema$Variable>): void;
         create(params: Params$Resource$Accounts$Containers$Variables$Create, callback: BodyResponseCallback<Schema$Variable>): void;
         create(callback: BodyResponseCallback<Schema$Variable>): void;
         /**
          * Deletes a GTM Variable.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.variables.delete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Variable ID.
+         *     variableId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Accounts$Containers$Variables$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Accounts$Containers$Variables$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Accounts$Containers$Variables$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Accounts$Containers$Variables$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Accounts$Containers$Variables$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Accounts$Containers$Variables$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Accounts$Containers$Variables$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Gets a GTM Variable.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.variables.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Variable ID.
+         *     variableId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "disablingTriggerId": [],
+         *   //   "enablingTriggerId": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "scheduleEndMs": "my_scheduleEndMs",
+         *   //   "scheduleStartMs": "my_scheduleStartMs",
+         *   //   "type": "my_type",
+         *   //   "variableId": "my_variableId"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Containers$Variables$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Containers$Variables$Get, options?: MethodOptions): GaxiosPromise<Schema$Variable>;
+        get(params: Params$Resource$Accounts$Containers$Variables$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Containers$Variables$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Variable>>;
         get(params: Params$Resource$Accounts$Containers$Variables$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Containers$Variables$Get, options: MethodOptions | BodyResponseCallback<Schema$Variable>, callback: BodyResponseCallback<Schema$Variable>): void;
         get(params: Params$Resource$Accounts$Containers$Variables$Get, callback: BodyResponseCallback<Schema$Variable>): void;
         get(callback: BodyResponseCallback<Schema$Variable>): void;
         /**
          * Lists all GTM Variables of a Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.variables.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "variables": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Containers$Variables$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Containers$Variables$List, options?: MethodOptions): GaxiosPromise<Schema$ListVariablesResponse>;
+        list(params: Params$Resource$Accounts$Containers$Variables$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Containers$Variables$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListVariablesResponse>>;
         list(params: Params$Resource$Accounts$Containers$Variables$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Containers$Variables$List, options: MethodOptions | BodyResponseCallback<Schema$ListVariablesResponse>, callback: BodyResponseCallback<Schema$ListVariablesResponse>): void;
         list(params: Params$Resource$Accounts$Containers$Variables$List, callback: BodyResponseCallback<Schema$ListVariablesResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListVariablesResponse>): void;
         /**
          * Updates a GTM Variable.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.variables.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the variable in storage.
+         *     fingerprint: 'placeholder-value',
+         *     // The GTM Variable ID.
+         *     variableId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "containerId": "my_containerId",
+         *       //   "disablingTriggerId": [],
+         *       //   "enablingTriggerId": [],
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "name": "my_name",
+         *       //   "notes": "my_notes",
+         *       //   "parameter": [],
+         *       //   "parentFolderId": "my_parentFolderId",
+         *       //   "scheduleEndMs": "my_scheduleEndMs",
+         *       //   "scheduleStartMs": "my_scheduleStartMs",
+         *       //   "type": "my_type",
+         *       //   "variableId": "my_variableId"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "containerId": "my_containerId",
+         *   //   "disablingTriggerId": [],
+         *   //   "enablingTriggerId": [],
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "parameter": [],
+         *   //   "parentFolderId": "my_parentFolderId",
+         *   //   "scheduleEndMs": "my_scheduleEndMs",
+         *   //   "scheduleStartMs": "my_scheduleStartMs",
+         *   //   "type": "my_type",
+         *   //   "variableId": "my_variableId"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Variables$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Variables$Update, options?: MethodOptions): GaxiosPromise<Schema$Variable>;
+        update(params: Params$Resource$Accounts$Containers$Variables$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Variables$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Variable>>;
         update(params: Params$Resource$Accounts$Containers$Variables$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Variables$Update, options: MethodOptions | BodyResponseCallback<Schema$Variable>, callback: BodyResponseCallback<Schema$Variable>): void;
         update(params: Params$Resource$Accounts$Containers$Variables$Update, callback: BodyResponseCallback<Schema$Variable>): void;
@@ -1879,112 +4230,603 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a Container Version.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containerversions',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.versions.create({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "name": "my_name",
+         *       //   "notes": "my_notes",
+         *       //   "quickPreview": false
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "compilerError": false,
+         *   //   "containerVersion": {}
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Accounts$Containers$Versions$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Accounts$Containers$Versions$Create, options?: MethodOptions): GaxiosPromise<Schema$CreateContainerVersionResponse>;
+        create(params: Params$Resource$Accounts$Containers$Versions$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Accounts$Containers$Versions$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$CreateContainerVersionResponse>>;
         create(params: Params$Resource$Accounts$Containers$Versions$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Accounts$Containers$Versions$Create, options: MethodOptions | BodyResponseCallback<Schema$CreateContainerVersionResponse>, callback: BodyResponseCallback<Schema$CreateContainerVersionResponse>): void;
         create(params: Params$Resource$Accounts$Containers$Versions$Create, callback: BodyResponseCallback<Schema$CreateContainerVersionResponse>): void;
         create(callback: BodyResponseCallback<Schema$CreateContainerVersionResponse>): void;
         /**
          * Deletes a Container Version.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containerversions',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.versions.delete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Container Version ID.
+         *     containerVersionId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Accounts$Containers$Versions$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Accounts$Containers$Versions$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Accounts$Containers$Versions$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Accounts$Containers$Versions$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Accounts$Containers$Versions$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Accounts$Containers$Versions$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Accounts$Containers$Versions$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Gets a Container Version.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.edit.containerversions',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.versions.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Container Version ID. Specify published to retrieve the currently published version.
+         *     containerVersionId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "container": {},
+         *   //   "containerId": "my_containerId",
+         *   //   "containerVersionId": "my_containerVersionId",
+         *   //   "deleted": false,
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "folder": [],
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "tag": [],
+         *   //   "trigger": [],
+         *   //   "variable": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Containers$Versions$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Containers$Versions$Get, options?: MethodOptions): GaxiosPromise<Schema$ContainerVersion>;
+        get(params: Params$Resource$Accounts$Containers$Versions$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Containers$Versions$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ContainerVersion>>;
         get(params: Params$Resource$Accounts$Containers$Versions$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Containers$Versions$Get, options: MethodOptions | BodyResponseCallback<Schema$ContainerVersion>, callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         get(params: Params$Resource$Accounts$Containers$Versions$Get, callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         get(callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         /**
          * Lists all Container Versions of a GTM Container.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers',
+         *       'https://www.googleapis.com/auth/tagmanager.edit.containerversions',
+         *       'https://www.googleapis.com/auth/tagmanager.readonly',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.versions.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // Retrieve headers only when true.
+         *     headers: 'placeholder-value',
+         *     // Also retrieve deleted (archived) versions when true.
+         *     includeDeleted: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "containerVersion": [],
+         *   //   "containerVersionHeader": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Containers$Versions$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Containers$Versions$List, options?: MethodOptions): GaxiosPromise<Schema$ListContainerVersionsResponse>;
+        list(params: Params$Resource$Accounts$Containers$Versions$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Containers$Versions$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListContainerVersionsResponse>>;
         list(params: Params$Resource$Accounts$Containers$Versions$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Containers$Versions$List, options: MethodOptions | BodyResponseCallback<Schema$ListContainerVersionsResponse>, callback: BodyResponseCallback<Schema$ListContainerVersionsResponse>): void;
         list(params: Params$Resource$Accounts$Containers$Versions$List, callback: BodyResponseCallback<Schema$ListContainerVersionsResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListContainerVersionsResponse>): void;
         /**
          * Publishes a Container Version.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.publish'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.versions.publish({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Container Version ID.
+         *     containerVersionId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the container version in storage.
+         *     fingerprint: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "compilerError": false,
+         *   //   "containerVersion": {}
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        publish(params: Params$Resource$Accounts$Containers$Versions$Publish, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        publish(params?: Params$Resource$Accounts$Containers$Versions$Publish, options?: MethodOptions): GaxiosPromise<Schema$PublishContainerVersionResponse>;
+        publish(params: Params$Resource$Accounts$Containers$Versions$Publish, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        publish(params?: Params$Resource$Accounts$Containers$Versions$Publish, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$PublishContainerVersionResponse>>;
         publish(params: Params$Resource$Accounts$Containers$Versions$Publish, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         publish(params: Params$Resource$Accounts$Containers$Versions$Publish, options: MethodOptions | BodyResponseCallback<Schema$PublishContainerVersionResponse>, callback: BodyResponseCallback<Schema$PublishContainerVersionResponse>): void;
         publish(params: Params$Resource$Accounts$Containers$Versions$Publish, callback: BodyResponseCallback<Schema$PublishContainerVersionResponse>): void;
         publish(callback: BodyResponseCallback<Schema$PublishContainerVersionResponse>): void;
         /**
          * Restores a Container Version. This will overwrite the container's current configuration (including its variables, triggers and tags). The operation will not have any effect on the version that is being served (i.e. the published version).
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containers'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.versions.restore({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Container Version ID.
+         *     containerVersionId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "container": {},
+         *   //   "containerId": "my_containerId",
+         *   //   "containerVersionId": "my_containerVersionId",
+         *   //   "deleted": false,
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "folder": [],
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "tag": [],
+         *   //   "trigger": [],
+         *   //   "variable": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        restore(params: Params$Resource$Accounts$Containers$Versions$Restore, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        restore(params?: Params$Resource$Accounts$Containers$Versions$Restore, options?: MethodOptions): GaxiosPromise<Schema$ContainerVersion>;
+        restore(params: Params$Resource$Accounts$Containers$Versions$Restore, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        restore(params?: Params$Resource$Accounts$Containers$Versions$Restore, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ContainerVersion>>;
         restore(params: Params$Resource$Accounts$Containers$Versions$Restore, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         restore(params: Params$Resource$Accounts$Containers$Versions$Restore, options: MethodOptions | BodyResponseCallback<Schema$ContainerVersion>, callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         restore(params: Params$Resource$Accounts$Containers$Versions$Restore, callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         restore(callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         /**
          * Undeletes a Container Version.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containerversions',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.versions.undelete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Container Version ID.
+         *     containerVersionId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "container": {},
+         *   //   "containerId": "my_containerId",
+         *   //   "containerVersionId": "my_containerVersionId",
+         *   //   "deleted": false,
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "folder": [],
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "tag": [],
+         *   //   "trigger": [],
+         *   //   "variable": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        undelete(params: Params$Resource$Accounts$Containers$Versions$Undelete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        undelete(params?: Params$Resource$Accounts$Containers$Versions$Undelete, options?: MethodOptions): GaxiosPromise<Schema$ContainerVersion>;
+        undelete(params: Params$Resource$Accounts$Containers$Versions$Undelete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        undelete(params?: Params$Resource$Accounts$Containers$Versions$Undelete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ContainerVersion>>;
         undelete(params: Params$Resource$Accounts$Containers$Versions$Undelete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         undelete(params: Params$Resource$Accounts$Containers$Versions$Undelete, options: MethodOptions | BodyResponseCallback<Schema$ContainerVersion>, callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         undelete(params: Params$Resource$Accounts$Containers$Versions$Undelete, callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         undelete(callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         /**
          * Updates a Container Version.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.edit.containerversions',
+         *     ],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.containers.versions.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM Container ID.
+         *     containerId: 'placeholder-value',
+         *     // The GTM Container Version ID.
+         *     containerVersionId: 'placeholder-value',
+         *     // When provided, this fingerprint must match the fingerprint of the container version in storage.
+         *     fingerprint: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountId": "my_accountId",
+         *       //   "container": {},
+         *       //   "containerId": "my_containerId",
+         *       //   "containerVersionId": "my_containerVersionId",
+         *       //   "deleted": false,
+         *       //   "fingerprint": "my_fingerprint",
+         *       //   "folder": [],
+         *       //   "name": "my_name",
+         *       //   "notes": "my_notes",
+         *       //   "tag": [],
+         *       //   "trigger": [],
+         *       //   "variable": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountId": "my_accountId",
+         *   //   "container": {},
+         *   //   "containerId": "my_containerId",
+         *   //   "containerVersionId": "my_containerVersionId",
+         *   //   "deleted": false,
+         *   //   "fingerprint": "my_fingerprint",
+         *   //   "folder": [],
+         *   //   "name": "my_name",
+         *   //   "notes": "my_notes",
+         *   //   "tag": [],
+         *   //   "trigger": [],
+         *   //   "variable": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Containers$Versions$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Containers$Versions$Update, options?: MethodOptions): GaxiosPromise<Schema$ContainerVersion>;
+        update(params: Params$Resource$Accounts$Containers$Versions$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Containers$Versions$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ContainerVersion>>;
         update(params: Params$Resource$Accounts$Containers$Versions$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Containers$Versions$Update, options: MethodOptions | BodyResponseCallback<Schema$ContainerVersion>, callback: BodyResponseCallback<Schema$ContainerVersion>): void;
         update(params: Params$Resource$Accounts$Containers$Versions$Update, callback: BodyResponseCallback<Schema$ContainerVersion>): void;
@@ -2123,70 +4965,337 @@ export declare namespace tagmanager_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a user's Account & Container Permissions.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.manage.users'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.permissions.create({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountAccess": {},
+         *       //   "accountId": "my_accountId",
+         *       //   "containerAccess": [],
+         *       //   "emailAddress": "my_emailAddress",
+         *       //   "permissionId": "my_permissionId"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountAccess": {},
+         *   //   "accountId": "my_accountId",
+         *   //   "containerAccess": [],
+         *   //   "emailAddress": "my_emailAddress",
+         *   //   "permissionId": "my_permissionId"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        create(params: Params$Resource$Accounts$Permissions$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Accounts$Permissions$Create, options?: MethodOptions): GaxiosPromise<Schema$UserAccess>;
+        create(params: Params$Resource$Accounts$Permissions$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Accounts$Permissions$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$UserAccess>>;
         create(params: Params$Resource$Accounts$Permissions$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Accounts$Permissions$Create, options: MethodOptions | BodyResponseCallback<Schema$UserAccess>, callback: BodyResponseCallback<Schema$UserAccess>): void;
         create(params: Params$Resource$Accounts$Permissions$Create, callback: BodyResponseCallback<Schema$UserAccess>): void;
         create(callback: BodyResponseCallback<Schema$UserAccess>): void;
         /**
          * Removes a user from the account, revoking access to it and all of its containers.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.manage.users'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.permissions.delete({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM User ID.
+         *     permissionId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        delete(params: Params$Resource$Accounts$Permissions$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Accounts$Permissions$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Accounts$Permissions$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Accounts$Permissions$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Accounts$Permissions$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Accounts$Permissions$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Accounts$Permissions$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Gets a user's Account & Container Permissions.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.manage.users'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.permissions.get({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM User ID.
+         *     permissionId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountAccess": {},
+         *   //   "accountId": "my_accountId",
+         *   //   "containerAccess": [],
+         *   //   "emailAddress": "my_emailAddress",
+         *   //   "permissionId": "my_permissionId"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Accounts$Permissions$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Accounts$Permissions$Get, options?: MethodOptions): GaxiosPromise<Schema$UserAccess>;
+        get(params: Params$Resource$Accounts$Permissions$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Accounts$Permissions$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$UserAccess>>;
         get(params: Params$Resource$Accounts$Permissions$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Accounts$Permissions$Get, options: MethodOptions | BodyResponseCallback<Schema$UserAccess>, callback: BodyResponseCallback<Schema$UserAccess>): void;
         get(params: Params$Resource$Accounts$Permissions$Get, callback: BodyResponseCallback<Schema$UserAccess>): void;
         get(callback: BodyResponseCallback<Schema$UserAccess>): void;
         /**
          * List all users that have access to the account along with Account and Container Permissions granted to each of them.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.manage.users'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.permissions.list({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "userAccess": []
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Accounts$Permissions$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Accounts$Permissions$List, options?: MethodOptions): GaxiosPromise<Schema$ListAccountUsersResponse>;
+        list(params: Params$Resource$Accounts$Permissions$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Accounts$Permissions$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListAccountUsersResponse>>;
         list(params: Params$Resource$Accounts$Permissions$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Accounts$Permissions$List, options: MethodOptions | BodyResponseCallback<Schema$ListAccountUsersResponse>, callback: BodyResponseCallback<Schema$ListAccountUsersResponse>): void;
         list(params: Params$Resource$Accounts$Permissions$List, callback: BodyResponseCallback<Schema$ListAccountUsersResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListAccountUsersResponse>): void;
         /**
          * Updates a user's Account & Container Permissions.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/tagmanager.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 tagmanager = google.tagmanager('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/tagmanager.manage.users'],
+         *   });
+         *
+         *   // 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 tagmanager.accounts.permissions.update({
+         *     // The GTM Account ID.
+         *     accountId: 'placeholder-value',
+         *     // The GTM User ID.
+         *     permissionId: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "accountAccess": {},
+         *       //   "accountId": "my_accountId",
+         *       //   "containerAccess": [],
+         *       //   "emailAddress": "my_emailAddress",
+         *       //   "permissionId": "my_permissionId"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "accountAccess": {},
+         *   //   "accountId": "my_accountId",
+         *   //   "containerAccess": [],
+         *   //   "emailAddress": "my_emailAddress",
+         *   //   "permissionId": "my_permissionId"
+         *   // }
+         * }
+         *
+         * 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`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        update(params: Params$Resource$Accounts$Permissions$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Accounts$Permissions$Update, options?: MethodOptions): GaxiosPromise<Schema$UserAccess>;
+        update(params: Params$Resource$Accounts$Permissions$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Accounts$Permissions$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$UserAccess>>;
         update(params: Params$Resource$Accounts$Permissions$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Accounts$Permissions$Update, options: MethodOptions | BodyResponseCallback<Schema$UserAccess>, callback: BodyResponseCallback<Schema$UserAccess>): void;
         update(params: Params$Resource$Accounts$Permissions$Update, callback: BodyResponseCallback<Schema$UserAccess>): void;