@googleapis/dns 17.0.0 → 17.2.0

package/build/v1beta2.d.ts

@@ -69,8 +69,11 @@ export declare 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;
@@ -216,6 +219,11 @@ export declare 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.
      */
@@ -350,6 +358,23 @@ export declare 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.
      */
@@ -379,6 +404,65 @@ export declare namespace dns_v1beta2 {
             [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.
      */
@@ -475,6 +559,10 @@ export declare 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.
          */
@@ -499,6 +587,13 @@ export declare 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.
@@ -648,6 +743,90 @@ export declare 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.
@@ -708,11 +887,22 @@ export declare 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.
@@ -824,6 +1014,14 @@ export declare 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
          */
@@ -1691,6 +1889,181 @@ export declare namespace dns_v1beta2 {
          */
         project?: string;
     }
+    export class Resource$Locations {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * Gets information about a location.
+         * @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.locations.get({
+         *     // Resource name for the location.
+         *     name: 'projects/my-project/locations/my-location',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "displayName": "my_displayName",
+         *   //   "labels": {},
+         *   //   "locationId": "my_locationId",
+         *   //   "metadata": {},
+         *   //   "name": "my_name"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @param callback - Optional callback that handles the response.
+         * @returns A promise if used with async/await, or void if used with a callback.
+         */
+        get(params: Params$Resource$Locations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Locations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Location>>;
+        get(params: Params$Resource$Locations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Locations$Get, options: MethodOptions | BodyResponseCallback<Schema$Location>, callback: BodyResponseCallback<Schema$Location>): void;
+        get(params: Params$Resource$Locations$Get, callback: BodyResponseCallback<Schema$Location>): void;
+        get(callback: BodyResponseCallback<Schema$Location>): void;
+        /**
+         * 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:
+         * // - 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.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',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "locations": [],
+         *   //   "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$Locations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Locations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListLocationsResponse>>;
+        list(params: Params$Resource$Locations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Locations$List, options: MethodOptions | BodyResponseCallback<Schema$ListLocationsResponse>, callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
+        list(params: Params$Resource$Locations$List, callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
+    }
+    export interface Params$Resource$Locations$Get extends StandardParameters {
+        /**
+         * Resource name for the location.
+         */
+        name?: string;
+    }
+    export interface Params$Resource$Locations$List extends StandardParameters {
+        /**
+         * Optional. Do not use this field unless explicitly documented otherwise. This is primarily for internal usage.
+         */
+        extraLocationTypes?: string[];
+        /**
+         * 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?: string;
+        /**
+         * The resource that owns the locations collection, if applicable.
+         */
+        name?: string;
+        /**
+         * The maximum number of results to return. If not set, the service selects a default.
+         */
+        pageSize?: number;
+        /**
+         * A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.
+         */
+        pageToken?: string;
+    }
     export class Resource$Managedzoneoperations {
         context: APIRequestContext;
         constructor(context: APIRequestContext);
@@ -2763,6 +3136,801 @@ export declare namespace dns_v1beta2 {
          */
         requestBody?: Schema$ManagedZone;
     }
+    export class Resource$Operations {
+        context: APIRequestContext;
+        constructor(context: APIRequestContext);
+        /**
+         * 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 => {
+         *   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.
+         */
+        cancel(params: Params$Resource$Operations$Cancel, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        cancel(params?: Params$Resource$Operations$Cancel, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
+        cancel(params: Params$Resource$Operations$Cancel, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        cancel(params: Params$Resource$Operations$Cancel, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
+        cancel(params: Params$Resource$Operations$Cancel, callback: BodyResponseCallback<Schema$Empty>): void;
+        cancel(callback: BodyResponseCallback<Schema$Empty>): void;
+        /**
+         * 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:
+         * // - 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.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 => {
+         *   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$Operations$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Operations$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
+        delete(params: Params$Resource$Operations$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        delete(params: Params$Resource$Operations$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
+        delete(params: Params$Resource$Operations$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
+        delete(callback: BodyResponseCallback<Schema$Empty>): void;
+        /**
+         * Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/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.get({
+         *     // The name of the operation resource.
+         *     name: 'projects/my-project/locations/my-location/operations/my-operation',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @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$Operations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Operations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+        get(params: Params$Resource$Operations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Operations$Get, options: MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        get(params: Params$Resource$Operations$Get, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        get(callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        /**
+         * 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:
+         * // - 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.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
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "operations": [],
+         *   //   "unreachable": []
+         *   // }
+         * }
+         *
+         * 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$Operations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Operations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningListOperationsResponse>>;
+        list(params: Params$Resource$Operations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Operations$List, options: MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>, callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>): void;
+        list(params: Params$Resource$Operations$List, callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>): void;
+        list(callback: BodyResponseCallback<Schema$GoogleLongrunningListOperationsResponse>): void;
+    }
+    export interface Params$Resource$Operations$Cancel extends StandardParameters {
+        /**
+         * 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);
+        /**
+         * Creates a new Outbound Endpoint.
+         * @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.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
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @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$Outboundendpoints$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Outboundendpoints$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+        create(params: Params$Resource$Outboundendpoints$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        create(params: Params$Resource$Outboundendpoints$Create, options: MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        create(params: Params$Resource$Outboundendpoints$Create, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        create(callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        /**
+         * Deletes a previously created Outbound Endpoint.
+         * @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.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',
+         *     // 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
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @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$Outboundendpoints$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Outboundendpoints$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+        delete(params: Params$Resource$Outboundendpoints$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        delete(params: Params$Resource$Outboundendpoints$Delete, options: MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        delete(params: Params$Resource$Outboundendpoints$Delete, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        delete(callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        /**
+         * Fetches the representation of an existing Outbound Endpoint.
+         * @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.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
+         *   // {
+         *   //   "annotations": {},
+         *   //   "createTime": "my_createTime",
+         *   //   "description": "my_description",
+         *   //   "endpointIp": "my_endpointIp",
+         *   //   "labels": {},
+         *   //   "name": "my_name",
+         *   //   "network": "my_network",
+         *   //   "subnetwork": "my_subnetwork",
+         *   //   "tags": {},
+         *   //   "updateTime": "my_updateTime"
+         *   // }
+         * }
+         *
+         * 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$Outboundendpoints$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Outboundendpoints$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$OutboundEndpoint>>;
+        get(params: Params$Resource$Outboundendpoints$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        get(params: Params$Resource$Outboundendpoints$Get, options: MethodOptions | BodyResponseCallback<Schema$OutboundEndpoint>, callback: BodyResponseCallback<Schema$OutboundEndpoint>): void;
+        get(params: Params$Resource$Outboundendpoints$Get, callback: BodyResponseCallback<Schema$OutboundEndpoint>): void;
+        get(callback: BodyResponseCallback<Schema$OutboundEndpoint>): void;
+        /**
+         * Enumerates all Outbound Endpoints associated with a project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/dns.googleapis.com
+         * // - Login into gcloud by running:
+         * //   ```sh
+         * //   $ gcloud auth application-default login
+         * //   ```
+         * // - Install the npm module by running:
+         * //   ```sh
+         * //   $ npm install googleapis
+         * //   ```
+         *
+         * const {google} = require('googleapis');
+         * const dns = google.dns('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.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
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "outboundEndpoints": [],
+         *   //   "unreachable": []
+         *   // }
+         * }
+         *
+         * 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$Outboundendpoints$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Outboundendpoints$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListOutboundEndpointsResponse>>;
+        list(params: Params$Resource$Outboundendpoints$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        list(params: Params$Resource$Outboundendpoints$List, options: MethodOptions | BodyResponseCallback<Schema$ListOutboundEndpointsResponse>, callback: BodyResponseCallback<Schema$ListOutboundEndpointsResponse>): void;
+        list(params: Params$Resource$Outboundendpoints$List, callback: BodyResponseCallback<Schema$ListOutboundEndpointsResponse>): void;
+        list(callback: BodyResponseCallback<Schema$ListOutboundEndpointsResponse>): void;
+        /**
+         * Updates an existing Outbound Endpoint.
+         * @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.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',
+         *     // 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
+         *       // {
+         *       //   "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
+         *   // {
+         *   //   "done": false,
+         *   //   "error": {},
+         *   //   "metadata": {},
+         *   //   "name": "my_name",
+         *   //   "response": {}
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
+         *
+         * @param params - Parameters for request
+         * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
+         * @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$Outboundendpoints$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Outboundendpoints$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GoogleLongrunningOperation>>;
+        patch(params: Params$Resource$Outboundendpoints$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
+        patch(params: Params$Resource$Outboundendpoints$Patch, options: MethodOptions | BodyResponseCallback<Schema$GoogleLongrunningOperation>, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        patch(params: Params$Resource$Outboundendpoints$Patch, callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+        patch(callback: BodyResponseCallback<Schema$GoogleLongrunningOperation>): void;
+    }
+    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;
+        /**
+         * Required. The ID to use for the OutboundEndpoint, which will become the final component of the OutboundEndpoint's resource name.
+         */
+        outboundEndpointId?: string;
+        /**
+         * Required. The parent project and location where this OutboundEndpoint will be created. Format: projects/{project\}/locations/{location\}
+         */
+        parent?: string;
+        /**
+         * Optional. An optional request ID to identify requests.
+         */
+        requestId?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$OutboundEndpoint;
+    }
+    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;
+        /**
+         * Required. The name of the OutboundEndpoint to delete. Format: projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}
+         */
+        name?: string;
+        /**
+         * Optional. An optional request ID to identify requests.
+         */
+        requestId?: string;
+    }
+    export interface Params$Resource$Outboundendpoints$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;
+        /**
+         * Required. The name of the OutboundEndpoint to retrieve. Format: projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}
+         */
+        name?: string;
+    }
+    export interface Params$Resource$Outboundendpoints$List extends StandardParameters {
+        /**
+         *
+         */
+        clientOperationId?: string;
+        /**
+         * Optional. The maximum number of results to return.
+         */
+        pageSize?: number;
+        /**
+         * Optional. A page token received from a previous List call.
+         */
+        pageToken?: string;
+        /**
+         * Required. The parent project and location from which to list resources. Format: projects/{project\}/locations/{location\}
+         */
+        parent?: string;
+    }
+    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;
+        /**
+         * Identifier. The resource name of the OutboundEndpoint. Format: `projects/{project\}/locations/{location\}/outboundEndpoints/{outboundEndpoint\}`
+         */
+        name?: string;
+        /**
+         * Optional. An optional request ID to identify requests.
+         */
+        requestId?: string;
+        /**
+         * Required. The list of fields to be updated.
+         */
+        updateMask?: string;
+        /**
+         * Request body metadata
+         */
+        requestBody?: Schema$OutboundEndpoint;
+    }
     export class Resource$Policies {
         context: APIRequestContext;
         constructor(context: APIRequestContext);