@googleapis/dns 6.3.0 → 8.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 dns_v1 {
     export interface Options extends GlobalOptions {
@@ -1139,42 +1139,241 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Atomically updates the ResourceRecordSet collection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.changes.create({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "additions": [],
+         *       //   "deletions": [],
+         *       //   "id": "my_id",
+         *       //   "isServing": false,
+         *       //   "kind": "my_kind",
+         *       //   "startTime": "my_startTime",
+         *       //   "status": "my_status"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "additions": [],
+         *   //   "deletions": [],
+         *   //   "id": "my_id",
+         *   //   "isServing": false,
+         *   //   "kind": "my_kind",
+         *   //   "startTime": "my_startTime",
+         *   //   "status": "my_status"
+         *   // }
+         * }
+         *
+         * 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$Changes$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Changes$Create, options?: MethodOptions): GaxiosPromise<Schema$Change>;
+        create(params: Params$Resource$Changes$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Changes$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Change>>;
         create(params: Params$Resource$Changes$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Changes$Create, options: MethodOptions | BodyResponseCallback<Schema$Change>, callback: BodyResponseCallback<Schema$Change>): void;
         create(params: Params$Resource$Changes$Create, callback: BodyResponseCallback<Schema$Change>): void;
         create(callback: BodyResponseCallback<Schema$Change>): void;
         /**
          * Fetches the representation of an existing Change.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.changes.get({
+         *     // The identifier of the requested change, from a previous ResourceRecordSetsChangeResponse.
+         *     changeId: 'placeholder-value',
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "additions": [],
+         *   //   "deletions": [],
+         *   //   "id": "my_id",
+         *   //   "isServing": false,
+         *   //   "kind": "my_kind",
+         *   //   "startTime": "my_startTime",
+         *   //   "status": "my_status"
+         *   // }
+         * }
+         *
+         * 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$Changes$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Changes$Get, options?: MethodOptions): GaxiosPromise<Schema$Change>;
+        get(params: Params$Resource$Changes$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Changes$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Change>>;
         get(params: Params$Resource$Changes$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Changes$Get, options: MethodOptions | BodyResponseCallback<Schema$Change>, callback: BodyResponseCallback<Schema$Change>): void;
         get(params: Params$Resource$Changes$Get, callback: BodyResponseCallback<Schema$Change>): void;
         get(callback: BodyResponseCallback<Schema$Change>): void;
         /**
          * Enumerates Changes to a ResourceRecordSet collection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.changes.list({
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+         *     maxResults: 'placeholder-value',
+         *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+         *     pageToken: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // Sorting criterion. The only supported value is change sequence.
+         *     sortBy: 'placeholder-value',
+         *     // Sorting order direction: 'ascending' or 'descending'.
+         *     sortOrder: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "changes": [],
+         *   //   "kind": "my_kind",
+         *   //   "nextPageToken": "my_nextPageToken"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @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$Changes$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Changes$List, options?: MethodOptions): GaxiosPromise<Schema$ChangesListResponse>;
+        list(params: Params$Resource$Changes$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Changes$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ChangesListResponse>>;
         list(params: Params$Resource$Changes$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Changes$List, options: MethodOptions | BodyResponseCallback<Schema$ChangesListResponse>, callback: BodyResponseCallback<Schema$ChangesListResponse>): void;
         list(params: Params$Resource$Changes$List, callback: BodyResponseCallback<Schema$ChangesListResponse>): void;
@@ -1247,28 +1446,158 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Fetches the representation of an existing DnsKey.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.dnsKeys.get({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // An optional comma-separated list of digest types to compute and display for key signing keys. If omitted, the recommended digest type is computed and displayed.
+         *     digestType: 'placeholder-value',
+         *     // The identifier of the requested DnsKey.
+         *     dnsKeyId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "algorithm": "my_algorithm",
+         *   //   "creationTime": "my_creationTime",
+         *   //   "description": "my_description",
+         *   //   "digests": [],
+         *   //   "id": "my_id",
+         *   //   "isActive": false,
+         *   //   "keyLength": 0,
+         *   //   "keyTag": 0,
+         *   //   "kind": "my_kind",
+         *   //   "publicKey": "my_publicKey",
+         *   //   "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$Dnskeys$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Dnskeys$Get, options?: MethodOptions): GaxiosPromise<Schema$DnsKey>;
+        get(params: Params$Resource$Dnskeys$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Dnskeys$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$DnsKey>>;
         get(params: Params$Resource$Dnskeys$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Dnskeys$Get, options: MethodOptions | BodyResponseCallback<Schema$DnsKey>, callback: BodyResponseCallback<Schema$DnsKey>): void;
         get(params: Params$Resource$Dnskeys$Get, callback: BodyResponseCallback<Schema$DnsKey>): void;
         get(callback: BodyResponseCallback<Schema$DnsKey>): void;
         /**
          * Enumerates DnsKeys to a ResourceRecordSet collection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.dnsKeys.list({
+         *     // An optional comma-separated list of digest types to compute and display for key signing keys. If omitted, the recommended digest type is computed and displayed.
+         *     digestType: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+         *     maxResults: 'placeholder-value',
+         *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+         *     pageToken: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "dnsKeys": [],
+         *   //   "kind": "my_kind",
+         *   //   "nextPageToken": "my_nextPageToken"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @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$Dnskeys$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Dnskeys$List, options?: MethodOptions): GaxiosPromise<Schema$DnsKeysListResponse>;
+        list(params: Params$Resource$Dnskeys$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Dnskeys$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$DnsKeysListResponse>>;
         list(params: Params$Resource$Dnskeys$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Dnskeys$List, options: MethodOptions | BodyResponseCallback<Schema$DnsKeysListResponse>, callback: BodyResponseCallback<Schema$DnsKeysListResponse>): void;
         list(params: Params$Resource$Dnskeys$List, callback: BodyResponseCallback<Schema$DnsKeysListResponse>): void;
@@ -1323,28 +1652,153 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Fetches the representation of an existing Operation.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZoneOperations.get({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the operation addressed by this request (ID of the operation).
+         *     operation: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "dnsKeyContext": {},
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "startTime": "my_startTime",
+         *   //   "status": "my_status",
+         *   //   "type": "my_type",
+         *   //   "user": "my_user",
+         *   //   "zoneContext": {}
+         *   // }
+         * }
+         *
+         * 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$Managedzoneoperations$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Managedzoneoperations$Get, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        get(params: Params$Resource$Managedzoneoperations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Managedzoneoperations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         get(params: Params$Resource$Managedzoneoperations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Managedzoneoperations$Get, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         get(params: Params$Resource$Managedzoneoperations$Get, callback: BodyResponseCallback<Schema$Operation>): void;
         get(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Enumerates Operations for the given ManagedZone.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZoneOperations.list({
+         *     // Identifies the managed zone addressed by this request.
+         *     managedZone: 'placeholder-value',
+         *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+         *     maxResults: 'placeholder-value',
+         *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+         *     pageToken: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // Sorting criterion. The only supported values are START_TIME and ID.
+         *     sortBy: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "kind": "my_kind",
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "operations": []
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @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$Managedzoneoperations$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Managedzoneoperations$List, options?: MethodOptions): GaxiosPromise<Schema$ManagedZoneOperationsListResponse>;
+        list(params: Params$Resource$Managedzoneoperations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Managedzoneoperations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZoneOperationsListResponse>>;
         list(params: Params$Resource$Managedzoneoperations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Managedzoneoperations$List, options: MethodOptions | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>, callback: BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>): void;
         list(params: Params$Resource$Managedzoneoperations$List, callback: BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>): void;
@@ -1395,126 +1849,745 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a new ManagedZone.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.create({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "cloudLoggingConfig": {},
+         *       //   "creationTime": "my_creationTime",
+         *       //   "description": "my_description",
+         *       //   "dnsName": "my_dnsName",
+         *       //   "dnssecConfig": {},
+         *       //   "forwardingConfig": {},
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "labels": {},
+         *       //   "name": "my_name",
+         *       //   "nameServerSet": "my_nameServerSet",
+         *       //   "nameServers": [],
+         *       //   "peeringConfig": {},
+         *       //   "privateVisibilityConfig": {},
+         *       //   "reverseLookupConfig": {},
+         *       //   "serviceDirectoryConfig": {},
+         *       //   "visibility": "my_visibility"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "cloudLoggingConfig": {},
+         *   //   "creationTime": "my_creationTime",
+         *   //   "description": "my_description",
+         *   //   "dnsName": "my_dnsName",
+         *   //   "dnssecConfig": {},
+         *   //   "forwardingConfig": {},
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "labels": {},
+         *   //   "name": "my_name",
+         *   //   "nameServerSet": "my_nameServerSet",
+         *   //   "nameServers": [],
+         *   //   "peeringConfig": {},
+         *   //   "privateVisibilityConfig": {},
+         *   //   "reverseLookupConfig": {},
+         *   //   "serviceDirectoryConfig": {},
+         *   //   "visibility": "my_visibility"
+         *   // }
+         * }
+         *
+         * 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$Managedzones$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Managedzones$Create, options?: MethodOptions): GaxiosPromise<Schema$ManagedZone>;
+        create(params: Params$Resource$Managedzones$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Managedzones$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>;
         create(params: Params$Resource$Managedzones$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Managedzones$Create, options: MethodOptions | BodyResponseCallback<Schema$ManagedZone>, callback: BodyResponseCallback<Schema$ManagedZone>): void;
         create(params: Params$Resource$Managedzones$Create, callback: BodyResponseCallback<Schema$ManagedZone>): void;
         create(callback: BodyResponseCallback<Schema$ManagedZone>): void;
         /**
          * Deletes a previously created ManagedZone.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.delete({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: '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$Managedzones$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Managedzones$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Managedzones$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Managedzones$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Managedzones$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Managedzones$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Managedzones$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Fetches the representation of an existing ManagedZone.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.get({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "cloudLoggingConfig": {},
+         *   //   "creationTime": "my_creationTime",
+         *   //   "description": "my_description",
+         *   //   "dnsName": "my_dnsName",
+         *   //   "dnssecConfig": {},
+         *   //   "forwardingConfig": {},
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "labels": {},
+         *   //   "name": "my_name",
+         *   //   "nameServerSet": "my_nameServerSet",
+         *   //   "nameServers": [],
+         *   //   "peeringConfig": {},
+         *   //   "privateVisibilityConfig": {},
+         *   //   "reverseLookupConfig": {},
+         *   //   "serviceDirectoryConfig": {},
+         *   //   "visibility": "my_visibility"
+         *   // }
+         * }
+         *
+         * 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$Managedzones$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Managedzones$Get, options?: MethodOptions): GaxiosPromise<Schema$ManagedZone>;
+        get(params: Params$Resource$Managedzones$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Managedzones$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>;
         get(params: Params$Resource$Managedzones$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Managedzones$Get, options: MethodOptions | BodyResponseCallback<Schema$ManagedZone>, callback: BodyResponseCallback<Schema$ManagedZone>): void;
         get(params: Params$Resource$Managedzones$Get, callback: BodyResponseCallback<Schema$ManagedZone>): void;
         get(callback: BodyResponseCallback<Schema$ManagedZone>): void;
         /**
          * Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.getIamPolicy({
+         *     // REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
+         *     resource: 'projects/my-project/managedZones/my-managedZone',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "options": {}
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "auditConfigs": [],
+         *   //   "bindings": [],
+         *   //   "etag": "my_etag",
+         *   //   "version": 0
+         *   // }
+         * }
+         *
+         * 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.
          */
-        getIamPolicy(params: Params$Resource$Managedzones$Getiampolicy, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        getIamPolicy(params?: Params$Resource$Managedzones$Getiampolicy, options?: MethodOptions): GaxiosPromise<Schema$GoogleIamV1Policy>;
+        getIamPolicy(params: Params$Resource$Managedzones$Getiampolicy, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        getIamPolicy(params?: Params$Resource$Managedzones$Getiampolicy, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>;
         getIamPolicy(params: Params$Resource$Managedzones$Getiampolicy, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         getIamPolicy(params: Params$Resource$Managedzones$Getiampolicy, options: MethodOptions | BodyResponseCallback<Schema$GoogleIamV1Policy>, callback: BodyResponseCallback<Schema$GoogleIamV1Policy>): void;
         getIamPolicy(params: Params$Resource$Managedzones$Getiampolicy, callback: BodyResponseCallback<Schema$GoogleIamV1Policy>): void;
         getIamPolicy(callback: BodyResponseCallback<Schema$GoogleIamV1Policy>): void;
         /**
          * Enumerates ManagedZones that have been created but not yet deleted.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.list({
+         *     // Restricts the list to return only zones with this domain name.
+         *     dnsName: 'placeholder-value',
+         *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+         *     maxResults: 'placeholder-value',
+         *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+         *     pageToken: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "kind": "my_kind",
+         *   //   "managedZones": [],
+         *   //   "nextPageToken": "my_nextPageToken"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @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$Managedzones$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Managedzones$List, options?: MethodOptions): GaxiosPromise<Schema$ManagedZonesListResponse>;
+        list(params: Params$Resource$Managedzones$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Managedzones$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZonesListResponse>>;
         list(params: Params$Resource$Managedzones$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Managedzones$List, options: MethodOptions | BodyResponseCallback<Schema$ManagedZonesListResponse>, callback: BodyResponseCallback<Schema$ManagedZonesListResponse>): void;
         list(params: Params$Resource$Managedzones$List, callback: BodyResponseCallback<Schema$ManagedZonesListResponse>): void;
         list(callback: BodyResponseCallback<Schema$ManagedZonesListResponse>): void;
         /**
          * Applies a partial update to an existing ManagedZone.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.patch({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "cloudLoggingConfig": {},
+         *       //   "creationTime": "my_creationTime",
+         *       //   "description": "my_description",
+         *       //   "dnsName": "my_dnsName",
+         *       //   "dnssecConfig": {},
+         *       //   "forwardingConfig": {},
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "labels": {},
+         *       //   "name": "my_name",
+         *       //   "nameServerSet": "my_nameServerSet",
+         *       //   "nameServers": [],
+         *       //   "peeringConfig": {},
+         *       //   "privateVisibilityConfig": {},
+         *       //   "reverseLookupConfig": {},
+         *       //   "serviceDirectoryConfig": {},
+         *       //   "visibility": "my_visibility"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "dnsKeyContext": {},
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "startTime": "my_startTime",
+         *   //   "status": "my_status",
+         *   //   "type": "my_type",
+         *   //   "user": "my_user",
+         *   //   "zoneContext": {}
+         *   // }
+         * }
+         *
+         * 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.
          */
-        patch(params: Params$Resource$Managedzones$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        patch(params?: Params$Resource$Managedzones$Patch, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        patch(params: Params$Resource$Managedzones$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Managedzones$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         patch(params: Params$Resource$Managedzones$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         patch(params: Params$Resource$Managedzones$Patch, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         patch(params: Params$Resource$Managedzones$Patch, callback: BodyResponseCallback<Schema$Operation>): void;
         patch(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.setIamPolicy({
+         *     // REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
+         *     resource: 'projects/my-project/managedZones/my-managedZone',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "policy": {},
+         *       //   "updateMask": "my_updateMask"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "auditConfigs": [],
+         *   //   "bindings": [],
+         *   //   "etag": "my_etag",
+         *   //   "version": 0
+         *   // }
+         * }
+         *
+         * 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.
          */
-        setIamPolicy(params: Params$Resource$Managedzones$Setiampolicy, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        setIamPolicy(params?: Params$Resource$Managedzones$Setiampolicy, options?: MethodOptions): GaxiosPromise<Schema$GoogleIamV1Policy>;
+        setIamPolicy(params: Params$Resource$Managedzones$Setiampolicy, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        setIamPolicy(params?: Params$Resource$Managedzones$Setiampolicy, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>;
         setIamPolicy(params: Params$Resource$Managedzones$Setiampolicy, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         setIamPolicy(params: Params$Resource$Managedzones$Setiampolicy, options: MethodOptions | BodyResponseCallback<Schema$GoogleIamV1Policy>, callback: BodyResponseCallback<Schema$GoogleIamV1Policy>): void;
         setIamPolicy(params: Params$Resource$Managedzones$Setiampolicy, callback: BodyResponseCallback<Schema$GoogleIamV1Policy>): void;
         setIamPolicy(callback: BodyResponseCallback<Schema$GoogleIamV1Policy>): void;
         /**
          * Returns permissions that a caller has on the specified resource. If the resource does not exist, this returns an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.testIamPermissions({
+         *     // REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
+         *     resource: 'projects/my-project/managedZones/my-managedZone',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "permissions": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "permissions": []
+         *   // }
+         * }
+         *
+         * 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.
          */
-        testIamPermissions(params: Params$Resource$Managedzones$Testiampermissions, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        testIamPermissions(params?: Params$Resource$Managedzones$Testiampermissions, options?: MethodOptions): GaxiosPromise<Schema$GoogleIamV1TestIamPermissionsResponse>;
+        testIamPermissions(params: Params$Resource$Managedzones$Testiampermissions, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        testIamPermissions(params?: Params$Resource$Managedzones$Testiampermissions, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1TestIamPermissionsResponse>>;
         testIamPermissions(params: Params$Resource$Managedzones$Testiampermissions, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         testIamPermissions(params: Params$Resource$Managedzones$Testiampermissions, options: MethodOptions | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>, callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>): void;
         testIamPermissions(params: Params$Resource$Managedzones$Testiampermissions, callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>): void;
         testIamPermissions(callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>): void;
         /**
          * Updates an existing ManagedZone.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.managedZones.update({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "cloudLoggingConfig": {},
+         *       //   "creationTime": "my_creationTime",
+         *       //   "description": "my_description",
+         *       //   "dnsName": "my_dnsName",
+         *       //   "dnssecConfig": {},
+         *       //   "forwardingConfig": {},
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "labels": {},
+         *       //   "name": "my_name",
+         *       //   "nameServerSet": "my_nameServerSet",
+         *       //   "nameServers": [],
+         *       //   "peeringConfig": {},
+         *       //   "privateVisibilityConfig": {},
+         *       //   "reverseLookupConfig": {},
+         *       //   "serviceDirectoryConfig": {},
+         *       //   "visibility": "my_visibility"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "dnsKeyContext": {},
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "startTime": "my_startTime",
+         *   //   "status": "my_status",
+         *   //   "type": "my_type",
+         *   //   "user": "my_user",
+         *   //   "zoneContext": {}
+         *   // }
+         * }
+         *
+         * 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$Managedzones$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Managedzones$Update, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        update(params: Params$Resource$Managedzones$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Managedzones$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         update(params: Params$Resource$Managedzones$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Managedzones$Update, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         update(params: Params$Resource$Managedzones$Update, callback: BodyResponseCallback<Schema$Operation>): void;
@@ -1651,84 +2724,465 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a new Policy.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.policies.create({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "alternativeNameServerConfig": {},
+         *       //   "description": "my_description",
+         *       //   "dns64Config": {},
+         *       //   "enableInboundForwarding": false,
+         *       //   "enableLogging": false,
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "name": "my_name",
+         *       //   "networks": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "alternativeNameServerConfig": {},
+         *   //   "description": "my_description",
+         *   //   "dns64Config": {},
+         *   //   "enableInboundForwarding": false,
+         *   //   "enableLogging": false,
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "name": "my_name",
+         *   //   "networks": []
+         *   // }
+         * }
+         *
+         * 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$Policies$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Policies$Create, options?: MethodOptions): GaxiosPromise<Schema$Policy>;
+        create(params: Params$Resource$Policies$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Policies$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Policy>>;
         create(params: Params$Resource$Policies$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Policies$Create, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
         create(params: Params$Resource$Policies$Create, callback: BodyResponseCallback<Schema$Policy>): void;
         create(callback: BodyResponseCallback<Schema$Policy>): void;
         /**
          * Deletes a previously created Policy. Fails if the policy is still being referenced by a network.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.policies.delete({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // User given friendly name of the policy addressed by this request.
+         *     policy: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: '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$Policies$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Policies$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Policies$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Policies$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Policies$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Policies$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Policies$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Fetches the representation of an existing Policy.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.policies.get({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // User given friendly name of the policy addressed by this request.
+         *     policy: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "alternativeNameServerConfig": {},
+         *   //   "description": "my_description",
+         *   //   "dns64Config": {},
+         *   //   "enableInboundForwarding": false,
+         *   //   "enableLogging": false,
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "name": "my_name",
+         *   //   "networks": []
+         *   // }
+         * }
+         *
+         * 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$Policies$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Policies$Get, options?: MethodOptions): GaxiosPromise<Schema$Policy>;
+        get(params: Params$Resource$Policies$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Policies$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Policy>>;
         get(params: Params$Resource$Policies$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Policies$Get, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
         get(params: Params$Resource$Policies$Get, callback: BodyResponseCallback<Schema$Policy>): void;
         get(callback: BodyResponseCallback<Schema$Policy>): void;
         /**
          * Enumerates all Policies associated with a project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.policies.list({
+         *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+         *     maxResults: 'placeholder-value',
+         *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+         *     pageToken: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "kind": "my_kind",
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "policies": []
+         *   // }
+         * }
+         *
+         * 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$Policies$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Policies$List, options?: MethodOptions): GaxiosPromise<Schema$PoliciesListResponse>;
+        list(params: Params$Resource$Policies$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Policies$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$PoliciesListResponse>>;
         list(params: Params$Resource$Policies$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Policies$List, options: MethodOptions | BodyResponseCallback<Schema$PoliciesListResponse>, callback: BodyResponseCallback<Schema$PoliciesListResponse>): void;
         list(params: Params$Resource$Policies$List, callback: BodyResponseCallback<Schema$PoliciesListResponse>): void;
         list(callback: BodyResponseCallback<Schema$PoliciesListResponse>): void;
         /**
          * Applies a partial update to an existing Policy.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.policies.patch({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // User given friendly name of the policy addressed by this request.
+         *     policy: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "alternativeNameServerConfig": {},
+         *       //   "description": "my_description",
+         *       //   "dns64Config": {},
+         *       //   "enableInboundForwarding": false,
+         *       //   "enableLogging": false,
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "name": "my_name",
+         *       //   "networks": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "policy": {}
+         *   // }
+         * }
+         *
+         * 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.
          */
-        patch(params: Params$Resource$Policies$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        patch(params?: Params$Resource$Policies$Patch, options?: MethodOptions): GaxiosPromise<Schema$PoliciesPatchResponse>;
+        patch(params: Params$Resource$Policies$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Policies$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$PoliciesPatchResponse>>;
         patch(params: Params$Resource$Policies$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         patch(params: Params$Resource$Policies$Patch, options: MethodOptions | BodyResponseCallback<Schema$PoliciesPatchResponse>, callback: BodyResponseCallback<Schema$PoliciesPatchResponse>): void;
         patch(params: Params$Resource$Policies$Patch, callback: BodyResponseCallback<Schema$PoliciesPatchResponse>): void;
         patch(callback: BodyResponseCallback<Schema$PoliciesPatchResponse>): void;
         /**
          * Updates an existing Policy.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.policies.update({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // User given friendly name of the policy addressed by this request.
+         *     policy: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "alternativeNameServerConfig": {},
+         *       //   "description": "my_description",
+         *       //   "dns64Config": {},
+         *       //   "enableInboundForwarding": false,
+         *       //   "enableLogging": false,
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "name": "my_name",
+         *       //   "networks": []
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "policy": {}
+         *   // }
+         * }
+         *
+         * 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$Policies$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Policies$Update, options?: MethodOptions): GaxiosPromise<Schema$PoliciesUpdateResponse>;
+        update(params: Params$Resource$Policies$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Policies$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$PoliciesUpdateResponse>>;
         update(params: Params$Resource$Policies$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Policies$Update, options: MethodOptions | BodyResponseCallback<Schema$PoliciesUpdateResponse>, callback: BodyResponseCallback<Schema$PoliciesUpdateResponse>): void;
         update(params: Params$Resource$Policies$Update, callback: BodyResponseCallback<Schema$PoliciesUpdateResponse>): void;
@@ -1831,14 +3285,70 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Fetches the representation of an existing Project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.projects.get({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "number": "my_number",
+         *   //   "quota": {}
+         *   // }
+         * }
+         *
+         * 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$Projects$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Projects$Get, options?: MethodOptions): GaxiosPromise<Schema$Project>;
+        get(params: Params$Resource$Projects$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Projects$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Project>>;
         get(params: Params$Resource$Projects$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Projects$Get, options: MethodOptions | BodyResponseCallback<Schema$Project>, callback: BodyResponseCallback<Schema$Project>): void;
         get(params: Params$Resource$Projects$Get, callback: BodyResponseCallback<Schema$Project>): void;
@@ -1859,70 +3369,403 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a new ResourceRecordSet.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.resourceRecordSets.create({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "kind": "my_kind",
+         *       //   "name": "my_name",
+         *       //   "routingPolicy": {},
+         *       //   "rrdatas": [],
+         *       //   "signatureRrdatas": [],
+         *       //   "ttl": 0,
+         *       //   "type": "my_type"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "kind": "my_kind",
+         *   //   "name": "my_name",
+         *   //   "routingPolicy": {},
+         *   //   "rrdatas": [],
+         *   //   "signatureRrdatas": [],
+         *   //   "ttl": 0,
+         *   //   "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$Resourcerecordsets$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Resourcerecordsets$Create, options?: MethodOptions): GaxiosPromise<Schema$ResourceRecordSet>;
+        create(params: Params$Resource$Resourcerecordsets$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Resourcerecordsets$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResourceRecordSet>>;
         create(params: Params$Resource$Resourcerecordsets$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Resourcerecordsets$Create, options: MethodOptions | BodyResponseCallback<Schema$ResourceRecordSet>, callback: BodyResponseCallback<Schema$ResourceRecordSet>): void;
         create(params: Params$Resource$Resourcerecordsets$Create, callback: BodyResponseCallback<Schema$ResourceRecordSet>): void;
         create(callback: BodyResponseCallback<Schema$ResourceRecordSet>): void;
         /**
          * Deletes a previously created ResourceRecordSet.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.resourceRecordSets.delete({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Fully qualified domain name.
+         *     name: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // RRSet type.
+         *     type: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {}
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @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$Resourcerecordsets$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Resourcerecordsets$Delete, options?: MethodOptions): GaxiosPromise<Schema$ResourceRecordSetsDeleteResponse>;
+        delete(params: Params$Resource$Resourcerecordsets$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Resourcerecordsets$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResourceRecordSetsDeleteResponse>>;
         delete(params: Params$Resource$Resourcerecordsets$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Resourcerecordsets$Delete, options: MethodOptions | BodyResponseCallback<Schema$ResourceRecordSetsDeleteResponse>, callback: BodyResponseCallback<Schema$ResourceRecordSetsDeleteResponse>): void;
         delete(params: Params$Resource$Resourcerecordsets$Delete, callback: BodyResponseCallback<Schema$ResourceRecordSetsDeleteResponse>): void;
         delete(callback: BodyResponseCallback<Schema$ResourceRecordSetsDeleteResponse>): void;
         /**
          * Fetches the representation of an existing ResourceRecordSet.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.resourceRecordSets.get({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Fully qualified domain name.
+         *     name: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // RRSet type.
+         *     type: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "kind": "my_kind",
+         *   //   "name": "my_name",
+         *   //   "routingPolicy": {},
+         *   //   "rrdatas": [],
+         *   //   "signatureRrdatas": [],
+         *   //   "ttl": 0,
+         *   //   "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$Resourcerecordsets$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Resourcerecordsets$Get, options?: MethodOptions): GaxiosPromise<Schema$ResourceRecordSet>;
+        get(params: Params$Resource$Resourcerecordsets$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Resourcerecordsets$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResourceRecordSet>>;
         get(params: Params$Resource$Resourcerecordsets$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Resourcerecordsets$Get, options: MethodOptions | BodyResponseCallback<Schema$ResourceRecordSet>, callback: BodyResponseCallback<Schema$ResourceRecordSet>): void;
         get(params: Params$Resource$Resourcerecordsets$Get, callback: BodyResponseCallback<Schema$ResourceRecordSet>): void;
         get(callback: BodyResponseCallback<Schema$ResourceRecordSet>): void;
         /**
          * Enumerates ResourceRecordSets that you have created but not yet deleted.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.resourceRecordSets.list({
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+         *     maxResults: 'placeholder-value',
+         *     // Restricts the list to return only records with this fully qualified domain name.
+         *     name: 'placeholder-value',
+         *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+         *     pageToken: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // Restricts the list to return only records of this type. If present, the "name" parameter must also be present.
+         *     type: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "kind": "my_kind",
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "rrsets": []
+         *   // }
+         * }
+         *
+         * 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$Resourcerecordsets$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Resourcerecordsets$List, options?: MethodOptions): GaxiosPromise<Schema$ResourceRecordSetsListResponse>;
+        list(params: Params$Resource$Resourcerecordsets$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Resourcerecordsets$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResourceRecordSetsListResponse>>;
         list(params: Params$Resource$Resourcerecordsets$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Resourcerecordsets$List, options: MethodOptions | BodyResponseCallback<Schema$ResourceRecordSetsListResponse>, callback: BodyResponseCallback<Schema$ResourceRecordSetsListResponse>): void;
         list(params: Params$Resource$Resourcerecordsets$List, callback: BodyResponseCallback<Schema$ResourceRecordSetsListResponse>): void;
         list(callback: BodyResponseCallback<Schema$ResourceRecordSetsListResponse>): void;
         /**
          * Applies a partial update to an existing ResourceRecordSet.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.resourceRecordSets.patch({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+         *     managedZone: 'placeholder-value',
+         *     // Fully qualified domain name.
+         *     name: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // RRSet type.
+         *     type: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "kind": "my_kind",
+         *       //   "name": "my_name",
+         *       //   "routingPolicy": {},
+         *       //   "rrdatas": [],
+         *       //   "signatureRrdatas": [],
+         *       //   "ttl": 0,
+         *       //   "type": "my_type"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "kind": "my_kind",
+         *   //   "name": "my_name",
+         *   //   "routingPolicy": {},
+         *   //   "rrdatas": [],
+         *   //   "signatureRrdatas": [],
+         *   //   "ttl": 0,
+         *   //   "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.
          */
-        patch(params: Params$Resource$Resourcerecordsets$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        patch(params?: Params$Resource$Resourcerecordsets$Patch, options?: MethodOptions): GaxiosPromise<Schema$ResourceRecordSet>;
+        patch(params: Params$Resource$Resourcerecordsets$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Resourcerecordsets$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResourceRecordSet>>;
         patch(params: Params$Resource$Resourcerecordsets$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         patch(params: Params$Resource$Resourcerecordsets$Patch, options: MethodOptions | BodyResponseCallback<Schema$ResourceRecordSet>, callback: BodyResponseCallback<Schema$ResourceRecordSet>): void;
         patch(params: Params$Resource$Resourcerecordsets$Patch, callback: BodyResponseCallback<Schema$ResourceRecordSet>): void;
@@ -2047,84 +3890,454 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a new Response Policy
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicies.create({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "description": "my_description",
+         *       //   "gkeClusters": [],
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "labels": {},
+         *       //   "networks": [],
+         *       //   "responsePolicyName": "my_responsePolicyName"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "description": "my_description",
+         *   //   "gkeClusters": [],
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "labels": {},
+         *   //   "networks": [],
+         *   //   "responsePolicyName": "my_responsePolicyName"
+         *   // }
+         * }
+         *
+         * 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$Responsepolicies$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Responsepolicies$Create, options?: MethodOptions): GaxiosPromise<Schema$ResponsePolicy>;
+        create(params: Params$Resource$Responsepolicies$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Responsepolicies$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePolicy>>;
         create(params: Params$Resource$Responsepolicies$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Responsepolicies$Create, options: MethodOptions | BodyResponseCallback<Schema$ResponsePolicy>, callback: BodyResponseCallback<Schema$ResponsePolicy>): void;
         create(params: Params$Resource$Responsepolicies$Create, callback: BodyResponseCallback<Schema$ResponsePolicy>): void;
         create(callback: BodyResponseCallback<Schema$ResponsePolicy>): void;
         /**
          * Deletes a previously created Response Policy. Fails if the response policy is non-empty or still being referenced by a network.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicies.delete({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy addressed by this request.
+         *     responsePolicy: '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$Responsepolicies$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Responsepolicies$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Responsepolicies$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Responsepolicies$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Responsepolicies$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Responsepolicies$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Responsepolicies$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Fetches the representation of an existing Response Policy.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicies.get({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy addressed by this request.
+         *     responsePolicy: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "description": "my_description",
+         *   //   "gkeClusters": [],
+         *   //   "id": "my_id",
+         *   //   "kind": "my_kind",
+         *   //   "labels": {},
+         *   //   "networks": [],
+         *   //   "responsePolicyName": "my_responsePolicyName"
+         *   // }
+         * }
+         *
+         * 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$Responsepolicies$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Responsepolicies$Get, options?: MethodOptions): GaxiosPromise<Schema$ResponsePolicy>;
+        get(params: Params$Resource$Responsepolicies$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Responsepolicies$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePolicy>>;
         get(params: Params$Resource$Responsepolicies$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Responsepolicies$Get, options: MethodOptions | BodyResponseCallback<Schema$ResponsePolicy>, callback: BodyResponseCallback<Schema$ResponsePolicy>): void;
         get(params: Params$Resource$Responsepolicies$Get, callback: BodyResponseCallback<Schema$ResponsePolicy>): void;
         get(callback: BodyResponseCallback<Schema$ResponsePolicy>): void;
         /**
          * Enumerates all Response Policies associated with a project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicies.list({
+         *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+         *     maxResults: 'placeholder-value',
+         *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+         *     pageToken: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "responsePolicies": []
+         *   // }
+         * }
+         *
+         * 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$Responsepolicies$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Responsepolicies$List, options?: MethodOptions): GaxiosPromise<Schema$ResponsePoliciesListResponse>;
+        list(params: Params$Resource$Responsepolicies$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Responsepolicies$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePoliciesListResponse>>;
         list(params: Params$Resource$Responsepolicies$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Responsepolicies$List, options: MethodOptions | BodyResponseCallback<Schema$ResponsePoliciesListResponse>, callback: BodyResponseCallback<Schema$ResponsePoliciesListResponse>): void;
         list(params: Params$Resource$Responsepolicies$List, callback: BodyResponseCallback<Schema$ResponsePoliciesListResponse>): void;
         list(callback: BodyResponseCallback<Schema$ResponsePoliciesListResponse>): void;
         /**
          * Applies a partial update to an existing Response Policy.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicies.patch({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the response policy addressed by this request.
+         *     responsePolicy: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "description": "my_description",
+         *       //   "gkeClusters": [],
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "labels": {},
+         *       //   "networks": [],
+         *       //   "responsePolicyName": "my_responsePolicyName"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "responsePolicy": {}
+         *   // }
+         * }
+         *
+         * 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.
          */
-        patch(params: Params$Resource$Responsepolicies$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        patch(params?: Params$Resource$Responsepolicies$Patch, options?: MethodOptions): GaxiosPromise<Schema$ResponsePoliciesPatchResponse>;
+        patch(params: Params$Resource$Responsepolicies$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Responsepolicies$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePoliciesPatchResponse>>;
         patch(params: Params$Resource$Responsepolicies$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         patch(params: Params$Resource$Responsepolicies$Patch, options: MethodOptions | BodyResponseCallback<Schema$ResponsePoliciesPatchResponse>, callback: BodyResponseCallback<Schema$ResponsePoliciesPatchResponse>): void;
         patch(params: Params$Resource$Responsepolicies$Patch, callback: BodyResponseCallback<Schema$ResponsePoliciesPatchResponse>): void;
         patch(callback: BodyResponseCallback<Schema$ResponsePoliciesPatchResponse>): void;
         /**
          * Updates an existing Response Policy.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicies.update({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy addressed by this request.
+         *     responsePolicy: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "description": "my_description",
+         *       //   "gkeClusters": [],
+         *       //   "id": "my_id",
+         *       //   "kind": "my_kind",
+         *       //   "labels": {},
+         *       //   "networks": [],
+         *       //   "responsePolicyName": "my_responsePolicyName"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "responsePolicy": {}
+         *   // }
+         * }
+         *
+         * 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$Responsepolicies$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Responsepolicies$Update, options?: MethodOptions): GaxiosPromise<Schema$ResponsePoliciesUpdateResponse>;
+        update(params: Params$Resource$Responsepolicies$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Responsepolicies$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePoliciesUpdateResponse>>;
         update(params: Params$Resource$Responsepolicies$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Responsepolicies$Update, options: MethodOptions | BodyResponseCallback<Schema$ResponsePoliciesUpdateResponse>, callback: BodyResponseCallback<Schema$ResponsePoliciesUpdateResponse>): void;
         update(params: Params$Resource$Responsepolicies$Update, callback: BodyResponseCallback<Schema$ResponsePoliciesUpdateResponse>): void;
@@ -2227,84 +4440,456 @@ export declare namespace dns_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a new Response Policy Rule.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicyRules.create({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy containing the Response Policy Rule.
+         *     responsePolicy: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "behavior": "my_behavior",
+         *       //   "dnsName": "my_dnsName",
+         *       //   "kind": "my_kind",
+         *       //   "localData": {},
+         *       //   "ruleName": "my_ruleName"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "behavior": "my_behavior",
+         *   //   "dnsName": "my_dnsName",
+         *   //   "kind": "my_kind",
+         *   //   "localData": {},
+         *   //   "ruleName": "my_ruleName"
+         *   // }
+         * }
+         *
+         * 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$Responsepolicyrules$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Responsepolicyrules$Create, options?: MethodOptions): GaxiosPromise<Schema$ResponsePolicyRule>;
+        create(params: Params$Resource$Responsepolicyrules$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Responsepolicyrules$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePolicyRule>>;
         create(params: Params$Resource$Responsepolicyrules$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Responsepolicyrules$Create, options: MethodOptions | BodyResponseCallback<Schema$ResponsePolicyRule>, callback: BodyResponseCallback<Schema$ResponsePolicyRule>): void;
         create(params: Params$Resource$Responsepolicyrules$Create, callback: BodyResponseCallback<Schema$ResponsePolicyRule>): void;
         create(callback: BodyResponseCallback<Schema$ResponsePolicyRule>): void;
         /**
          * Deletes a previously created Response Policy Rule.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicyRules.delete({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy containing the Response Policy Rule.
+         *     responsePolicy: 'placeholder-value',
+         *     // User assigned name of the Response Policy Rule addressed by this request.
+         *     responsePolicyRule: '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$Responsepolicyrules$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Responsepolicyrules$Delete, options?: MethodOptions): GaxiosPromise<void>;
+        delete(params: Params$Resource$Responsepolicyrules$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Responsepolicyrules$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<void>>;
         delete(params: Params$Resource$Responsepolicyrules$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Responsepolicyrules$Delete, options: MethodOptions | BodyResponseCallback<void>, callback: BodyResponseCallback<void>): void;
         delete(params: Params$Resource$Responsepolicyrules$Delete, callback: BodyResponseCallback<void>): void;
         delete(callback: BodyResponseCallback<void>): void;
         /**
          * Fetches the representation of an existing Response Policy Rule.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicyRules.get({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy containing the Response Policy Rule.
+         *     responsePolicy: 'placeholder-value',
+         *     // User assigned name of the Response Policy Rule addressed by this request.
+         *     responsePolicyRule: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "behavior": "my_behavior",
+         *   //   "dnsName": "my_dnsName",
+         *   //   "kind": "my_kind",
+         *   //   "localData": {},
+         *   //   "ruleName": "my_ruleName"
+         *   // }
+         * }
+         *
+         * 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$Responsepolicyrules$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Responsepolicyrules$Get, options?: MethodOptions): GaxiosPromise<Schema$ResponsePolicyRule>;
+        get(params: Params$Resource$Responsepolicyrules$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Responsepolicyrules$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePolicyRule>>;
         get(params: Params$Resource$Responsepolicyrules$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Responsepolicyrules$Get, options: MethodOptions | BodyResponseCallback<Schema$ResponsePolicyRule>, callback: BodyResponseCallback<Schema$ResponsePolicyRule>): void;
         get(params: Params$Resource$Responsepolicyrules$Get, callback: BodyResponseCallback<Schema$ResponsePolicyRule>): void;
         get(callback: BodyResponseCallback<Schema$ResponsePolicyRule>): void;
         /**
          * Enumerates all Response Policy Rules associated with a project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicyRules.list({
+         *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+         *     maxResults: 'placeholder-value',
+         *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+         *     pageToken: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy to list.
+         *     responsePolicy: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "responsePolicyRules": []
+         *   // }
+         * }
+         *
+         * 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$Responsepolicyrules$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Responsepolicyrules$List, options?: MethodOptions): GaxiosPromise<Schema$ResponsePolicyRulesListResponse>;
+        list(params: Params$Resource$Responsepolicyrules$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Responsepolicyrules$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePolicyRulesListResponse>>;
         list(params: Params$Resource$Responsepolicyrules$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Responsepolicyrules$List, options: MethodOptions | BodyResponseCallback<Schema$ResponsePolicyRulesListResponse>, callback: BodyResponseCallback<Schema$ResponsePolicyRulesListResponse>): void;
         list(params: Params$Resource$Responsepolicyrules$List, callback: BodyResponseCallback<Schema$ResponsePolicyRulesListResponse>): void;
         list(callback: BodyResponseCallback<Schema$ResponsePolicyRulesListResponse>): void;
         /**
          * Applies a partial update to an existing Response Policy Rule.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicyRules.patch({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy containing the Response Policy Rule.
+         *     responsePolicy: 'placeholder-value',
+         *     // User assigned name of the Response Policy Rule addressed by this request.
+         *     responsePolicyRule: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "behavior": "my_behavior",
+         *       //   "dnsName": "my_dnsName",
+         *       //   "kind": "my_kind",
+         *       //   "localData": {},
+         *       //   "ruleName": "my_ruleName"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "responsePolicyRule": {}
+         *   // }
+         * }
+         *
+         * 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.
          */
-        patch(params: Params$Resource$Responsepolicyrules$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        patch(params?: Params$Resource$Responsepolicyrules$Patch, options?: MethodOptions): GaxiosPromise<Schema$ResponsePolicyRulesPatchResponse>;
+        patch(params: Params$Resource$Responsepolicyrules$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Responsepolicyrules$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePolicyRulesPatchResponse>>;
         patch(params: Params$Resource$Responsepolicyrules$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         patch(params: Params$Resource$Responsepolicyrules$Patch, options: MethodOptions | BodyResponseCallback<Schema$ResponsePolicyRulesPatchResponse>, callback: BodyResponseCallback<Schema$ResponsePolicyRulesPatchResponse>): void;
         patch(params: Params$Resource$Responsepolicyrules$Patch, callback: BodyResponseCallback<Schema$ResponsePolicyRulesPatchResponse>): void;
         patch(callback: BodyResponseCallback<Schema$ResponsePolicyRulesPatchResponse>): void;
         /**
          * Updates an existing Response Policy Rule.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.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 dns = google.dns('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+         *     ],
+         *   });
+         *
+         *   // 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 dns.responsePolicyRules.update({
+         *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+         *     clientOperationId: 'placeholder-value',
+         *     // Identifies the project addressed by this request.
+         *     project: 'placeholder-value',
+         *     // User assigned name of the Response Policy containing the Response Policy Rule.
+         *     responsePolicy: 'placeholder-value',
+         *     // User assigned name of the Response Policy Rule addressed by this request.
+         *     responsePolicyRule: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "behavior": "my_behavior",
+         *       //   "dnsName": "my_dnsName",
+         *       //   "kind": "my_kind",
+         *       //   "localData": {},
+         *       //   "ruleName": "my_ruleName"
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "responsePolicyRule": {}
+         *   // }
+         * }
+         *
+         * 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$Responsepolicyrules$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Responsepolicyrules$Update, options?: MethodOptions): GaxiosPromise<Schema$ResponsePolicyRulesUpdateResponse>;
+        update(params: Params$Resource$Responsepolicyrules$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Responsepolicyrules$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResponsePolicyRulesUpdateResponse>>;
         update(params: Params$Resource$Responsepolicyrules$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Responsepolicyrules$Update, options: MethodOptions | BodyResponseCallback<Schema$ResponsePolicyRulesUpdateResponse>, callback: BodyResponseCallback<Schema$ResponsePolicyRulesUpdateResponse>): void;
         update(params: Params$Resource$Responsepolicyrules$Update, callback: BodyResponseCallback<Schema$ResponsePolicyRulesUpdateResponse>): void;