@googleapis/dns 17.0.0 → 17.2.0

package/v1beta2.ts

@@ -114,8 +114,11 @@ export namespace dns_v1beta2 {
     context: APIRequestContext;
     changes: Resource$Changes;
     dnsKeys: Resource$Dnskeys;
+    locations: Resource$Locations;
     managedZoneOperations: Resource$Managedzoneoperations;
     managedZones: Resource$Managedzones;
+    operations: Resource$Operations;
+    outboundEndpoints: Resource$Outboundendpoints;
     policies: Resource$Policies;
     projects: Resource$Projects;
     resourceRecordSets: Resource$Resourcerecordsets;
@@ -130,10 +133,13 @@ export namespace dns_v1beta2 {
 
       this.changes = new Resource$Changes(this.context);
       this.dnsKeys = new Resource$Dnskeys(this.context);
+      this.locations = new Resource$Locations(this.context);
       this.managedZoneOperations = new Resource$Managedzoneoperations(
         this.context
       );
       this.managedZones = new Resource$Managedzones(this.context);
+      this.operations = new Resource$Operations(this.context);
+      this.outboundEndpoints = new Resource$Outboundendpoints(this.context);
       this.policies = new Resource$Policies(this.context);
       this.projects = new Resource$Projects(this.context);
       this.resourceRecordSets = new Resource$Resourcerecordsets(this.context);
@@ -280,6 +286,10 @@ export namespace dns_v1beta2 {
     keyType?: string | null;
     kind?: string | null;
   }
+  /**
+   * A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); \}
+   */
+  export interface Schema$Empty {}
   /**
    * Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.
    */
@@ -414,6 +424,23 @@ export namespace dns_v1beta2 {
      */
     permissions?: string[] | null;
   }
+  /**
+   * The response message for Operations.ListOperations.
+   */
+  export interface Schema$GoogleLongrunningListOperationsResponse {
+    /**
+     * The standard List next-page token.
+     */
+    nextPageToken?: string | null;
+    /**
+     * A list of operations that matches the specified filter in the request.
+     */
+    operations?: Schema$GoogleLongrunningOperation[];
+    /**
+     * Unordered list. Unreachable resources. Populated when the request sets `ListOperationsRequest.return_partial_success` and reads across collections. For example, when attempting to list all resources across all supported locations.
+     */
+    unreachable?: string[] | null;
+  }
   /**
    * This resource represents a long-running operation that is the result of a network API call.
    */
@@ -439,6 +466,61 @@ export namespace dns_v1beta2 {
      */
     response?: {[key: string]: any} | null;
   }
+  /**
+   * The response message for Locations.ListLocations.
+   */
+  export interface Schema$ListLocationsResponse {
+    /**
+     * A list of locations that matches the specified filter in the request.
+     */
+    locations?: Schema$Location[];
+    /**
+     * The standard List next-page token.
+     */
+    nextPageToken?: string | null;
+  }
+  /**
+   * Response message for OutboundEndpointsService.ListOutboundEndpoints
+   */
+  export interface Schema$ListOutboundEndpointsResponse {
+    /**
+     * A token to retrieve the next page of results. Set to empty if there are no remaining results.
+     */
+    nextPageToken?: string | null;
+    /**
+     * The list of OutboundEndpoints.
+     */
+    outboundEndpoints?: Schema$OutboundEndpoint[];
+    /**
+     * Unordered list. The resource names of the unreachable locations. Format: `projects/{project\}/locations/{location\}`
+     */
+    unreachable?: string[] | null;
+  }
+  /**
+   * A resource that represents a Google Cloud location.
+   */
+  export interface Schema$Location {
+    /**
+     * The friendly name for this location, typically a nearby city name. For example, "Tokyo".
+     */
+    displayName?: string | null;
+    /**
+     * Cross-service attributes for the location. For example {"cloud.googleapis.com/region": "us-east1"\}
+     */
+    labels?: {[key: string]: string} | null;
+    /**
+     * The canonical id for this location. For example: `"us-east1"`.
+     */
+    locationId?: string | null;
+    /**
+     * Service-specific metadata. For example the available capacity at the given location.
+     */
+    metadata?: {[key: string]: any} | null;
+    /**
+     * Resource name for the location, which may vary between implementations. For example: `"projects/example-project/locations/us-east1"`
+     */
+    name?: string | null;
+  }
   /**
    * A zone is a subtree of the DNS namespace under one administrative responsibility. A ManagedZone is a resource that represents a DNS zone hosted by the Cloud DNS service.
    */
@@ -533,6 +615,10 @@ export namespace dns_v1beta2 {
   }
   export interface Schema$ManagedZoneForwardingConfig {
     kind?: string | null;
+    /**
+     * The list of outbound endpoints to use for queries.
+     */
+    outboundEndpoints?: Schema$ManagedZoneForwardingConfigOutboundEndpoint[];
     /**
      * List of target name servers to forward to. Cloud DNS selects the best available name server if more than one target is given.
      */
@@ -557,6 +643,13 @@ export namespace dns_v1beta2 {
     ipv6Address?: string | null;
     kind?: string | null;
   }
+  export interface Schema$ManagedZoneForwardingConfigOutboundEndpoint {
+    kind?: string | null;
+    /**
+     * Specified as a resource path including project and region. This should be formatted like projects/{project\}/locations/{location\}/outboundEndpoints/{endpoint\}
+     */
+    name?: string | null;
+  }
   export interface Schema$ManagedZoneOperationsListResponse {
     /**
      * Output only. Type of resource.
@@ -706,6 +799,84 @@ export namespace dns_v1beta2 {
      */
     oldValue?: Schema$ManagedZone;
   }
+  /**
+   * Represents the metadata of the long-running operation.
+   */
+  export interface Schema$OperationMetadata {
+    /**
+     * Output only. API version used to start the operation.
+     */
+    apiVersion?: string | null;
+    /**
+     * Output only. The time the operation was created.
+     */
+    createTime?: string | null;
+    /**
+     * Output only. The time the operation finished running.
+     */
+    endTime?: string | null;
+    /**
+     * Output only. Identifies whether the user has requested cancellation of the operation. Operations that have successfully been cancelled have Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.
+     */
+    requestedCancellation?: boolean | null;
+    /**
+     * Output only. Human-readable status of the operation, if any.
+     */
+    statusMessage?: string | null;
+    /**
+     * Output only. Server-defined resource path for the target of the operation.
+     */
+    target?: string | null;
+    /**
+     * Output only. Name of the verb executed by the operation.
+     */
+    verb?: string | null;
+  }
+  /**
+   * An OutboundEndpoint is a regional resource to enable outbound forwarding from a private IP range in VPCs to on-premise or other networks.
+   */
+  export interface Schema$OutboundEndpoint {
+    /**
+     * Optional. Annotations as key value pairs
+     */
+    annotations?: {[key: string]: string} | null;
+    /**
+     * Output only. [Output only] Create time stamp
+     */
+    createTime?: string | null;
+    /**
+     * Optional. User provided description.
+     */
+    description?: string | null;
+    /**
+     * Required. Immutable. User provided IP address to use for outbound DNS forwarding. This address must be a free address on the subnetwork.
+     */
+    endpointIp?: string | null;
+    /**
+     * Optional. Labels as key value pairs
+     */
+    labels?: {[key: string]: string} | null;
+    /**
+     * Identifier. The resource name of the OutboundEndpoint. Format: `projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}`
+     */
+    name?: string | null;
+    /**
+     * Required. Immutable. The VPC network containing the outbound endpoint, specified as full path.
+     */
+    network?: string | null;
+    /**
+     * Required. Immutable. The subnetwork holding the endpoint_ip, specified as full path.
+     */
+    subnetwork?: string | null;
+    /**
+     * Optional. Tag bindings as key value pairs
+     */
+    tags?: {[key: string]: string} | null;
+    /**
+     * Output only. [Output only] Update time stamp
+     */
+    updateTime?: string | null;
+  }
   export interface Schema$PoliciesListResponse {
     /**
      * Output only. Type of resource.
@@ -766,11 +937,22 @@ export namespace dns_v1beta2 {
   }
   export interface Schema$PolicyAlternativeNameServerConfig {
     kind?: string | null;
+    /**
+     * The list of outbound endpoints to use for queries.
+     */
+    outboundEndpoints?: Schema$PolicyAlternativeNameServerConfigOutboundEndpoint[];
     /**
      * Sets an alternative name server for the associated networks. When specified, all DNS queries are forwarded to a name server that you choose. Names such as .internal are not available when an alternative name server is specified.
      */
     targetNameServers?: Schema$PolicyAlternativeNameServerConfigTargetNameServer[];
   }
+  export interface Schema$PolicyAlternativeNameServerConfigOutboundEndpoint {
+    kind?: string | null;
+    /**
+     * Specified as a resource path including project and region. This should be formatted like projects/{project\}/locations/{location\}/outboundEndpoints/{endpoint\}
+     */
+    name?: string | null;
+  }
   export interface Schema$PolicyAlternativeNameServerConfigTargetNameServer {
     /**
      * Forwarding path for this TargetNameServer. If unset or set to DEFAULT, Cloud DNS makes forwarding decisions based on address ranges; that is, RFC1918 addresses go to the VPC network, non-RFC1918 addresses go to the internet. When set to PRIVATE, Cloud DNS always sends queries through the VPC network for this target.
@@ -882,6 +1064,14 @@ export namespace dns_v1beta2 {
      * Maximum allowed number of networks per response policy.
      */
     networksPerResponsePolicy?: number | null;
+    /**
+     * Maximum allowed number of outbound endpoints per managed zone.
+     */
+    outboundEndpointsPerManagedZone?: number | null;
+    /**
+     * Maximum allowed number of outbound endpoints per policy.
+     */
+    outboundEndpointsPerPolicy?: number | null;
     /**
      * Maximum allowed number of consumer peering zones per target network owned by this producer project
      */
@@ -2132,14 +2322,14 @@ export namespace dns_v1beta2 {
     project?: string;
   }
 
-  export class Resource$Managedzoneoperations {
+  export class Resource$Locations {
     context: APIRequestContext;
     constructor(context: APIRequestContext) {
       this.context = context;
     }
 
     /**
-     * Fetches the representation of an existing Operation.
+     * Gets information about a location.
      * @example
      * ```js
      * // Before running the sample:
@@ -2173,28 +2363,19 @@ export namespace dns_v1beta2 {
      *   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',
+     *   const res = await dns.locations.get({
+     *     // Resource name for the location.
+     *     name: 'projects/my-project/locations/my-location',
      *   });
      *   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": {}
+     *   //   "displayName": "my_displayName",
+     *   //   "labels": {},
+     *   //   "locationId": "my_locationId",
+     *   //   "metadata": {},
+     *   //   "name": "my_name"
      *   // }
      * }
      *
@@ -2211,51 +2392,50 @@ export namespace dns_v1beta2 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     get(
-      params: Params$Resource$Managedzoneoperations$Get,
+      params: Params$Resource$Locations$Get,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
     get(
-      params?: Params$Resource$Managedzoneoperations$Get,
+      params?: Params$Resource$Locations$Get,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
+    ): Promise<GaxiosResponseWithHTTP2<Schema$Location>>;
     get(
-      params: Params$Resource$Managedzoneoperations$Get,
+      params: Params$Resource$Locations$Get,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     get(
-      params: Params$Resource$Managedzoneoperations$Get,
-      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
-      callback: BodyResponseCallback<Schema$Operation>
+      params: Params$Resource$Locations$Get,
+      options: MethodOptions | BodyResponseCallback<Schema$Location>,
+      callback: BodyResponseCallback<Schema$Location>
     ): void;
     get(
-      params: Params$Resource$Managedzoneoperations$Get,
-      callback: BodyResponseCallback<Schema$Operation>
+      params: Params$Resource$Locations$Get,
+      callback: BodyResponseCallback<Schema$Location>
     ): void;
-    get(callback: BodyResponseCallback<Schema$Operation>): void;
+    get(callback: BodyResponseCallback<Schema$Location>): void;
     get(
       paramsOrCallback?:
-        | Params$Resource$Managedzoneoperations$Get
-        | BodyResponseCallback<Schema$Operation>
+        | Params$Resource$Locations$Get
+        | BodyResponseCallback<Schema$Location>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Schema$Location>
         | BodyResponseCallback<Readable>,
       callback?:
-        BodyResponseCallback<Schema$Operation> | BodyResponseCallback<Readable>
+        BodyResponseCallback<Schema$Location> | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<Schema$Operation>>
+      | Promise<GaxiosResponseWithHTTP2<Schema$Location>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
-      let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzoneoperations$Get;
+      let params = (paramsOrCallback || {}) as Params$Resource$Locations$Get;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzoneoperations$Get;
+        params = {} as Params$Resource$Locations$Get;
         options = {};
       }
 
@@ -2268,32 +2448,32 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl +
-              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}/operations/{operation}'
-            ).replace(/([^:]\/)\/+/g, '$1'),
+            url: (rootUrl + '/dns/v1beta2/{+name}').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
             method: 'GET',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['project', 'managedZone', 'operation'],
-        pathParams: ['managedZone', 'operation', 'project'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$Operation>(
+        createAPIRequest<Schema$Location>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$Operation>(parameters);
+        return createAPIRequest<Schema$Location>(parameters);
       }
     }
 
     /**
-     * Enumerates Operations for the given ManagedZone.
+     * Lists information about the supported locations for this service. This method lists locations based on the resource scope provided in the ListLocationsRequest.name field: * **Global locations**: If `name` is empty, the method lists the public locations available to all projects. * **Project-specific locations**: If `name` follows the format `projects/{project\}`, the method lists locations visible to that specific project. This includes public, private, or other project-specific locations enabled for the project. For gRPC and client library implementations, the resource name is passed as the `name` field. For direct service calls, the resource name is incorporated into the request path based on the specific service implementation and version.
      * @example
      * ```js
      * // Before running the sample:
@@ -2327,25 +2507,24 @@ export namespace dns_v1beta2 {
      *   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.
+     *   const res = await dns.locations.list({
+     *     // Optional. Do not use this field unless explicitly documented otherwise. This is primarily for internal usage.
+     *     extraLocationTypes: 'placeholder-value',
+     *     // A filter to narrow down results to a preferred subset. The filtering language accepts strings like `"displayName=tokyo"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160).
+     *     filter: 'placeholder-value',
+     *     // The resource that owns the locations collection, if applicable.
+     *     name: 'projects/my-project',
+     *     // The maximum number of results to return. If not set, the service selects a default.
+     *     pageSize: 'placeholder-value',
+     *     // A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.
      *     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": []
+     *   //   "locations": [],
+     *   //   "nextPageToken": "my_nextPageToken"
      *   // }
      * }
      *
@@ -2362,60 +2541,52 @@ export namespace dns_v1beta2 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     list(
-      params: Params$Resource$Managedzoneoperations$List,
+      params: Params$Resource$Locations$List,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
     list(
-      params?: Params$Resource$Managedzoneoperations$List,
+      params?: Params$Resource$Locations$List,
       options?: MethodOptions
-    ): Promise<
-      GaxiosResponseWithHTTP2<Schema$ManagedZoneOperationsListResponse>
-    >;
+    ): Promise<GaxiosResponseWithHTTP2<Schema$ListLocationsResponse>>;
     list(
-      params: Params$Resource$Managedzoneoperations$List,
+      params: Params$Resource$Locations$List,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     list(
-      params: Params$Resource$Managedzoneoperations$List,
+      params: Params$Resource$Locations$List,
       options:
-        | MethodOptions
-        | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>,
-      callback: BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
-    ): void;
-    list(
-      params: Params$Resource$Managedzoneoperations$List,
-      callback: BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+        MethodOptions | BodyResponseCallback<Schema$ListLocationsResponse>,
+      callback: BodyResponseCallback<Schema$ListLocationsResponse>
     ): void;
     list(
-      callback: BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+      params: Params$Resource$Locations$List,
+      callback: BodyResponseCallback<Schema$ListLocationsResponse>
     ): void;
+    list(callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
     list(
       paramsOrCallback?:
-        | Params$Resource$Managedzoneoperations$List
-        | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+        | Params$Resource$Locations$List
+        | BodyResponseCallback<Schema$ListLocationsResponse>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+        | BodyResponseCallback<Schema$ListLocationsResponse>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+        | BodyResponseCallback<Schema$ListLocationsResponse>
         | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<
-          GaxiosResponseWithHTTP2<Schema$ManagedZoneOperationsListResponse>
-        >
+      | Promise<GaxiosResponseWithHTTP2<Schema$ListLocationsResponse>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
-      let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzoneoperations$List;
+      let params = (paramsOrCallback || {}) as Params$Resource$Locations$List;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzoneoperations$List;
+        params = {} as Params$Resource$Locations$List;
         options = {};
       }
 
@@ -2428,82 +2599,68 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl +
-              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}/operations'
-            ).replace(/([^:]\/)\/+/g, '$1'),
+            url: (rootUrl + '/dns/v1beta2/{+name}/locations').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
             method: 'GET',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['project', 'managedZone'],
-        pathParams: ['managedZone', 'project'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$ManagedZoneOperationsListResponse>(
+        createAPIRequest<Schema$ListLocationsResponse>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$ManagedZoneOperationsListResponse>(
-          parameters
-        );
+        return createAPIRequest<Schema$ListLocationsResponse>(parameters);
       }
     }
   }
 
-  export interface Params$Resource$Managedzoneoperations$Get extends StandardParameters {
-    /**
-     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
-     */
-    clientOperationId?: string;
-    /**
-     * Identifies the managed zone addressed by this request.
-     */
-    managedZone?: string;
-    /**
-     * Identifies the operation addressed by this request (ID of the operation).
-     */
-    operation?: string;
+  export interface Params$Resource$Locations$Get extends StandardParameters {
     /**
-     * Identifies the project addressed by this request.
+     * Resource name for the location.
      */
-    project?: string;
+    name?: string;
   }
-  export interface Params$Resource$Managedzoneoperations$List extends StandardParameters {
+  export interface Params$Resource$Locations$List extends StandardParameters {
     /**
-     * Identifies the managed zone addressed by this request.
+     * Optional. Do not use this field unless explicitly documented otherwise. This is primarily for internal usage.
      */
-    managedZone?: string;
+    extraLocationTypes?: string[];
     /**
-     * Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+     * A filter to narrow down results to a preferred subset. The filtering language accepts strings like `"displayName=tokyo"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160).
      */
-    maxResults?: number;
+    filter?: string;
     /**
-     * Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+     * The resource that owns the locations collection, if applicable.
      */
-    pageToken?: string;
+    name?: string;
     /**
-     * Identifies the project addressed by this request.
+     * The maximum number of results to return. If not set, the service selects a default.
      */
-    project?: string;
+    pageSize?: number;
     /**
-     * Sorting criterion. The only supported values are START_TIME and ID.
+     * A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.
      */
-    sortBy?: string;
+    pageToken?: string;
   }
 
-  export class Resource$Managedzones {
+  export class Resource$Managedzoneoperations {
     context: APIRequestContext;
     constructor(context: APIRequestContext) {
       this.context = context;
     }
 
     /**
-     * Creates a new ManagedZone. Note: While `dns.managedZones.create` is the baseline permission required to invoke this method, additional permissions are required if the managed zone configuration references other resources.
+     * Fetches the representation of an existing Operation.
      * @example
      * ```js
      * // Before running the sample:
@@ -2526,6 +2683,8 @@ export namespace dns_v1beta2 {
      *     // 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',
      *     ],
      *   });
@@ -2535,14 +2694,1649 @@ export namespace dns_v1beta2 {
      *   google.options({auth: authClient});
      *
      *   // Do the magic
-     *   const res = await dns.managedZones.create({
+     *   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);
      *
-     *     // Request body metadata
-     *     requestBody: {
+     *   // Example response
+     *   // {
+     *   //   "dnsKeyContext": {},
+     *   //   "id": "my_id",
+     *   //   "kind": "my_kind",
+     *   //   "startTime": "my_startTime",
+     *   //   "status": "my_status",
+     *   //   "type": "my_type",
+     *   //   "user": "my_user",
+     *   //   "zoneContext": {}
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    get(
+      params: Params$Resource$Managedzoneoperations$Get,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    get(
+      params?: Params$Resource$Managedzoneoperations$Get,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
+    get(
+      params: Params$Resource$Managedzoneoperations$Get,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    get(
+      params: Params$Resource$Managedzoneoperations$Get,
+      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    get(
+      params: Params$Resource$Managedzoneoperations$Get,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    get(callback: BodyResponseCallback<Schema$Operation>): void;
+    get(
+      paramsOrCallback?:
+        | Params$Resource$Managedzoneoperations$Get
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        BodyResponseCallback<Schema$Operation> | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$Operation>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzoneoperations$Get;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzoneoperations$Get;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}/operations/{operation}'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['project', 'managedZone', 'operation'],
+        pathParams: ['managedZone', 'operation', 'project'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Operation>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Operation>(parameters);
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZoneOperations.list({
+     *     // Identifies the managed zone addressed by this request.
+     *     managedZone: 'placeholder-value',
+     *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+     *     maxResults: 'placeholder-value',
+     *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+     *     pageToken: 'placeholder-value',
+     *     // Identifies the project addressed by this request.
+     *     project: 'placeholder-value',
+     *     // Sorting criterion. The only supported values are START_TIME and ID.
+     *     sortBy: 'placeholder-value',
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "kind": "my_kind",
+     *   //   "nextPageToken": "my_nextPageToken",
+     *   //   "operations": []
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    list(
+      params: Params$Resource$Managedzoneoperations$List,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    list(
+      params?: Params$Resource$Managedzoneoperations$List,
+      options?: MethodOptions
+    ): Promise<
+      GaxiosResponseWithHTTP2<Schema$ManagedZoneOperationsListResponse>
+    >;
+    list(
+      params: Params$Resource$Managedzoneoperations$List,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    list(
+      params: Params$Resource$Managedzoneoperations$List,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>,
+      callback: BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+    ): void;
+    list(
+      params: Params$Resource$Managedzoneoperations$List,
+      callback: BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+    ): void;
+    list(
+      callback: BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+    ): void;
+    list(
+      paramsOrCallback?:
+        | Params$Resource$Managedzoneoperations$List
+        | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$ManagedZoneOperationsListResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<
+          GaxiosResponseWithHTTP2<Schema$ManagedZoneOperationsListResponse>
+        >
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzoneoperations$List;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzoneoperations$List;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}/operations'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['project', 'managedZone'],
+        pathParams: ['managedZone', 'project'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$ManagedZoneOperationsListResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$ManagedZoneOperationsListResponse>(
+          parameters
+        );
+      }
+    }
+  }
+
+  export interface Params$Resource$Managedzoneoperations$Get extends StandardParameters {
+    /**
+     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     */
+    clientOperationId?: string;
+    /**
+     * Identifies the managed zone addressed by this request.
+     */
+    managedZone?: string;
+    /**
+     * Identifies the operation addressed by this request (ID of the operation).
+     */
+    operation?: string;
+    /**
+     * Identifies the project addressed by this request.
+     */
+    project?: string;
+  }
+  export interface Params$Resource$Managedzoneoperations$List extends StandardParameters {
+    /**
+     * Identifies the managed zone addressed by this request.
+     */
+    managedZone?: string;
+    /**
+     * Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+     */
+    maxResults?: number;
+    /**
+     * Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+     */
+    pageToken?: string;
+    /**
+     * Identifies the project addressed by this request.
+     */
+    project?: string;
+    /**
+     * Sorting criterion. The only supported values are START_TIME and ID.
+     */
+    sortBy?: string;
+  }
+
+  export class Resource$Managedzones {
+    context: APIRequestContext;
+    constructor(context: APIRequestContext) {
+      this.context = context;
+    }
+
+    /**
+     * Creates a new ManagedZone. Note: While `dns.managedZones.create` is the baseline permission required to invoke this method, additional permissions are required if the managed zone configuration references other resources.
+     * @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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZones.create({
+     *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     *     clientOperationId: 'placeholder-value',
+     *     // Identifies the project addressed by this request.
+     *     project: 'placeholder-value',
+     *
+     *     // Request body metadata
+     *     requestBody: {
+     *       // request body parameters
+     *       // {
+     *       //   "cloudLoggingConfig": {},
+     *       //   "creationTime": "my_creationTime",
+     *       //   "description": "my_description",
+     *       //   "dnsName": "my_dnsName",
+     *       //   "dnssecConfig": {},
+     *       //   "forwardingConfig": {},
+     *       //   "id": "my_id",
+     *       //   "kind": "my_kind",
+     *       //   "labels": {},
+     *       //   "name": "my_name",
+     *       //   "nameServerSet": "my_nameServerSet",
+     *       //   "nameServers": [],
+     *       //   "peeringConfig": {},
+     *       //   "privateVisibilityConfig": {},
+     *       //   "reverseLookupConfig": {},
+     *       //   "serviceDirectoryConfig": {},
+     *       //   "visibility": "my_visibility"
+     *       // }
+     *     },
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "cloudLoggingConfig": {},
+     *   //   "creationTime": "my_creationTime",
+     *   //   "description": "my_description",
+     *   //   "dnsName": "my_dnsName",
+     *   //   "dnssecConfig": {},
+     *   //   "forwardingConfig": {},
+     *   //   "id": "my_id",
+     *   //   "kind": "my_kind",
+     *   //   "labels": {},
+     *   //   "name": "my_name",
+     *   //   "nameServerSet": "my_nameServerSet",
+     *   //   "nameServers": [],
+     *   //   "peeringConfig": {},
+     *   //   "privateVisibilityConfig": {},
+     *   //   "reverseLookupConfig": {},
+     *   //   "serviceDirectoryConfig": {},
+     *   //   "visibility": "my_visibility"
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    create(
+      params: Params$Resource$Managedzones$Create,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    create(
+      params?: Params$Resource$Managedzones$Create,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>;
+    create(
+      params: Params$Resource$Managedzones$Create,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    create(
+      params: Params$Resource$Managedzones$Create,
+      options: MethodOptions | BodyResponseCallback<Schema$ManagedZone>,
+      callback: BodyResponseCallback<Schema$ManagedZone>
+    ): void;
+    create(
+      params: Params$Resource$Managedzones$Create,
+      callback: BodyResponseCallback<Schema$ManagedZone>
+    ): void;
+    create(callback: BodyResponseCallback<Schema$ManagedZone>): void;
+    create(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$Create
+        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzones$Create;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$Create;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl + '/dns/v1beta2/projects/{project}/managedZones'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'POST',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['project'],
+        pathParams: ['project'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$ManagedZone>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$ManagedZone>(parameters);
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZones.delete({
+     *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     *     clientOperationId: 'placeholder-value',
+     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     *     managedZone: 'placeholder-value',
+     *     // Identifies the project addressed by this request.
+     *     project: 'placeholder-value',
+     *   });
+     *   console.log(res.data);
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    delete(
+      params: Params$Resource$Managedzones$Delete,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    delete(
+      params?: Params$Resource$Managedzones$Delete,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<void>>;
+    delete(
+      params: Params$Resource$Managedzones$Delete,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    delete(
+      params: Params$Resource$Managedzones$Delete,
+      options: MethodOptions | BodyResponseCallback<void>,
+      callback: BodyResponseCallback<void>
+    ): void;
+    delete(
+      params: Params$Resource$Managedzones$Delete,
+      callback: BodyResponseCallback<void>
+    ): void;
+    delete(callback: BodyResponseCallback<void>): void;
+    delete(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$Delete
+        | BodyResponseCallback<void>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<void>
+        | BodyResponseCallback<Readable>,
+      callback?: BodyResponseCallback<void> | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<void>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzones$Delete;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$Delete;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'DELETE',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['project', 'managedZone'],
+        pathParams: ['managedZone', 'project'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<void>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<void>(parameters);
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZones.get({
+     *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     *     clientOperationId: 'placeholder-value',
+     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     *     managedZone: 'placeholder-value',
+     *     // Identifies the project addressed by this request.
+     *     project: 'placeholder-value',
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "cloudLoggingConfig": {},
+     *   //   "creationTime": "my_creationTime",
+     *   //   "description": "my_description",
+     *   //   "dnsName": "my_dnsName",
+     *   //   "dnssecConfig": {},
+     *   //   "forwardingConfig": {},
+     *   //   "id": "my_id",
+     *   //   "kind": "my_kind",
+     *   //   "labels": {},
+     *   //   "name": "my_name",
+     *   //   "nameServerSet": "my_nameServerSet",
+     *   //   "nameServers": [],
+     *   //   "peeringConfig": {},
+     *   //   "privateVisibilityConfig": {},
+     *   //   "reverseLookupConfig": {},
+     *   //   "serviceDirectoryConfig": {},
+     *   //   "visibility": "my_visibility"
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    get(
+      params: Params$Resource$Managedzones$Get,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    get(
+      params?: Params$Resource$Managedzones$Get,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>;
+    get(
+      params: Params$Resource$Managedzones$Get,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    get(
+      params: Params$Resource$Managedzones$Get,
+      options: MethodOptions | BodyResponseCallback<Schema$ManagedZone>,
+      callback: BodyResponseCallback<Schema$ManagedZone>
+    ): void;
+    get(
+      params: Params$Resource$Managedzones$Get,
+      callback: BodyResponseCallback<Schema$ManagedZone>
+    ): void;
+    get(callback: BodyResponseCallback<Schema$ManagedZone>): void;
+    get(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$Get
+        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback || {}) as Params$Resource$Managedzones$Get;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$Get;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['project', 'managedZone'],
+        pathParams: ['managedZone', 'project'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$ManagedZone>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$ManagedZone>(parameters);
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZones.getIamPolicy({
+     *     // REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
+     *     resource: 'projects/my-project/managedZones/my-managedZone',
+     *
+     *     // Request body metadata
+     *     requestBody: {
+     *       // request body parameters
+     *       // {
+     *       //   "options": {}
+     *       // }
+     *     },
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "auditConfigs": [],
+     *   //   "bindings": [],
+     *   //   "etag": "my_etag",
+     *   //   "version": 0
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    getIamPolicy(
+      params: Params$Resource$Managedzones$Getiampolicy,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    getIamPolicy(
+      params?: Params$Resource$Managedzones$Getiampolicy,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>;
+    getIamPolicy(
+      params: Params$Resource$Managedzones$Getiampolicy,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    getIamPolicy(
+      params: Params$Resource$Managedzones$Getiampolicy,
+      options: MethodOptions | BodyResponseCallback<Schema$GoogleIamV1Policy>,
+      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    ): void;
+    getIamPolicy(
+      params: Params$Resource$Managedzones$Getiampolicy,
+      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    ): void;
+    getIamPolicy(
+      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    ): void;
+    getIamPolicy(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$Getiampolicy
+        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzones$Getiampolicy;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$Getiampolicy;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/dns/v1beta2/{+resource}:getIamPolicy').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'POST',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['resource'],
+        pathParams: ['resource'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleIamV1Policy>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleIamV1Policy>(parameters);
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZones.list({
+     *     // Restricts the list to return only zones with this domain name.
+     *     dnsName: 'placeholder-value',
+     *     // Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+     *     maxResults: 'placeholder-value',
+     *     // Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+     *     pageToken: 'placeholder-value',
+     *     // Identifies the project addressed by this request.
+     *     project: 'placeholder-value',
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "kind": "my_kind",
+     *   //   "managedZones": [],
+     *   //   "nextPageToken": "my_nextPageToken"
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    list(
+      params: Params$Resource$Managedzones$List,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    list(
+      params?: Params$Resource$Managedzones$List,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZonesListResponse>>;
+    list(
+      params: Params$Resource$Managedzones$List,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    list(
+      params: Params$Resource$Managedzones$List,
+      options:
+        MethodOptions | BodyResponseCallback<Schema$ManagedZonesListResponse>,
+      callback: BodyResponseCallback<Schema$ManagedZonesListResponse>
+    ): void;
+    list(
+      params: Params$Resource$Managedzones$List,
+      callback: BodyResponseCallback<Schema$ManagedZonesListResponse>
+    ): void;
+    list(callback: BodyResponseCallback<Schema$ManagedZonesListResponse>): void;
+    list(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$List
+        | BodyResponseCallback<Schema$ManagedZonesListResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$ManagedZonesListResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$ManagedZonesListResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$ManagedZonesListResponse>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzones$List;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$List;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl + '/dns/v1beta2/projects/{project}/managedZones'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'GET',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['project'],
+        pathParams: ['project'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$ManagedZonesListResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$ManagedZonesListResponse>(parameters);
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZones.patch({
+     *     // For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     *     clientOperationId: 'placeholder-value',
+     *     // Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     *     managedZone: 'placeholder-value',
+     *     // Identifies the project addressed by this request.
+     *     project: 'placeholder-value',
+     *
+     *     // Request body metadata
+     *     requestBody: {
+     *       // request body parameters
+     *       // {
+     *       //   "cloudLoggingConfig": {},
+     *       //   "creationTime": "my_creationTime",
+     *       //   "description": "my_description",
+     *       //   "dnsName": "my_dnsName",
+     *       //   "dnssecConfig": {},
+     *       //   "forwardingConfig": {},
+     *       //   "id": "my_id",
+     *       //   "kind": "my_kind",
+     *       //   "labels": {},
+     *       //   "name": "my_name",
+     *       //   "nameServerSet": "my_nameServerSet",
+     *       //   "nameServers": [],
+     *       //   "peeringConfig": {},
+     *       //   "privateVisibilityConfig": {},
+     *       //   "reverseLookupConfig": {},
+     *       //   "serviceDirectoryConfig": {},
+     *       //   "visibility": "my_visibility"
+     *       // }
+     *     },
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "dnsKeyContext": {},
+     *   //   "id": "my_id",
+     *   //   "kind": "my_kind",
+     *   //   "startTime": "my_startTime",
+     *   //   "status": "my_status",
+     *   //   "type": "my_type",
+     *   //   "user": "my_user",
+     *   //   "zoneContext": {}
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    patch(
+      params: Params$Resource$Managedzones$Patch,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    patch(
+      params?: Params$Resource$Managedzones$Patch,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
+    patch(
+      params: Params$Resource$Managedzones$Patch,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    patch(
+      params: Params$Resource$Managedzones$Patch,
+      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    patch(
+      params: Params$Resource$Managedzones$Patch,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    patch(callback: BodyResponseCallback<Schema$Operation>): void;
+    patch(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$Patch
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        BodyResponseCallback<Schema$Operation> | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$Operation>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzones$Patch;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$Patch;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'PATCH',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['project', 'managedZone'],
+        pathParams: ['managedZone', 'project'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Operation>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Operation>(parameters);
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZones.setIamPolicy({
+     *     // REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
+     *     resource: 'projects/my-project/managedZones/my-managedZone',
+     *
+     *     // Request body metadata
+     *     requestBody: {
+     *       // request body parameters
+     *       // {
+     *       //   "policy": {},
+     *       //   "updateMask": "my_updateMask"
+     *       // }
+     *     },
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "auditConfigs": [],
+     *   //   "bindings": [],
+     *   //   "etag": "my_etag",
+     *   //   "version": 0
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    setIamPolicy(
+      params: Params$Resource$Managedzones$Setiampolicy,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    setIamPolicy(
+      params?: Params$Resource$Managedzones$Setiampolicy,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>;
+    setIamPolicy(
+      params: Params$Resource$Managedzones$Setiampolicy,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    setIamPolicy(
+      params: Params$Resource$Managedzones$Setiampolicy,
+      options: MethodOptions | BodyResponseCallback<Schema$GoogleIamV1Policy>,
+      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    ): void;
+    setIamPolicy(
+      params: Params$Resource$Managedzones$Setiampolicy,
+      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    ): void;
+    setIamPolicy(
+      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    ): void;
+    setIamPolicy(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$Setiampolicy
+        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzones$Setiampolicy;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$Setiampolicy;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (rootUrl + '/dns/v1beta2/{+resource}:setIamPolicy').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'POST',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['resource'],
+        pathParams: ['resource'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleIamV1Policy>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleIamV1Policy>(parameters);
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * async function main() {
+     *   const auth = new google.auth.GoogleAuth({
+     *     // Scopes can be specified either as an array or as a single, space-delimited string.
+     *     scopes: [
+     *       'https://www.googleapis.com/auth/cloud-platform',
+     *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readonly',
+     *       'https://www.googleapis.com/auth/ndev.clouddns.readwrite',
+     *     ],
+     *   });
+     *
+     *   // Acquire an auth client, and bind it to all future calls
+     *   const authClient = await auth.getClient();
+     *   google.options({auth: authClient});
+     *
+     *   // Do the magic
+     *   const res = await dns.managedZones.testIamPermissions({
+     *     // REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
+     *     resource: 'projects/my-project/managedZones/my-managedZone',
+     *
+     *     // Request body metadata
+     *     requestBody: {
+     *       // request body parameters
+     *       // {
+     *       //   "permissions": []
+     *       // }
+     *     },
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {
+     *   //   "permissions": []
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    testIamPermissions(
+      params: Params$Resource$Managedzones$Testiampermissions,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    testIamPermissions(
+      params?: Params$Resource$Managedzones$Testiampermissions,
+      options?: MethodOptions
+    ): Promise<
+      GaxiosResponseWithHTTP2<Schema$GoogleIamV1TestIamPermissionsResponse>
+    >;
+    testIamPermissions(
+      params: Params$Resource$Managedzones$Testiampermissions,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    testIamPermissions(
+      params: Params$Resource$Managedzones$Testiampermissions,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>,
+      callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+    ): void;
+    testIamPermissions(
+      params: Params$Resource$Managedzones$Testiampermissions,
+      callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+    ): void;
+    testIamPermissions(
+      callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+    ): void;
+    testIamPermissions(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$Testiampermissions
+        | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+        | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<
+          GaxiosResponseWithHTTP2<Schema$GoogleIamV1TestIamPermissionsResponse>
+        >
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzones$Testiampermissions;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$Testiampermissions;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl + '/dns/v1beta2/{+resource}:testIamPermissions'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'POST',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['resource'],
+        pathParams: ['resource'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$GoogleIamV1TestIamPermissionsResponse>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$GoogleIamV1TestIamPermissionsResponse>(
+          parameters
+        );
+      }
+    }
+
+    /**
+     * 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('v1beta2');
+     *
+     * 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": {},
@@ -2568,25 +4362,293 @@ export namespace dns_v1beta2 {
      *   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"
-     *   // }
+     *   // {
+     *   //   "dnsKeyContext": {},
+     *   //   "id": "my_id",
+     *   //   "kind": "my_kind",
+     *   //   "startTime": "my_startTime",
+     *   //   "status": "my_status",
+     *   //   "type": "my_type",
+     *   //   "user": "my_user",
+     *   //   "zoneContext": {}
+     *   // }
+     * }
+     *
+     * main().catch(e => {
+     *   console.error(e);
+     *   throw e;
+     * });
+     *
+     * ```
+     *
+     * @param params - Parameters for request
+     * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+     * @param callback - Optional callback that handles the response.
+     * @returns A promise if used with async/await, or void if used with a callback.
+     */
+    update(
+      params: Params$Resource$Managedzones$Update,
+      options: StreamMethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Readable>>;
+    update(
+      params?: Params$Resource$Managedzones$Update,
+      options?: MethodOptions
+    ): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
+    update(
+      params: Params$Resource$Managedzones$Update,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
+    ): void;
+    update(
+      params: Params$Resource$Managedzones$Update,
+      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    update(
+      params: Params$Resource$Managedzones$Update,
+      callback: BodyResponseCallback<Schema$Operation>
+    ): void;
+    update(callback: BodyResponseCallback<Schema$Operation>): void;
+    update(
+      paramsOrCallback?:
+        | Params$Resource$Managedzones$Update
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      optionsOrCallback?:
+        | MethodOptions
+        | StreamMethodOptions
+        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Readable>,
+      callback?:
+        BodyResponseCallback<Schema$Operation> | BodyResponseCallback<Readable>
+    ):
+      | void
+      | Promise<GaxiosResponseWithHTTP2<Schema$Operation>>
+      | Promise<GaxiosResponseWithHTTP2<Readable>> {
+      let params = (paramsOrCallback ||
+        {}) as Params$Resource$Managedzones$Update;
+      let options = (optionsOrCallback || {}) as MethodOptions;
+
+      if (typeof paramsOrCallback === 'function') {
+        callback = paramsOrCallback;
+        params = {} as Params$Resource$Managedzones$Update;
+        options = {};
+      }
+
+      if (typeof optionsOrCallback === 'function') {
+        callback = optionsOrCallback;
+        options = {};
+      }
+
+      const rootUrl = options.rootUrl || 'https://dns.googleapis.com/';
+      const parameters = {
+        options: Object.assign(
+          {
+            url: (
+              rootUrl +
+              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}'
+            ).replace(/([^:]\/)\/+/g, '$1'),
+            method: 'PUT',
+            apiVersion: '',
+          },
+          options
+        ),
+        params,
+        requiredParams: ['project', 'managedZone'],
+        pathParams: ['managedZone', 'project'],
+        context: this.context,
+      };
+      if (callback) {
+        createAPIRequest<Schema$Operation>(
+          parameters,
+          callback as BodyResponseCallback<unknown>
+        );
+      } else {
+        return createAPIRequest<Schema$Operation>(parameters);
+      }
+    }
+  }
+
+  export interface Params$Resource$Managedzones$Create extends StandardParameters {
+    /**
+     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     */
+    clientOperationId?: string;
+    /**
+     * Identifies the project addressed by this request.
+     */
+    project?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$ManagedZone;
+  }
+  export interface Params$Resource$Managedzones$Delete extends StandardParameters {
+    /**
+     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     */
+    clientOperationId?: string;
+    /**
+     * Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     */
+    managedZone?: string;
+    /**
+     * Identifies the project addressed by this request.
+     */
+    project?: string;
+  }
+  export interface Params$Resource$Managedzones$Get extends StandardParameters {
+    /**
+     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     */
+    clientOperationId?: string;
+    /**
+     * Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     */
+    managedZone?: string;
+    /**
+     * Identifies the project addressed by this request.
+     */
+    project?: string;
+  }
+  export interface Params$Resource$Managedzones$Getiampolicy extends StandardParameters {
+    /**
+     * 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?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$GoogleIamV1GetIamPolicyRequest;
+  }
+  export interface Params$Resource$Managedzones$List extends StandardParameters {
+    /**
+     * Restricts the list to return only zones with this domain name.
+     */
+    dnsName?: string;
+    /**
+     * Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+     */
+    maxResults?: number;
+    /**
+     * Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+     */
+    pageToken?: string;
+    /**
+     * Identifies the project addressed by this request.
+     */
+    project?: string;
+  }
+  export interface Params$Resource$Managedzones$Patch extends StandardParameters {
+    /**
+     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     */
+    clientOperationId?: string;
+    /**
+     * Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     */
+    managedZone?: string;
+    /**
+     * Identifies the project addressed by this request.
+     */
+    project?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$ManagedZone;
+  }
+  export interface Params$Resource$Managedzones$Setiampolicy extends StandardParameters {
+    /**
+     * 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?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$GoogleIamV1SetIamPolicyRequest;
+  }
+  export interface Params$Resource$Managedzones$Testiampermissions extends StandardParameters {
+    /**
+     * 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?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$GoogleIamV1TestIamPermissionsRequest;
+  }
+  export interface Params$Resource$Managedzones$Update extends StandardParameters {
+    /**
+     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     */
+    clientOperationId?: string;
+    /**
+     * Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     */
+    managedZone?: string;
+    /**
+     * Identifies the project addressed by this request.
+     */
+    project?: string;
+
+    /**
+     * Request body metadata
+     */
+    requestBody?: Schema$ManagedZone;
+  }
+
+  export class Resource$Operations {
+    context: APIRequestContext;
+    constructor(context: APIRequestContext) {
+      this.context = context;
+    }
+
+    /**
+     * Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of `1`, corresponding to `Code.CANCELLED`.
+     * @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('v1beta2');
+     *
+     * 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.operations.cancel({
+     *     // The name of the operation resource to be cancelled.
+     *     name: 'projects/my-project/locations/my-location/operations/my-operation',
+     *   });
+     *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {}
      * }
      *
      * main().catch(e => {
@@ -2601,53 +4663,52 @@ export namespace dns_v1beta2 {
      * @param callback - Optional callback that handles the response.
      * @returns A promise if used with async/await, or void if used with a callback.
      */
-    create(
-      params: Params$Resource$Managedzones$Create,
+    cancel(
+      params: Params$Resource$Operations$Cancel,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
-    create(
-      params?: Params$Resource$Managedzones$Create,
+    cancel(
+      params?: Params$Resource$Operations$Cancel,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>;
-    create(
-      params: Params$Resource$Managedzones$Create,
+    ): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
+    cancel(
+      params: Params$Resource$Operations$Cancel,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    create(
-      params: Params$Resource$Managedzones$Create,
-      options: MethodOptions | BodyResponseCallback<Schema$ManagedZone>,
-      callback: BodyResponseCallback<Schema$ManagedZone>
+    cancel(
+      params: Params$Resource$Operations$Cancel,
+      options: MethodOptions | BodyResponseCallback<Schema$Empty>,
+      callback: BodyResponseCallback<Schema$Empty>
     ): void;
-    create(
-      params: Params$Resource$Managedzones$Create,
-      callback: BodyResponseCallback<Schema$ManagedZone>
+    cancel(
+      params: Params$Resource$Operations$Cancel,
+      callback: BodyResponseCallback<Schema$Empty>
     ): void;
-    create(callback: BodyResponseCallback<Schema$ManagedZone>): void;
-    create(
+    cancel(callback: BodyResponseCallback<Schema$Empty>): void;
+    cancel(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$Create
-        | BodyResponseCallback<Schema$ManagedZone>
+        | Params$Resource$Operations$Cancel
+        | BodyResponseCallback<Schema$Empty>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Schema$Empty>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$ManagedZone>
-        | BodyResponseCallback<Readable>
+        BodyResponseCallback<Schema$Empty> | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>
+      | Promise<GaxiosResponseWithHTTP2<Schema$Empty>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzones$Create;
+        {}) as Params$Resource$Operations$Cancel;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$Create;
+        params = {} as Params$Resource$Operations$Cancel;
         options = {};
       }
 
@@ -2660,31 +4721,32 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl + '/dns/v1beta2/projects/{project}/managedZones'
-            ).replace(/([^:]\/)\/+/g, '$1'),
+            url: (rootUrl + '/dns/v1beta2/{+name}:cancel').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
             method: 'POST',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['project'],
-        pathParams: ['project'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$ManagedZone>(
+        createAPIRequest<Schema$Empty>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$ManagedZone>(parameters);
+        return createAPIRequest<Schema$Empty>(parameters);
       }
     }
 
     /**
-     * Deletes a previously created ManagedZone.
+     * Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
      * @example
      * ```js
      * // Before running the sample:
@@ -2716,15 +4778,14 @@ export namespace dns_v1beta2 {
      *   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',
+     *   const res = await dns.operations.delete({
+     *     // The name of the operation resource to be deleted.
+     *     name: 'projects/my-project/locations/my-location/operations/my-operation',
      *   });
      *   console.log(res.data);
+     *
+     *   // Example response
+     *   // {}
      * }
      *
      * main().catch(e => {
@@ -2740,50 +4801,51 @@ export namespace dns_v1beta2 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     delete(
-      params: Params$Resource$Managedzones$Delete,
+      params: Params$Resource$Operations$Delete,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
     delete(
-      params?: Params$Resource$Managedzones$Delete,
+      params?: Params$Resource$Operations$Delete,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<void>>;
+    ): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
     delete(
-      params: Params$Resource$Managedzones$Delete,
+      params: Params$Resource$Operations$Delete,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     delete(
-      params: Params$Resource$Managedzones$Delete,
-      options: MethodOptions | BodyResponseCallback<void>,
-      callback: BodyResponseCallback<void>
+      params: Params$Resource$Operations$Delete,
+      options: MethodOptions | BodyResponseCallback<Schema$Empty>,
+      callback: BodyResponseCallback<Schema$Empty>
     ): void;
     delete(
-      params: Params$Resource$Managedzones$Delete,
-      callback: BodyResponseCallback<void>
+      params: Params$Resource$Operations$Delete,
+      callback: BodyResponseCallback<Schema$Empty>
     ): void;
-    delete(callback: BodyResponseCallback<void>): void;
+    delete(callback: BodyResponseCallback<Schema$Empty>): void;
     delete(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$Delete
-        | BodyResponseCallback<void>
+        | Params$Resource$Operations$Delete
+        | BodyResponseCallback<Schema$Empty>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<void>
+        | BodyResponseCallback<Schema$Empty>
         | BodyResponseCallback<Readable>,
-      callback?: BodyResponseCallback<void> | BodyResponseCallback<Readable>
+      callback?:
+        BodyResponseCallback<Schema$Empty> | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<void>>
+      | Promise<GaxiosResponseWithHTTP2<Schema$Empty>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzones$Delete;
+        {}) as Params$Resource$Operations$Delete;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$Delete;
+        params = {} as Params$Resource$Operations$Delete;
         options = {};
       }
 
@@ -2796,32 +4858,32 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl +
-              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}'
-            ).replace(/([^:]\/)\/+/g, '$1'),
+            url: (rootUrl + '/dns/v1beta2/{+name}').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
             method: 'DELETE',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['project', 'managedZone'],
-        pathParams: ['managedZone', 'project'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<void>(
+        createAPIRequest<Schema$Empty>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<void>(parameters);
+        return createAPIRequest<Schema$Empty>(parameters);
       }
     }
 
     /**
-     * Fetches the representation of an existing ManagedZone.
+     * Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
      * @example
      * ```js
      * // Before running the sample:
@@ -2844,8 +4906,6 @@ export namespace dns_v1beta2 {
      *     // 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',
      *     ],
      *   });
@@ -2855,35 +4915,19 @@ export namespace dns_v1beta2 {
      *   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',
+     *   const res = await dns.operations.get({
+     *     // The name of the operation resource.
+     *     name: 'projects/my-project/locations/my-location/operations/my-operation',
      *   });
      *   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": {},
+     *   //   "done": false,
+     *   //   "error": {},
+     *   //   "metadata": {},
      *   //   "name": "my_name",
-     *   //   "nameServerSet": "my_nameServerSet",
-     *   //   "nameServers": [],
-     *   //   "peeringConfig": {},
-     *   //   "privateVisibilityConfig": {},
-     *   //   "reverseLookupConfig": {},
-     *   //   "serviceDirectoryConfig": {},
-     *   //   "visibility": "my_visibility"
+     *   //   "response": {}
      *   // }
      * }
      *
@@ -2900,51 +4944,54 @@ export namespace dns_v1beta2 {
      * @returns A promise if used with async/await, or void if used with a callback.
      */
     get(
-      params: Params$Resource$Managedzones$Get,
+      params: Params$Resource$Operations$Get,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
     get(
-      params?: Params$Resource$Managedzones$Get,
+      params?: Params$Resource$Operations$Get,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>;
+    ): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
     get(
-      params: Params$Resource$Managedzones$Get,
+      params: Params$Resource$Operations$Get,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
     get(
-      params: Params$Resource$Managedzones$Get,
-      options: MethodOptions | BodyResponseCallback<Schema$ManagedZone>,
-      callback: BodyResponseCallback<Schema$ManagedZone>
+      params: Params$Resource$Operations$Get,
+      options:
+        MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
     ): void;
     get(
-      params: Params$Resource$Managedzones$Get,
-      callback: BodyResponseCallback<Schema$ManagedZone>
+      params: Params$Resource$Operations$Get,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    get(
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
     ): void;
-    get(callback: BodyResponseCallback<Schema$ManagedZone>): void;
     get(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$Get
-        | BodyResponseCallback<Schema$ManagedZone>
+        | Params$Resource$Operations$Get
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$ManagedZone>
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<Schema$ManagedZone>>
+      | Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
-      let params = (paramsOrCallback || {}) as Params$Resource$Managedzones$Get;
+      let params = (paramsOrCallback || {}) as Params$Resource$Operations$Get;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$Get;
+        params = {} as Params$Resource$Operations$Get;
         options = {};
       }
 
@@ -2957,32 +5004,32 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl +
-              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}'
-            ).replace(/([^:]\/)\/+/g, '$1'),
+            url: (rootUrl + '/dns/v1beta2/{+name}').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
             method: 'GET',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['project', 'managedZone'],
-        pathParams: ['managedZone', 'project'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$ManagedZone>(
+        createAPIRequest<Schema$GoogleLongrunningOperation>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$ManagedZone>(parameters);
+        return createAPIRequest<Schema$GoogleLongrunningOperation>(parameters);
       }
     }
 
     /**
-     * Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.
+     * Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.
      * @example
      * ```js
      * // Before running the sample:
@@ -3005,8 +5052,6 @@ export namespace dns_v1beta2 {
      *     // 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',
      *     ],
      *   });
@@ -3016,26 +5061,25 @@ export namespace dns_v1beta2 {
      *   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": {}
-     *       // }
-     *     },
+     *   const res = await dns.operations.list({
+     *     // The standard list filter.
+     *     filter: 'placeholder-value',
+     *     // The name of the operation's parent resource.
+     *     name: 'projects/my-project/locations/my-location',
+     *     // The standard list page size.
+     *     pageSize: 'placeholder-value',
+     *     // The standard list page token.
+     *     pageToken: 'placeholder-value',
+     *     // When set to `true`, operations that are reachable are returned as normal, and those that are unreachable are returned in the ListOperationsResponse.unreachable field. This can only be `true` when reading across collections. For example, when `parent` is set to `"projects/example/locations/-"`. This field is not supported by default and will result in an `UNIMPLEMENTED` error if set unless explicitly documented otherwise in service or product specific documentation.
+     *     returnPartialSuccess: 'placeholder-value',
      *   });
      *   console.log(res.data);
      *
      *   // Example response
      *   // {
-     *   //   "auditConfigs": [],
-     *   //   "bindings": [],
-     *   //   "etag": "my_etag",
-     *   //   "version": 0
+     *   //   "nextPageToken": "my_nextPageToken",
+     *   //   "operations": [],
+     *   //   "unreachable": []
      *   // }
      * }
      *
@@ -3051,55 +5095,60 @@ export namespace dns_v1beta2 {
      * @param callback - Optional callback that handles the response.
      * @returns A promise if used with async/await, or void if used with a callback.
      */
-    getIamPolicy(
-      params: Params$Resource$Managedzones$Getiampolicy,
+    list(
+      params: Params$Resource$Operations$List,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
-    getIamPolicy(
-      params?: Params$Resource$Managedzones$Getiampolicy,
+    list(
+      params?: Params$Resource$Operations$List,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>;
-    getIamPolicy(
-      params: Params$Resource$Managedzones$Getiampolicy,
-      options: StreamMethodOptions | BodyResponseCallback<Readable>,
-      callback: BodyResponseCallback<Readable>
-    ): void;
-    getIamPolicy(
-      params: Params$Resource$Managedzones$Getiampolicy,
-      options: MethodOptions | BodyResponseCallback<Schema$GoogleIamV1Policy>,
-      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    ): Promise<
+      GaxiosResponseWithHTTP2<Schema$GoogleLongrunningListOperationsResponse>
+    >;
+    list(
+      params: Params$Resource$Operations$List,
+      options: StreamMethodOptions | BodyResponseCallback<Readable>,
+      callback: BodyResponseCallback<Readable>
     ): void;
-    getIamPolicy(
-      params: Params$Resource$Managedzones$Getiampolicy,
-      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    list(
+      params: Params$Resource$Operations$List,
+      options:
+        | MethodOptions
+        | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
     ): void;
-    getIamPolicy(
-      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    list(
+      params: Params$Resource$Operations$List,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
     ): void;
-    getIamPolicy(
+    list(
+      callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
+    ): void;
+    list(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$Getiampolicy
-        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | Params$Resource$Operations$List
+        | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>
         | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>
+      | Promise<
+          GaxiosResponseWithHTTP2<Schema$GoogleLongrunningListOperationsResponse>
+        >
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
-      let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzones$Getiampolicy;
+      let params = (paramsOrCallback || {}) as Params$Resource$Operations$List;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$Getiampolicy;
+        params = {} as Params$Resource$Operations$List;
         options = {};
       }
 
@@ -3112,32 +5161,82 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (rootUrl + '/dns/v1beta2/{+resource}:getIamPolicy').replace(
+            url: (rootUrl + '/dns/v1beta2/{+name}/operations').replace(
               /([^:]\/)\/+/g,
               '$1'
             ),
-            method: 'POST',
+            method: 'GET',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['resource'],
-        pathParams: ['resource'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$GoogleIamV1Policy>(
+        createAPIRequest<Schema$GoogleLongrunningListOperationsResponse>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$GoogleIamV1Policy>(parameters);
+        return createAPIRequest<Schema$GoogleLongrunningListOperationsResponse>(
+          parameters
+        );
       }
     }
+  }
 
+  export interface Params$Resource$Operations$Cancel extends StandardParameters {
     /**
-     * Enumerates ManagedZones that have been created but not yet deleted.
+     * The name of the operation resource to be cancelled.
+     */
+    name?: string;
+  }
+  export interface Params$Resource$Operations$Delete extends StandardParameters {
+    /**
+     * The name of the operation resource to be deleted.
+     */
+    name?: string;
+  }
+  export interface Params$Resource$Operations$Get extends StandardParameters {
+    /**
+     * The name of the operation resource.
+     */
+    name?: string;
+  }
+  export interface Params$Resource$Operations$List extends StandardParameters {
+    /**
+     * The standard list filter.
+     */
+    filter?: string;
+    /**
+     * The name of the operation's parent resource.
+     */
+    name?: string;
+    /**
+     * The standard list page size.
+     */
+    pageSize?: number;
+    /**
+     * The standard list page token.
+     */
+    pageToken?: string;
+    /**
+     * When set to `true`, operations that are reachable are returned as normal, and those that are unreachable are returned in the ListOperationsResponse.unreachable field. This can only be `true` when reading across collections. For example, when `parent` is set to `"projects/example/locations/-"`. This field is not supported by default and will result in an `UNIMPLEMENTED` error if set unless explicitly documented otherwise in service or product specific documentation.
+     */
+    returnPartialSuccess?: boolean;
+  }
+
+  export class Resource$Outboundendpoints {
+    context: APIRequestContext;
+    constructor(context: APIRequestContext) {
+      this.context = context;
+    }
+
+    /**
+     * Creates a new Outbound Endpoint.
      * @example
      * ```js
      * // Before running the sample:
@@ -3160,8 +5259,6 @@ export namespace dns_v1beta2 {
      *     // 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',
      *     ],
      *   });
@@ -3171,23 +5268,42 @@ export namespace dns_v1beta2 {
      *   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',
+     *   const res = await dns.outboundEndpoints.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',
+     *     // Required. The ID to use for the OutboundEndpoint, which will become the final component of the OutboundEndpoint's resource name.
+     *     outboundEndpointId: 'placeholder-value',
+     *     // Required. The parent project and location where this OutboundEndpoint will be created. Format: projects/{project\}/locations/{location\}
+     *     parent: 'projects/my-project/locations/my-location',
+     *     // Optional. An optional request ID to identify requests.
+     *     requestId: 'placeholder-value',
+     *
+     *     // Request body metadata
+     *     requestBody: {
+     *       // request body parameters
+     *       // {
+     *       //   "annotations": {},
+     *       //   "createTime": "my_createTime",
+     *       //   "description": "my_description",
+     *       //   "endpointIp": "my_endpointIp",
+     *       //   "labels": {},
+     *       //   "name": "my_name",
+     *       //   "network": "my_network",
+     *       //   "subnetwork": "my_subnetwork",
+     *       //   "tags": {},
+     *       //   "updateTime": "my_updateTime"
+     *       // }
+     *     },
      *   });
      *   console.log(res.data);
      *
      *   // Example response
      *   // {
-     *   //   "kind": "my_kind",
-     *   //   "managedZones": [],
-     *   //   "nextPageToken": "my_nextPageToken"
+     *   //   "done": false,
+     *   //   "error": {},
+     *   //   "metadata": {},
+     *   //   "name": "my_name",
+     *   //   "response": {}
      *   // }
      * }
      *
@@ -3203,54 +5319,56 @@ export namespace dns_v1beta2 {
      * @param callback - Optional callback that handles the response.
      * @returns A promise if used with async/await, or void if used with a callback.
      */
-    list(
-      params: Params$Resource$Managedzones$List,
+    create(
+      params: Params$Resource$Outboundendpoints$Create,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
-    list(
-      params?: Params$Resource$Managedzones$List,
+    create(
+      params?: Params$Resource$Outboundendpoints$Create,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<Schema$ManagedZonesListResponse>>;
-    list(
-      params: Params$Resource$Managedzones$List,
+    ): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+    create(
+      params: Params$Resource$Outboundendpoints$Create,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    list(
-      params: Params$Resource$Managedzones$List,
+    create(
+      params: Params$Resource$Outboundendpoints$Create,
       options:
-        MethodOptions | BodyResponseCallback<Schema$ManagedZonesListResponse>,
-      callback: BodyResponseCallback<Schema$ManagedZonesListResponse>
+        MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
     ): void;
-    list(
-      params: Params$Resource$Managedzones$List,
-      callback: BodyResponseCallback<Schema$ManagedZonesListResponse>
+    create(
+      params: Params$Resource$Outboundendpoints$Create,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
     ): void;
-    list(callback: BodyResponseCallback<Schema$ManagedZonesListResponse>): void;
-    list(
+    create(
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    create(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$List
-        | BodyResponseCallback<Schema$ManagedZonesListResponse>
+        | Params$Resource$Outboundendpoints$Create
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$ManagedZonesListResponse>
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$ManagedZonesListResponse>
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<Schema$ManagedZonesListResponse>>
+      | Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzones$List;
+        {}) as Params$Resource$Outboundendpoints$Create;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$List;
+        params = {} as Params$Resource$Outboundendpoints$Create;
         options = {};
       }
 
@@ -3263,31 +5381,32 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl + '/dns/v1beta2/projects/{project}/managedZones'
-            ).replace(/([^:]\/)\/+/g, '$1'),
-            method: 'GET',
+            url: (rootUrl + '/dns/v1beta2/{+parent}/outboundEndpoints').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'POST',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['project'],
-        pathParams: ['project'],
+        requiredParams: ['parent'],
+        pathParams: ['parent'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$ManagedZonesListResponse>(
+        createAPIRequest<Schema$GoogleLongrunningOperation>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$ManagedZonesListResponse>(parameters);
+        return createAPIRequest<Schema$GoogleLongrunningOperation>(parameters);
       }
     }
 
     /**
-     * Applies a partial update to an existing ManagedZone.
+     * Deletes a previously created Outbound Endpoint.
      * @example
      * ```js
      * // Before running the sample:
@@ -3319,50 +5438,23 @@ export namespace dns_v1beta2 {
      *   google.options({auth: authClient});
      *
      *   // Do the magic
-     *   const res = await dns.managedZones.patch({
+     *   const res = await dns.outboundEndpoints.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',
-     *
-     *     // 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"
-     *       // }
-     *     },
+     *     // Required. The name of the OutboundEndpoint to delete. Format: projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}
+     *     name: 'projects/my-project/locations/my-location/outboundEndpoints/my-outboundEndpoint',
+     *     // Optional. An optional request ID to identify requests.
+     *     requestId: '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": {}
+     *   //   "done": false,
+     *   //   "error": {},
+     *   //   "metadata": {},
+     *   //   "name": "my_name",
+     *   //   "response": {}
      *   // }
      * }
      *
@@ -3378,52 +5470,56 @@ export namespace dns_v1beta2 {
      * @param callback - Optional callback that handles the response.
      * @returns A promise if used with async/await, or void if used with a callback.
      */
-    patch(
-      params: Params$Resource$Managedzones$Patch,
+    delete(
+      params: Params$Resource$Outboundendpoints$Delete,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
-    patch(
-      params?: Params$Resource$Managedzones$Patch,
+    delete(
+      params?: Params$Resource$Outboundendpoints$Delete,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
-    patch(
-      params: Params$Resource$Managedzones$Patch,
+    ): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+    delete(
+      params: Params$Resource$Outboundendpoints$Delete,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    patch(
-      params: Params$Resource$Managedzones$Patch,
-      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
-      callback: BodyResponseCallback<Schema$Operation>
+    delete(
+      params: Params$Resource$Outboundendpoints$Delete,
+      options:
+        MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
     ): void;
-    patch(
-      params: Params$Resource$Managedzones$Patch,
-      callback: BodyResponseCallback<Schema$Operation>
+    delete(
+      params: Params$Resource$Outboundendpoints$Delete,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
     ): void;
-    patch(callback: BodyResponseCallback<Schema$Operation>): void;
-    patch(
+    delete(
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    delete(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$Patch
-        | BodyResponseCallback<Schema$Operation>
+        | Params$Resource$Outboundendpoints$Delete
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>,
       callback?:
-        BodyResponseCallback<Schema$Operation> | BodyResponseCallback<Readable>
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
+        | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<Schema$Operation>>
+      | Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzones$Patch;
+        {}) as Params$Resource$Outboundendpoints$Delete;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$Patch;
+        params = {} as Params$Resource$Outboundendpoints$Delete;
         options = {};
       }
 
@@ -3436,32 +5532,32 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl +
-              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}'
-            ).replace(/([^:]\/)\/+/g, '$1'),
-            method: 'PATCH',
+            url: (rootUrl + '/dns/v1beta2/{+name}').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'DELETE',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['project', 'managedZone'],
-        pathParams: ['managedZone', 'project'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$Operation>(
+        createAPIRequest<Schema$GoogleLongrunningOperation>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$Operation>(parameters);
+        return createAPIRequest<Schema$GoogleLongrunningOperation>(parameters);
       }
     }
 
     /**
-     * Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
+     * Fetches the representation of an existing Outbound Endpoint.
      * @example
      * ```js
      * // Before running the sample:
@@ -3484,6 +5580,8 @@ export namespace dns_v1beta2 {
      *     // 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',
      *     ],
      *   });
@@ -3493,27 +5591,26 @@ export namespace dns_v1beta2 {
      *   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"
-     *       // }
-     *     },
+     *   const res = await dns.outboundEndpoints.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',
+     *     // Required. The name of the OutboundEndpoint to retrieve. Format: projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}
+     *     name: 'projects/my-project/locations/my-location/outboundEndpoints/my-outboundEndpoint',
      *   });
      *   console.log(res.data);
      *
      *   // Example response
      *   // {
-     *   //   "auditConfigs": [],
-     *   //   "bindings": [],
-     *   //   "etag": "my_etag",
-     *   //   "version": 0
+     *   //   "annotations": {},
+     *   //   "createTime": "my_createTime",
+     *   //   "description": "my_description",
+     *   //   "endpointIp": "my_endpointIp",
+     *   //   "labels": {},
+     *   //   "name": "my_name",
+     *   //   "network": "my_network",
+     *   //   "subnetwork": "my_subnetwork",
+     *   //   "tags": {},
+     *   //   "updateTime": "my_updateTime"
      *   // }
      * }
      *
@@ -3529,55 +5626,53 @@ export namespace dns_v1beta2 {
      * @param callback - Optional callback that handles the response.
      * @returns A promise if used with async/await, or void if used with a callback.
      */
-    setIamPolicy(
-      params: Params$Resource$Managedzones$Setiampolicy,
+    get(
+      params: Params$Resource$Outboundendpoints$Get,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
-    setIamPolicy(
-      params?: Params$Resource$Managedzones$Setiampolicy,
+    get(
+      params?: Params$Resource$Outboundendpoints$Get,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>;
-    setIamPolicy(
-      params: Params$Resource$Managedzones$Setiampolicy,
+    ): Promise<GaxiosResponseWithHTTP2<Schema$OutboundEndpoint>>;
+    get(
+      params: Params$Resource$Outboundendpoints$Get,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    setIamPolicy(
-      params: Params$Resource$Managedzones$Setiampolicy,
-      options: MethodOptions | BodyResponseCallback<Schema$GoogleIamV1Policy>,
-      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
-    ): void;
-    setIamPolicy(
-      params: Params$Resource$Managedzones$Setiampolicy,
-      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    get(
+      params: Params$Resource$Outboundendpoints$Get,
+      options: MethodOptions | BodyResponseCallback<Schema$OutboundEndpoint>,
+      callback: BodyResponseCallback<Schema$OutboundEndpoint>
     ): void;
-    setIamPolicy(
-      callback: BodyResponseCallback<Schema$GoogleIamV1Policy>
+    get(
+      params: Params$Resource$Outboundendpoints$Get,
+      callback: BodyResponseCallback<Schema$OutboundEndpoint>
     ): void;
-    setIamPolicy(
+    get(callback: BodyResponseCallback<Schema$OutboundEndpoint>): void;
+    get(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$Setiampolicy
-        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | Params$Resource$Outboundendpoints$Get
+        | BodyResponseCallback<Schema$OutboundEndpoint>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Schema$OutboundEndpoint>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$GoogleIamV1Policy>
+        | BodyResponseCallback<Schema$OutboundEndpoint>
         | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<Schema$GoogleIamV1Policy>>
+      | Promise<GaxiosResponseWithHTTP2<Schema$OutboundEndpoint>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzones$Setiampolicy;
+        {}) as Params$Resource$Outboundendpoints$Get;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$Setiampolicy;
+        params = {} as Params$Resource$Outboundendpoints$Get;
         options = {};
       }
 
@@ -3590,32 +5685,32 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (rootUrl + '/dns/v1beta2/{+resource}:setIamPolicy').replace(
+            url: (rootUrl + '/dns/v1beta2/{+name}').replace(
               /([^:]\/)\/+/g,
               '$1'
             ),
-            method: 'POST',
+            method: 'GET',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['resource'],
-        pathParams: ['resource'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$GoogleIamV1Policy>(
+        createAPIRequest<Schema$OutboundEndpoint>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$GoogleIamV1Policy>(parameters);
+        return createAPIRequest<Schema$OutboundEndpoint>(parameters);
       }
     }
 
     /**
-     * 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.
+     * Enumerates all Outbound Endpoints associated with a project.
      * @example
      * ```js
      * // Before running the sample:
@@ -3649,23 +5744,22 @@ export namespace dns_v1beta2 {
      *   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": []
-     *       // }
-     *     },
+     *   const res = await dns.outboundEndpoints.list({
+     *     clientOperationId: 'placeholder-value',
+     *     // Optional. The maximum number of results to return.
+     *     pageSize: 'placeholder-value',
+     *     // Optional. A page token received from a previous List call.
+     *     pageToken: 'placeholder-value',
+     *     // Required. The parent project and location from which to list resources. Format: projects/{project\}/locations/{location\}
+     *     parent: 'projects/my-project/locations/my-location',
      *   });
      *   console.log(res.data);
      *
      *   // Example response
      *   // {
-     *   //   "permissions": []
+     *   //   "nextPageToken": "my_nextPageToken",
+     *   //   "outboundEndpoints": [],
+     *   //   "unreachable": []
      *   // }
      * }
      *
@@ -3681,61 +5775,57 @@ export namespace dns_v1beta2 {
      * @param callback - Optional callback that handles the response.
      * @returns A promise if used with async/await, or void if used with a callback.
      */
-    testIamPermissions(
-      params: Params$Resource$Managedzones$Testiampermissions,
+    list(
+      params: Params$Resource$Outboundendpoints$List,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
-    testIamPermissions(
-      params?: Params$Resource$Managedzones$Testiampermissions,
+    list(
+      params?: Params$Resource$Outboundendpoints$List,
       options?: MethodOptions
-    ): Promise<
-      GaxiosResponseWithHTTP2<Schema$GoogleIamV1TestIamPermissionsResponse>
-    >;
-    testIamPermissions(
-      params: Params$Resource$Managedzones$Testiampermissions,
+    ): Promise<GaxiosResponseWithHTTP2<Schema$ListOutboundEndpointsResponse>>;
+    list(
+      params: Params$Resource$Outboundendpoints$List,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    testIamPermissions(
-      params: Params$Resource$Managedzones$Testiampermissions,
+    list(
+      params: Params$Resource$Outboundendpoints$List,
       options:
         | MethodOptions
-        | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>,
-      callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+        | BodyResponseCallback<Schema$ListOutboundEndpointsResponse>,
+      callback: BodyResponseCallback<Schema$ListOutboundEndpointsResponse>
     ): void;
-    testIamPermissions(
-      params: Params$Resource$Managedzones$Testiampermissions,
-      callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+    list(
+      params: Params$Resource$Outboundendpoints$List,
+      callback: BodyResponseCallback<Schema$ListOutboundEndpointsResponse>
     ): void;
-    testIamPermissions(
-      callback: BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+    list(
+      callback: BodyResponseCallback<Schema$ListOutboundEndpointsResponse>
     ): void;
-    testIamPermissions(
+    list(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$Testiampermissions
-        | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+        | Params$Resource$Outboundendpoints$List
+        | BodyResponseCallback<Schema$ListOutboundEndpointsResponse>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+        | BodyResponseCallback<Schema$ListOutboundEndpointsResponse>
         | BodyResponseCallback<Readable>,
       callback?:
-        | BodyResponseCallback<Schema$GoogleIamV1TestIamPermissionsResponse>
+        | BodyResponseCallback<Schema$ListOutboundEndpointsResponse>
         | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<
-          GaxiosResponseWithHTTP2<Schema$GoogleIamV1TestIamPermissionsResponse>
-        >
+      | Promise<GaxiosResponseWithHTTP2<Schema$ListOutboundEndpointsResponse>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzones$Testiampermissions;
+        {}) as Params$Resource$Outboundendpoints$List;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$Testiampermissions;
+        params = {} as Params$Resource$Outboundendpoints$List;
         options = {};
       }
 
@@ -3748,33 +5838,34 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl + '/dns/v1beta2/{+resource}:testIamPermissions'
-            ).replace(/([^:]\/)\/+/g, '$1'),
-            method: 'POST',
+            url: (rootUrl + '/dns/v1beta2/{+parent}/outboundEndpoints').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'GET',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['resource'],
-        pathParams: ['resource'],
+        requiredParams: ['parent'],
+        pathParams: ['parent'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$GoogleIamV1TestIamPermissionsResponse>(
+        createAPIRequest<Schema$ListOutboundEndpointsResponse>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$GoogleIamV1TestIamPermissionsResponse>(
+        return createAPIRequest<Schema$ListOutboundEndpointsResponse>(
           parameters
         );
       }
     }
 
     /**
-     * Updates an existing ManagedZone.
+     * Updates an existing Outbound Endpoint.
      * @example
      * ```js
      * // Before running the sample:
@@ -3806,35 +5897,30 @@ export namespace dns_v1beta2 {
      *   google.options({auth: authClient});
      *
      *   // Do the magic
-     *   const res = await dns.managedZones.update({
+     *   const res = await dns.outboundEndpoints.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',
+     *     // Identifier. The resource name of the OutboundEndpoint. Format: `projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}`
+     *     name: 'projects/my-project/locations/my-location/outboundEndpoints/my-outboundEndpoint',
+     *     // Optional. An optional request ID to identify requests.
+     *     requestId: 'placeholder-value',
+     *     // Required. The list of fields to be updated.
+     *     updateMask: 'placeholder-value',
      *
      *     // Request body metadata
      *     requestBody: {
      *       // request body parameters
      *       // {
-     *       //   "cloudLoggingConfig": {},
-     *       //   "creationTime": "my_creationTime",
+     *       //   "annotations": {},
+     *       //   "createTime": "my_createTime",
      *       //   "description": "my_description",
-     *       //   "dnsName": "my_dnsName",
-     *       //   "dnssecConfig": {},
-     *       //   "forwardingConfig": {},
-     *       //   "id": "my_id",
-     *       //   "kind": "my_kind",
+     *       //   "endpointIp": "my_endpointIp",
      *       //   "labels": {},
      *       //   "name": "my_name",
-     *       //   "nameServerSet": "my_nameServerSet",
-     *       //   "nameServers": [],
-     *       //   "peeringConfig": {},
-     *       //   "privateVisibilityConfig": {},
-     *       //   "reverseLookupConfig": {},
-     *       //   "serviceDirectoryConfig": {},
-     *       //   "visibility": "my_visibility"
+     *       //   "network": "my_network",
+     *       //   "subnetwork": "my_subnetwork",
+     *       //   "tags": {},
+     *       //   "updateTime": "my_updateTime"
      *       // }
      *     },
      *   });
@@ -3842,14 +5928,11 @@ export namespace dns_v1beta2 {
      *
      *   // Example response
      *   // {
-     *   //   "dnsKeyContext": {},
-     *   //   "id": "my_id",
-     *   //   "kind": "my_kind",
-     *   //   "startTime": "my_startTime",
-     *   //   "status": "my_status",
-     *   //   "type": "my_type",
-     *   //   "user": "my_user",
-     *   //   "zoneContext": {}
+     *   //   "done": false,
+     *   //   "error": {},
+     *   //   "metadata": {},
+     *   //   "name": "my_name",
+     *   //   "response": {}
      *   // }
      * }
      *
@@ -3865,52 +5948,56 @@ export namespace dns_v1beta2 {
      * @param callback - Optional callback that handles the response.
      * @returns A promise if used with async/await, or void if used with a callback.
      */
-    update(
-      params: Params$Resource$Managedzones$Update,
+    patch(
+      params: Params$Resource$Outboundendpoints$Patch,
       options: StreamMethodOptions
     ): Promise<GaxiosResponseWithHTTP2<Readable>>;
-    update(
-      params?: Params$Resource$Managedzones$Update,
+    patch(
+      params?: Params$Resource$Outboundendpoints$Patch,
       options?: MethodOptions
-    ): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
-    update(
-      params: Params$Resource$Managedzones$Update,
+    ): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+    patch(
+      params: Params$Resource$Outboundendpoints$Patch,
       options: StreamMethodOptions | BodyResponseCallback<Readable>,
       callback: BodyResponseCallback<Readable>
     ): void;
-    update(
-      params: Params$Resource$Managedzones$Update,
-      options: MethodOptions | BodyResponseCallback<Schema$Operation>,
-      callback: BodyResponseCallback<Schema$Operation>
+    patch(
+      params: Params$Resource$Outboundendpoints$Patch,
+      options:
+        MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
     ): void;
-    update(
-      params: Params$Resource$Managedzones$Update,
-      callback: BodyResponseCallback<Schema$Operation>
+    patch(
+      params: Params$Resource$Outboundendpoints$Patch,
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
     ): void;
-    update(callback: BodyResponseCallback<Schema$Operation>): void;
-    update(
+    patch(
+      callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>
+    ): void;
+    patch(
       paramsOrCallback?:
-        | Params$Resource$Managedzones$Update
-        | BodyResponseCallback<Schema$Operation>
+        | Params$Resource$Outboundendpoints$Patch
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>,
       optionsOrCallback?:
         | MethodOptions
         | StreamMethodOptions
-        | BodyResponseCallback<Schema$Operation>
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
         | BodyResponseCallback<Readable>,
       callback?:
-        BodyResponseCallback<Schema$Operation> | BodyResponseCallback<Readable>
+        | BodyResponseCallback<Schema$GoogleLongrunningOperation>
+        | BodyResponseCallback<Readable>
     ):
       | void
-      | Promise<GaxiosResponseWithHTTP2<Schema$Operation>>
+      | Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>
       | Promise<GaxiosResponseWithHTTP2<Readable>> {
       let params = (paramsOrCallback ||
-        {}) as Params$Resource$Managedzones$Update;
+        {}) as Params$Resource$Outboundendpoints$Patch;
       let options = (optionsOrCallback || {}) as MethodOptions;
 
       if (typeof paramsOrCallback === 'function') {
         callback = paramsOrCallback;
-        params = {} as Params$Resource$Managedzones$Update;
+        params = {} as Params$Resource$Outboundendpoints$Patch;
         options = {};
       }
 
@@ -3923,162 +6010,118 @@ export namespace dns_v1beta2 {
       const parameters = {
         options: Object.assign(
           {
-            url: (
-              rootUrl +
-              '/dns/v1beta2/projects/{project}/managedZones/{managedZone}'
-            ).replace(/([^:]\/)\/+/g, '$1'),
-            method: 'PUT',
+            url: (rootUrl + '/dns/v1beta2/{+name}').replace(
+              /([^:]\/)\/+/g,
+              '$1'
+            ),
+            method: 'PATCH',
             apiVersion: '',
           },
           options
         ),
         params,
-        requiredParams: ['project', 'managedZone'],
-        pathParams: ['managedZone', 'project'],
+        requiredParams: ['name'],
+        pathParams: ['name'],
         context: this.context,
       };
       if (callback) {
-        createAPIRequest<Schema$Operation>(
+        createAPIRequest<Schema$GoogleLongrunningOperation>(
           parameters,
           callback as BodyResponseCallback<unknown>
         );
       } else {
-        return createAPIRequest<Schema$Operation>(parameters);
+        return createAPIRequest<Schema$GoogleLongrunningOperation>(parameters);
       }
     }
   }
 
-  export interface Params$Resource$Managedzones$Create extends StandardParameters {
+  export interface Params$Resource$Outboundendpoints$Create extends StandardParameters {
     /**
      * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
      */
     clientOperationId?: string;
     /**
-     * Identifies the project addressed by this request.
-     */
-    project?: string;
-
-    /**
-     * Request body metadata
+     * Required. The ID to use for the OutboundEndpoint, which will become the final component of the OutboundEndpoint's resource name.
      */
-    requestBody?: Schema$ManagedZone;
-  }
-  export interface Params$Resource$Managedzones$Delete extends StandardParameters {
+    outboundEndpointId?: string;
     /**
-     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     * Required. The parent project and location where this OutboundEndpoint will be created. Format: projects/{project\}/locations/{location\}
      */
-    clientOperationId?: string;
+    parent?: string;
     /**
-     * Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     * Optional. An optional request ID to identify requests.
      */
-    managedZone?: string;
+    requestId?: string;
+
     /**
-     * Identifies the project addressed by this request.
+     * Request body metadata
      */
-    project?: string;
+    requestBody?: Schema$OutboundEndpoint;
   }
-  export interface Params$Resource$Managedzones$Get extends StandardParameters {
+  export interface Params$Resource$Outboundendpoints$Delete extends StandardParameters {
     /**
      * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
      */
     clientOperationId?: string;
     /**
-     * Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     * Required. The name of the OutboundEndpoint to delete. Format: projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}
      */
-    managedZone?: string;
+    name?: string;
     /**
-     * Identifies the project addressed by this request.
+     * Optional. An optional request ID to identify requests.
      */
-    project?: string;
+    requestId?: string;
   }
-  export interface Params$Resource$Managedzones$Getiampolicy extends StandardParameters {
+  export interface Params$Resource$Outboundendpoints$Get extends StandardParameters {
     /**
-     * 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.
+     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
      */
-    resource?: string;
-
+    clientOperationId?: string;
     /**
-     * Request body metadata
+     * Required. The name of the OutboundEndpoint to retrieve. Format: projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}
      */
-    requestBody?: Schema$GoogleIamV1GetIamPolicyRequest;
+    name?: string;
   }
-  export interface Params$Resource$Managedzones$List extends StandardParameters {
+  export interface Params$Resource$Outboundendpoints$List extends StandardParameters {
     /**
-     * Restricts the list to return only zones with this domain name.
+     *
      */
-    dnsName?: string;
+    clientOperationId?: string;
     /**
-     * Optional. Maximum number of results to be returned. If unspecified, the server decides how many results to return.
+     * Optional. The maximum number of results to return.
      */
-    maxResults?: number;
+    pageSize?: number;
     /**
-     * Optional. A tag returned by a previous list request that was truncated. Use this parameter to continue a previous list request.
+     * Optional. A page token received from a previous List call.
      */
     pageToken?: string;
     /**
-     * Identifies the project addressed by this request.
+     * Required. The parent project and location from which to list resources. Format: projects/{project\}/locations/{location\}
      */
-    project?: string;
+    parent?: string;
   }
-  export interface Params$Resource$Managedzones$Patch extends StandardParameters {
+  export interface Params$Resource$Outboundendpoints$Patch extends StandardParameters {
     /**
      * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
      */
     clientOperationId?: string;
     /**
-     * Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
-     */
-    managedZone?: string;
-    /**
-     * Identifies the project addressed by this request.
-     */
-    project?: string;
-
-    /**
-     * Request body metadata
-     */
-    requestBody?: Schema$ManagedZone;
-  }
-  export interface Params$Resource$Managedzones$Setiampolicy extends StandardParameters {
-    /**
-     * 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?: string;
-
-    /**
-     * Request body metadata
-     */
-    requestBody?: Schema$GoogleIamV1SetIamPolicyRequest;
-  }
-  export interface Params$Resource$Managedzones$Testiampermissions extends StandardParameters {
-    /**
-     * 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?: string;
-
-    /**
-     * Request body metadata
-     */
-    requestBody?: Schema$GoogleIamV1TestIamPermissionsRequest;
-  }
-  export interface Params$Resource$Managedzones$Update extends StandardParameters {
-    /**
-     * For mutating operation requests only. An optional identifier specified by the client. Must be unique for operation resources in the Operations collection.
+     * Identifier. The resource name of the OutboundEndpoint. Format: `projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}`
      */
-    clientOperationId?: string;
+    name?: string;
     /**
-     * Identifies the managed zone addressed by this request. Can be the managed zone name or ID.
+     * Optional. An optional request ID to identify requests.
      */
-    managedZone?: string;
+    requestId?: string;
     /**
-     * Identifies the project addressed by this request.
+     * Required. The list of fields to be updated.
      */
-    project?: string;
+    updateMask?: string;
 
     /**
      * Request body metadata
      */
-    requestBody?: Schema$ManagedZone;
+    requestBody?: Schema$OutboundEndpoint;
   }
 
   export class Resource$Policies {