@googleapis/dns 7.0.1 → 9.0.0

package/build/v1.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
 import { Readable } from 'stream';
 export declare namespace dns_v1 {
@@ -1139,6 +1138,79 @@ 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`.
@@ -1153,6 +1225,69 @@ export declare namespace dns_v1 {
         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`.
@@ -1167,6 +1302,69 @@ export declare namespace dns_v1 {
         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`.
@@ -1247,6 +1445,75 @@ 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`.
@@ -1261,6 +1528,67 @@ export declare namespace dns_v1 {
         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`.
@@ -1323,6 +1651,70 @@ 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`.
@@ -1337,6 +1729,67 @@ export declare namespace dns_v1 {
         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`.
@@ -1395,6 +1848,97 @@ 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`.
@@ -1409,6 +1953,54 @@ export declare namespace dns_v1 {
         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`.
@@ -1423,6 +2015,77 @@ export declare namespace dns_v1 {
         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`.
@@ -1437,6 +2100,68 @@ export declare namespace dns_v1 {
         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`.
@@ -1451,6 +2176,65 @@ export declare namespace dns_v1 {
         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`.
@@ -1465,6 +2249,90 @@ export declare namespace dns_v1 {
         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`.
@@ -1479,6 +2347,67 @@ export declare namespace dns_v1 {
         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`.
@@ -1493,6 +2422,65 @@ export declare namespace dns_v1 {
         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`.
@@ -1507,6 +2495,90 @@ export declare namespace dns_v1 {
         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`.
@@ -1651,6 +2723,81 @@ 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`.
@@ -1665,6 +2812,54 @@ export declare namespace dns_v1 {
         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`.
@@ -1679,6 +2874,69 @@ export declare namespace dns_v1 {
         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`.
@@ -1693,6 +2951,63 @@ export declare namespace dns_v1 {
         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`.
@@ -1707,6 +3022,75 @@ export declare namespace dns_v1 {
         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`.
@@ -1721,6 +3105,75 @@ export declare namespace dns_v1 {
         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`.
@@ -1831,6 +3284,62 @@ 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`.
@@ -1859,6 +3368,79 @@ 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`.
@@ -1873,6 +3455,61 @@ export declare namespace dns_v1 {
         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`.
@@ -1887,6 +3524,71 @@ export declare namespace dns_v1 {
         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`.
@@ -1901,6 +3603,69 @@ export declare namespace dns_v1 {
         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`.
@@ -1915,6 +3680,83 @@ export declare namespace dns_v1 {
         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`.
@@ -2047,6 +3889,77 @@ 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`.
@@ -2061,6 +3974,54 @@ export declare namespace dns_v1 {
         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`.
@@ -2075,6 +4036,67 @@ export declare namespace dns_v1 {
         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`.
@@ -2089,6 +4111,62 @@ export declare namespace dns_v1 {
         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`.
@@ -2103,6 +4181,73 @@ export declare namespace dns_v1 {
         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`.
@@ -2117,6 +4262,73 @@ export declare namespace dns_v1 {
         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`.
@@ -2227,6 +4439,75 @@ 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`.
@@ -2241,6 +4522,56 @@ export declare namespace dns_v1 {
         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`.
@@ -2255,6 +4586,67 @@ export declare namespace dns_v1 {
         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`.
@@ -2269,6 +4661,64 @@ export declare namespace dns_v1 {
         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`.
@@ -2283,6 +4733,73 @@ export declare namespace dns_v1 {
         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`.
@@ -2297,6 +4814,73 @@ export declare namespace dns_v1 {
         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`.