@googleapis/servicenetworking 21.7.0 → 23.1.0

package/build/v1.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosPromise, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
+import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
 import { Readable } from 'stream';
 export declare namespace servicenetworking_v1 {
     export interface Options extends GlobalOptions {
@@ -205,7 +205,7 @@ export declare namespace servicenetworking_v1 {
          */
         purpose?: string | null;
         /**
-         * Required. The name of a [region](/compute/docs/regions-zones) for the subnet, such `europe-west1`.
+         * Required. The name of a [region](https://cloud.google.com/compute/docs/regions-zones) for the subnet, such `europe-west1`.
          */
         region?: string | null;
         /**
@@ -229,7 +229,7 @@ export declare namespace servicenetworking_v1 {
          */
         skipRequestedAddressValidation?: boolean | null;
         /**
-         * Required. A name for the new subnet. For information about the naming requirements, see [subnetwork](/compute/docs/reference/rest/v1/subnetworks) in the Compute API documentation.
+         * Required. A name for the new subnet. For information about the naming requirements, see [subnetwork](https://cloud.google.com/compute/docs/reference/rest/v1/subnetworks) in the Compute API documentation.
          */
         subnetwork?: string | null;
         /**
@@ -283,7 +283,7 @@ export declare namespace servicenetworking_v1 {
          */
         kind?: string | null;
         /**
-         * Content of the configuration. The underlying schema should be defined by Aspect owners as protobuf message under `apiserving/configaspects/proto`.
+         * Content of the configuration. The underlying schema should be defined by Aspect owners as protobuf message under `google/api/configaspects/proto`.
          */
         spec?: {
             [key: string]: any;
@@ -422,6 +422,73 @@ export declare namespace servicenetworking_v1 {
          */
         selector?: string | null;
     }
+    /**
+     * `BatchingConfigProto` defines the batching configuration for an API method.
+     */
+    export interface Schema$BatchingConfigProto {
+        /**
+         * The request and response fields used in batching.
+         */
+        batchDescriptor?: Schema$BatchingDescriptorProto;
+        /**
+         * The thresholds which trigger a batched request to be sent.
+         */
+        thresholds?: Schema$BatchingSettingsProto;
+    }
+    /**
+     * `BatchingDescriptorProto` specifies the fields of the request message to be used for batching, and, optionally, the fields of the response message to be used for demultiplexing.
+     */
+    export interface Schema$BatchingDescriptorProto {
+        /**
+         * The repeated field in the request message to be aggregated by batching.
+         */
+        batchedField?: string | null;
+        /**
+         * A list of the fields in the request message. Two requests will be batched together only if the values of every field specified in `request_discriminator_fields` is equal between the two requests.
+         */
+        discriminatorFields?: string[] | null;
+        /**
+         * Optional. When present, indicates the field in the response message to be used to demultiplex the response into multiple response messages, in correspondence with the multiple request messages originally batched together.
+         */
+        subresponseField?: string | null;
+    }
+    /**
+     * `BatchingSettingsProto` specifies a set of batching thresholds, each of which acts as a trigger to send a batch of messages as a request. At least one threshold must be positive nonzero.
+     */
+    export interface Schema$BatchingSettingsProto {
+        /**
+         * The duration after which a batch should be sent, starting from the addition of the first message to that batch.
+         */
+        delayThreshold?: string | null;
+        /**
+         * The maximum number of elements collected in a batch that could be accepted by server.
+         */
+        elementCountLimit?: number | null;
+        /**
+         * The number of elements of a field collected into a batch which, if exceeded, causes the batch to be sent.
+         */
+        elementCountThreshold?: number | null;
+        /**
+         * The maximum size of data allowed by flow control.
+         */
+        flowControlByteLimit?: number | null;
+        /**
+         * The maximum number of elements allowed by flow control.
+         */
+        flowControlElementLimit?: number | null;
+        /**
+         * The behavior to take when the flow control limit is exceeded.
+         */
+        flowControlLimitExceededBehavior?: string | null;
+        /**
+         * The maximum size of the request that could be accepted by server.
+         */
+        requestByteLimit?: number | null;
+        /**
+         * The aggregated size of the batched field which, if exceeded, causes the batch to be sent. This size is computed by aggregating the sizes of the request field to be batched, not of the entire request message.
+         */
+        requestByteThreshold?: string | null;
+    }
     /**
      * Billing related configuration of the service. The following example shows how to configure monitored resources and metrics for billing, `consumer_destinations` is the only supported destination and the monitored resources need at least one label key `cloud.googleapis.com/location` to indicate the location of the billing usage, using different monitored resources between monitoring and billing is recommended so they can be evolved independently: monitored_resources: - type: library.googleapis.com/billing_branch labels: - key: cloud.googleapis.com/location description: | Predefined label to support billing location restriction. - key: city description: | Custom label to define the city where the library branch is located in. - key: name description: Custom label to define the name of the library branch. metrics: - name: library.googleapis.com/book/borrowed_count metric_kind: DELTA value_type: INT64 unit: "1" billing: consumer_destinations: - monitored_resource: library.googleapis.com/billing_branch metrics: - library.googleapis.com/book/borrowed_count
      */
@@ -449,6 +516,11 @@ export declare namespace servicenetworking_v1 {
      */
     export interface Schema$CancelOperationRequest {
     }
+    /**
+     * Metadata provided through GetOperation request for the LRO generated by Cleanup Connection API
+     */
+    export interface Schema$CleanupConnectionMetadata {
+    }
     /**
      * Details about how and where to publish client libraries.
      */
@@ -503,15 +575,15 @@ export declare namespace servicenetworking_v1 {
      */
     export interface Schema$CloudSQLConfig {
         /**
-         * Peering service used for peering with the Cloud SQL project.
+         * Required. Peering service used for peering with the Cloud SQL project.
          */
         service?: string | null;
         /**
-         * The name of the umbrella network in the Cloud SQL umbrella project.
+         * Required. The name of the umbrella network in the Cloud SQL umbrella project.
          */
         umbrellaNetwork?: string | null;
         /**
-         * The project number of the Cloud SQL umbrella project.
+         * Required. The project number of the Cloud SQL umbrella project.
          */
         umbrellaProject?: string | null;
     }
@@ -537,7 +609,7 @@ export declare namespace servicenetworking_v1 {
      */
     export interface Schema$Connection {
         /**
-         * The name of service consumer's VPC network that's connected with service producer network, in the following format: `projects/{project\}/global/networks/{network\}`. `{project\}` is a project number, such as in `12345` that includes the VPC service consumer's VPC network. `{network\}` is the name of the service consumer's VPC network.
+         * Required. The name of service consumer's VPC network that's connected with service producer network, in the following format: `projects/{project\}/global/networks/{network\}`. `{project\}` is a project number, such as in `12345` that includes the VPC service consumer's VPC network. `{network\}` is the name of the service consumer's VPC network.
          */
         network?: string | null;
         /**
@@ -1418,6 +1490,10 @@ export declare namespace servicenetworking_v1 {
          * List of top-level fields of the request message, that should be automatically populated by the client libraries based on their (google.api.field_info).format. Currently supported format: UUID4. Example of a YAML configuration: publishing: method_settings: - selector: google.example.v1.ExampleService.CreateExample auto_populated_fields: - request_id
          */
         autoPopulatedFields?: string[] | null;
+        /**
+         * Batching configuration for an API method in client libraries. Example of a YAML configuration: publishing: method_settings: - selector: google.example.v1.ExampleService.BatchCreateExample batching: element_count_threshold: 1000 request_byte_threshold: 100000000 delay_threshold_millis: 10
+         */
+        batching?: Schema$BatchingConfigProto;
         /**
          * Describes settings to use for long-running operations when generating API methods for RPCs. Complements RPCs that use the annotations in google/longrunning/operations.proto. Example of a YAML configuration:: publishing: method_settings: - selector: google.cloud.speech.v2.Speech.BatchRecognize long_running: initial_poll_delay: 60s # 1 minute poll_delay_multiplier: 1.5 max_poll_delay: 360s # 6 minutes total_poll_timeout: 54000s # 90 minutes
          */
@@ -1673,7 +1749,7 @@ export declare namespace servicenetworking_v1 {
          */
         dnsSuffix?: string | null;
         /**
-         * User assigned name for this resource. Must be unique within the consumer network. The name must be 1-63 characters long, must begin with a letter, end with a letter or digit, and only contain lowercase letters, digits or dashes.
+         * Required. User assigned name for this resource. Must be unique within the consumer network. The name must be 1-63 characters long, must begin with a letter, end with a letter or digit, and only contain lowercase letters, digits or dashes.
          */
         name?: string | null;
     }
@@ -1690,6 +1766,10 @@ export declare namespace servicenetworking_v1 {
          * Some settings.
          */
         common?: Schema$CommonLanguageSettings;
+        /**
+         * The package name to use in Php. Clobbers the php_namespace option set in the protobuf. This should be used **only** by APIs who have already set the language_settings.php.package_name" field in gapic.yaml. API teams should use the protobuf php_namespace option where possible. Example of a YAML configuration:: publishing: library_settings: php_settings: library_package: Google\Cloud\PubSub\V1
+         */
+        libraryPackage?: string | null;
     }
     /**
      * Grouping of IAM role and IAM member.
@@ -1949,7 +2029,7 @@ export declare namespace servicenetworking_v1 {
          */
         ipPrefixLength?: number | null;
         /**
-         * Network name in the consumer project. This network must have been already peered with a shared VPC network using CreateConnection method. Must be in a form 'projects/{project\}/global/networks/{network\}'. {project\} is a project number, as in '12345' {network\} is network name.
+         * Required. Network name in the consumer project. This network must have been already peered with a shared VPC network using CreateConnection method. Must be in a form 'projects/{project\}/global/networks/{network\}'. {project\} is a project number, as in '12345' {network\} is network name.
          */
         network?: string | null;
     }
@@ -2374,56 +2454,265 @@ export declare namespace servicenetworking_v1 {
         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/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.operations.cancel({
+         *     // The name of the operation resource to be cancelled.
+         *     name: 'operations/.*',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   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): GaxiosPromise<Readable>;
-        cancel(params?: Params$Resource$Operations$Cancel, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        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/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.operations.delete({
+         *     // The name of the operation resource to be deleted.
+         *     name: 'operations/.*',
+         *   });
+         *   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): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Operations$Delete, options?: MethodOptions): GaxiosPromise<Schema$Empty>;
+        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/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.operations.get({
+         *     // The name of the operation resource.
+         *     name: '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): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Operations$Get, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        get(params: Params$Resource$Operations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Operations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         get(params: Params$Resource$Operations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Operations$Get, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         get(params: Params$Resource$Operations$Get, callback: BodyResponseCallback<Schema$Operation>): void;
         get(callback: BodyResponseCallback<Schema$Operation>): 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/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.operations.list({
+         *     // The standard list filter.
+         *     filter: 'placeholder-value',
+         *     // The name of the operation's parent resource.
+         *     name: 'operations',
+         *     // The standard list page size.
+         *     pageSize: 'placeholder-value',
+         *     // The standard list page token.
+         *     pageToken: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "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$Operations$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Operations$List, options?: MethodOptions): GaxiosPromise<Schema$ListOperationsResponse>;
+        list(params: Params$Resource$Operations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Operations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListOperationsResponse>>;
         list(params: Params$Resource$Operations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Operations$List, options: MethodOptions | BodyResponseCallback<Schema$ListOperationsResponse>, callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
         list(params: Params$Resource$Operations$List, callback: BodyResponseCallback<Schema$ListOperationsResponse>): void;
@@ -2479,70 +2768,397 @@ export declare namespace servicenetworking_v1 {
         constructor(context: APIRequestContext);
         /**
          * For service producers, provisions a new subnet in a peered service's shared VPC network in the requested region and with the requested size that's expressed as a CIDR range (number of leading bits of ipV4 network mask). The method checks against the assigned allocated ranges to find a non-conflicting IP address range. The method will reuse a subnet if subsequent calls contain the same subnet name, region, and prefix length. This method will make producer's tenant project to be a shared VPC service project as needed.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.addSubnetwork({
+         *     // Required. A tenant project in the service producer organization, in the following format: services/{service\}/{collection-id\}/{resource-id\}. {collection-id\} is the cloud resource collection type that represents the tenant project. Only `projects` are supported. {resource-id\} is the tenant project numeric id, such as `123456`. {service\} the name of the peering service, such as `service-peering.example.com`. This service must already be enabled in the service consumer's project.
+         *     parent: 'services/my-service/[^/]+/[^/]+',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "allowSubnetCidrRoutesOverlap": false,
+         *       //   "checkServiceNetworkingUsePermission": false,
+         *       //   "computeIdempotencyWindow": "my_computeIdempotencyWindow",
+         *       //   "consumer": "my_consumer",
+         *       //   "consumerNetwork": "my_consumerNetwork",
+         *       //   "description": "my_description",
+         *       //   "internalRange": "my_internalRange",
+         *       //   "ipPrefixLength": 0,
+         *       //   "outsideAllocationPublicIpRange": "my_outsideAllocationPublicIpRange",
+         *       //   "privateIpv6GoogleAccess": "my_privateIpv6GoogleAccess",
+         *       //   "purpose": "my_purpose",
+         *       //   "region": "my_region",
+         *       //   "requestedAddress": "my_requestedAddress",
+         *       //   "requestedRanges": [],
+         *       //   "role": "my_role",
+         *       //   "secondaryIpRangeSpecs": [],
+         *       //   "skipRequestedAddressValidation": false,
+         *       //   "subnetwork": "my_subnetwork",
+         *       //   "subnetworkUsers": [],
+         *       //   "useCustomComputeIdempotencyWindow": false
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        addSubnetwork(params: Params$Resource$Services$Addsubnetwork, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        addSubnetwork(params?: Params$Resource$Services$Addsubnetwork, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        addSubnetwork(params: Params$Resource$Services$Addsubnetwork, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        addSubnetwork(params?: Params$Resource$Services$Addsubnetwork, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         addSubnetwork(params: Params$Resource$Services$Addsubnetwork, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         addSubnetwork(params: Params$Resource$Services$Addsubnetwork, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         addSubnetwork(params: Params$Resource$Services$Addsubnetwork, callback: BodyResponseCallback<Schema$Operation>): void;
         addSubnetwork(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Disables VPC service controls for a connection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.disableVpcServiceControls({
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        disableVpcServiceControls(params: Params$Resource$Services$Disablevpcservicecontrols, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        disableVpcServiceControls(params?: Params$Resource$Services$Disablevpcservicecontrols, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        disableVpcServiceControls(params: Params$Resource$Services$Disablevpcservicecontrols, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        disableVpcServiceControls(params?: Params$Resource$Services$Disablevpcservicecontrols, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         disableVpcServiceControls(params: Params$Resource$Services$Disablevpcservicecontrols, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         disableVpcServiceControls(params: Params$Resource$Services$Disablevpcservicecontrols, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         disableVpcServiceControls(params: Params$Resource$Services$Disablevpcservicecontrols, callback: BodyResponseCallback<Schema$Operation>): void;
         disableVpcServiceControls(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Enables VPC service controls for a connection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.enableVpcServiceControls({
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        enableVpcServiceControls(params: Params$Resource$Services$Enablevpcservicecontrols, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        enableVpcServiceControls(params?: Params$Resource$Services$Enablevpcservicecontrols, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        enableVpcServiceControls(params: Params$Resource$Services$Enablevpcservicecontrols, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        enableVpcServiceControls(params?: Params$Resource$Services$Enablevpcservicecontrols, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         enableVpcServiceControls(params: Params$Resource$Services$Enablevpcservicecontrols, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         enableVpcServiceControls(params: Params$Resource$Services$Enablevpcservicecontrols, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         enableVpcServiceControls(params: Params$Resource$Services$Enablevpcservicecontrols, callback: BodyResponseCallback<Schema$Operation>): void;
         enableVpcServiceControls(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Service producers can use this method to find a currently unused range within consumer allocated ranges. This returned range is not reserved, and not guaranteed to remain unused. It will validate previously provided allocated ranges, find non-conflicting sub-range of requested size (expressed in number of leading bits of ipv4 network mask, as in CIDR range notation).
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.searchRange({
+         *     // Required. This is in a form services/{service\}. {service\} the name of the private access management service, for example 'service-peering.example.com'.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "ipPrefixLength": 0,
+         *       //   "network": "my_network"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        searchRange(params: Params$Resource$Services$Searchrange, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        searchRange(params?: Params$Resource$Services$Searchrange, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        searchRange(params: Params$Resource$Services$Searchrange, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        searchRange(params?: Params$Resource$Services$Searchrange, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         searchRange(params: Params$Resource$Services$Searchrange, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         searchRange(params: Params$Resource$Services$Searchrange, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         searchRange(params: Params$Resource$Services$Searchrange, callback: BodyResponseCallback<Schema$Operation>): void;
         searchRange(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Service producers use this method to validate if the consumer provided network, project and requested range are valid. This allows them to use a fail-fast mechanism for consumer requests, and not have to wait for AddSubnetwork operation completion to determine if user request is invalid.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.validate({
+         *     // Required. This is in a form services/{service\} where {service\} is the name of the private access management service. For example 'service-peering.example.com'.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "checkServiceNetworkingUsePermission": false,
+         *       //   "consumerNetwork": "my_consumerNetwork",
+         *       //   "consumerProject": {},
+         *       //   "rangeReservation": {},
+         *       //   "validateNetwork": false
+         *       // }
+         *     },
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "existingSubnetworkCandidates": [],
+         *   //   "isValid": false,
+         *   //   "validationError": "my_validationError"
+         *   // }
+         * }
+         *
+         * 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.
          */
-        validate(params: Params$Resource$Services$Validate, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        validate(params?: Params$Resource$Services$Validate, options?: MethodOptions): GaxiosPromise<Schema$ValidateConsumerConfigResponse>;
+        validate(params: Params$Resource$Services$Validate, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        validate(params?: Params$Resource$Services$Validate, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ValidateConsumerConfigResponse>>;
         validate(params: Params$Resource$Services$Validate, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         validate(params: Params$Resource$Services$Validate, options: MethodOptions | BodyResponseCallback<Schema$ValidateConsumerConfigResponse>, callback: BodyResponseCallback<Schema$ValidateConsumerConfigResponse>): void;
         validate(params: Params$Resource$Services$Validate, callback: BodyResponseCallback<Schema$ValidateConsumerConfigResponse>): void;
@@ -2560,7 +3176,7 @@ export declare namespace servicenetworking_v1 {
     }
     export interface Params$Resource$Services$Disablevpcservicecontrols extends StandardParameters {
         /**
-         * The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         * Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
          */
         parent?: string;
         /**
@@ -2570,7 +3186,7 @@ export declare namespace servicenetworking_v1 {
     }
     export interface Params$Resource$Services$Enablevpcservicecontrols extends StandardParameters {
         /**
-         * The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         * Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
          */
         parent?: string;
         /**
@@ -2603,56 +3219,300 @@ export declare namespace servicenetworking_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a private connection that establishes a VPC Network Peering connection to a VPC network in the service producer's organization. The administrator of the service consumer's VPC network invokes this method. The administrator must assign one or more allocated IP ranges for provisioning subnetworks in the service producer's VPC network. This connection is used for all supported services in the service producer's organization, so it only needs to be invoked once.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.connections.create({
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "network": "my_network",
+         *       //   "peering": "my_peering",
+         *       //   "reservedPeeringRanges": [],
+         *       //   "service": "my_service"
+         *       // }
+         *     },
+         *   });
+         *   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$Services$Connections$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Services$Connections$Create, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        create(params: Params$Resource$Services$Connections$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Services$Connections$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         create(params: Params$Resource$Services$Connections$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Services$Connections$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         create(params: Params$Resource$Services$Connections$Create, callback: BodyResponseCallback<Schema$Operation>): void;
         create(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Deletes a private service access connection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.connections.deleteConnection({
+         *     // Required. The private service connection that connects to a service producer organization. The name includes both the private service name and the VPC network peering name in the format of `services/{peering_service_name\}/connections/{vpc_peering_name\}`. For Google services that support this functionality, this is `services/servicenetworking.googleapis.com/connections/servicenetworking-googleapis-com`.
+         *     name: 'services/my-service/connections/my-connection',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        deleteConnection(params: Params$Resource$Services$Connections$Deleteconnection, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        deleteConnection(params?: Params$Resource$Services$Connections$Deleteconnection, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        deleteConnection(params: Params$Resource$Services$Connections$Deleteconnection, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        deleteConnection(params?: Params$Resource$Services$Connections$Deleteconnection, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         deleteConnection(params: Params$Resource$Services$Connections$Deleteconnection, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         deleteConnection(params: Params$Resource$Services$Connections$Deleteconnection, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         deleteConnection(params: Params$Resource$Services$Connections$Deleteconnection, callback: BodyResponseCallback<Schema$Operation>): void;
         deleteConnection(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * List the private connections that are configured in a service consumer's VPC network.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.connections.list({
+         *     // Required. The name of service consumer's VPC network that's connected with service producer network through a private connection. The network name must be in the following format: `projects/{project\}/global/networks/{network\}`. {project\} is a project number, such as in `12345` that includes the VPC service consumer's VPC network. {network\} is the name of the service consumer's VPC network.
+         *     network: 'placeholder-value',
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`. If you specify `services/-` as the parameter value, all configured peering services are listed.
+         *     parent: 'services/my-service',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "connections": []
+         *   // }
+         * }
+         *
+         * 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$Services$Connections$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Services$Connections$List, options?: MethodOptions): GaxiosPromise<Schema$ListConnectionsResponse>;
+        list(params: Params$Resource$Services$Connections$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Services$Connections$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListConnectionsResponse>>;
         list(params: Params$Resource$Services$Connections$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Services$Connections$List, options: MethodOptions | BodyResponseCallback<Schema$ListConnectionsResponse>, callback: BodyResponseCallback<Schema$ListConnectionsResponse>): void;
         list(params: Params$Resource$Services$Connections$List, callback: BodyResponseCallback<Schema$ListConnectionsResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListConnectionsResponse>): void;
         /**
          * Updates the allocated ranges that are assigned to a connection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.connections.patch({
+         *     // If a previously defined allocated range is removed, force flag must be set to true.
+         *     force: 'placeholder-value',
+         *     // Required. The private service connection that connects to a service producer organization. The name includes both the private service name and the VPC network peering name in the format of `services/{peering_service_name\}/connections/{vpc_peering_name\}`. For Google services that support this functionality, this is `services/servicenetworking.googleapis.com/connections/servicenetworking-googleapis-com`.
+         *     name: 'services/my-service/connections/my-connection',
+         *     // The update mask. If this is omitted, it defaults to "*". You can only update the listed peering ranges.
+         *     updateMask: 'placeholder-value',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "network": "my_network",
+         *       //   "peering": "my_peering",
+         *       //   "reservedPeeringRanges": [],
+         *       //   "service": "my_service"
+         *       // }
+         *     },
+         *   });
+         *   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$Services$Connections$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        patch(params?: Params$Resource$Services$Connections$Patch, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        patch(params: Params$Resource$Services$Connections$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Services$Connections$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         patch(params: Params$Resource$Services$Connections$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         patch(params: Params$Resource$Services$Connections$Patch, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         patch(params: Params$Resource$Services$Connections$Patch, callback: BodyResponseCallback<Schema$Operation>): void;
@@ -2660,7 +3520,7 @@ export declare namespace servicenetworking_v1 {
     }
     export interface Params$Resource$Services$Connections$Create extends StandardParameters {
         /**
-         * The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         * Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
          */
         parent?: string;
         /**
@@ -2680,11 +3540,11 @@ export declare namespace servicenetworking_v1 {
     }
     export interface Params$Resource$Services$Connections$List extends StandardParameters {
         /**
-         * The name of service consumer's VPC network that's connected with service producer network through a private connection. The network name must be in the following format: `projects/{project\}/global/networks/{network\}`. {project\} is a project number, such as in `12345` that includes the VPC service consumer's VPC network. {network\} is the name of the service consumer's VPC network.
+         * Required. The name of service consumer's VPC network that's connected with service producer network through a private connection. The network name must be in the following format: `projects/{project\}/global/networks/{network\}`. {project\} is a project number, such as in `12345` that includes the VPC service consumer's VPC network. {network\} is the name of the service consumer's VPC network.
          */
         network?: string;
         /**
-         * The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`. If you specify `services/-` as the parameter value, all configured peering services are listed.
+         * Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`. If you specify `services/-` as the parameter value, all configured peering services are listed.
          */
         parent?: string;
     }
@@ -2694,7 +3554,7 @@ export declare namespace servicenetworking_v1 {
          */
         force?: boolean;
         /**
-         * The private service connection that connects to a service producer organization. The name includes both the private service name and the VPC network peering name in the format of `services/{peering_service_name\}/connections/{vpc_peering_name\}`. For Google services that support this functionality, this is `services/servicenetworking.googleapis.com/connections/servicenetworking-googleapis-com`.
+         * Required. The private service connection that connects to a service producer organization. The name includes both the private service name and the VPC network peering name in the format of `services/{peering_service_name\}/connections/{vpc_peering_name\}`. For Google services that support this functionality, this is `services/servicenetworking.googleapis.com/connections/servicenetworking-googleapis-com`.
          */
         name?: string;
         /**
@@ -2711,70 +3571,373 @@ export declare namespace servicenetworking_v1 {
         constructor(context: APIRequestContext);
         /**
          * Service producers can use this method to add DNS record sets to private DNS zones in the shared producer host project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.dnsRecordSets.add({
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork",
+         *       //   "dnsRecordSet": {},
+         *       //   "zone": "my_zone"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        add(params: Params$Resource$Services$Dnsrecordsets$Add, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        add(params?: Params$Resource$Services$Dnsrecordsets$Add, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        add(params: Params$Resource$Services$Dnsrecordsets$Add, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        add(params?: Params$Resource$Services$Dnsrecordsets$Add, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         add(params: Params$Resource$Services$Dnsrecordsets$Add, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         add(params: Params$Resource$Services$Dnsrecordsets$Add, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         add(params: Params$Resource$Services$Dnsrecordsets$Add, callback: BodyResponseCallback<Schema$Operation>): void;
         add(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Producers can use this method to retrieve information about the DNS record set added to the private zone inside the shared tenant host project associated with a consumer network.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.dnsRecordSets.get({
+         *     // Required. The consumer network containing the record set. Must be in the form of projects/{project\}/global/networks/{network\}
+         *     consumerNetwork: 'placeholder-value',
+         *     // Required. The domain name of the zone containing the recordset.
+         *     domain: 'placeholder-value',
+         *     // Required. Parent resource identifying the connection which owns this collection of DNS zones in the format services/{service\}.
+         *     parent: 'services/my-service',
+         *     // Required. RecordSet Type eg. type='A'. See the list of [Supported DNS Types](https://cloud.google.com/dns/records/json-record).
+         *     type: 'placeholder-value',
+         *     // Required. The name of the zone containing the record set.
+         *     zone: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "data": [],
+         *   //   "domain": "my_domain",
+         *   //   "ttl": "my_ttl",
+         *   //   "type": "my_type"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Services$Dnsrecordsets$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Services$Dnsrecordsets$Get, options?: MethodOptions): GaxiosPromise<Schema$DnsRecordSet>;
+        get(params: Params$Resource$Services$Dnsrecordsets$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Services$Dnsrecordsets$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$DnsRecordSet>>;
         get(params: Params$Resource$Services$Dnsrecordsets$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Services$Dnsrecordsets$Get, options: MethodOptions | BodyResponseCallback<Schema$DnsRecordSet>, callback: BodyResponseCallback<Schema$DnsRecordSet>): void;
         get(params: Params$Resource$Services$Dnsrecordsets$Get, callback: BodyResponseCallback<Schema$DnsRecordSet>): void;
         get(callback: BodyResponseCallback<Schema$DnsRecordSet>): void;
         /**
          * Producers can use this method to retrieve a list of available DNS RecordSets available inside the private zone on the tenant host project accessible from their network.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.dnsRecordSets.list({
+         *     // Required. The network that the consumer is using to connect with services. Must be in the form of projects/{project\}/global/networks/{network\} {project\} is the project number, as in '12345' {network\} is the network name.
+         *     consumerNetwork: 'placeholder-value',
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *     // Required. The name of the private DNS zone in the shared producer host project from which the record set will be removed.
+         *     zone: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "dnsRecordSets": []
+         *   // }
+         * }
+         *
+         * 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$Services$Dnsrecordsets$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Services$Dnsrecordsets$List, options?: MethodOptions): GaxiosPromise<Schema$ListDnsRecordSetsResponse>;
+        list(params: Params$Resource$Services$Dnsrecordsets$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Services$Dnsrecordsets$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListDnsRecordSetsResponse>>;
         list(params: Params$Resource$Services$Dnsrecordsets$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Services$Dnsrecordsets$List, options: MethodOptions | BodyResponseCallback<Schema$ListDnsRecordSetsResponse>, callback: BodyResponseCallback<Schema$ListDnsRecordSetsResponse>): void;
         list(params: Params$Resource$Services$Dnsrecordsets$List, callback: BodyResponseCallback<Schema$ListDnsRecordSetsResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListDnsRecordSetsResponse>): void;
         /**
          * Service producers can use this method to remove DNS record sets from private DNS zones in the shared producer host project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.dnsRecordSets.remove({
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork",
+         *       //   "dnsRecordSet": {},
+         *       //   "zone": "my_zone"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        remove(params: Params$Resource$Services$Dnsrecordsets$Remove, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        remove(params?: Params$Resource$Services$Dnsrecordsets$Remove, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        remove(params: Params$Resource$Services$Dnsrecordsets$Remove, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        remove(params?: Params$Resource$Services$Dnsrecordsets$Remove, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         remove(params: Params$Resource$Services$Dnsrecordsets$Remove, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         remove(params: Params$Resource$Services$Dnsrecordsets$Remove, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         remove(params: Params$Resource$Services$Dnsrecordsets$Remove, callback: BodyResponseCallback<Schema$Operation>): void;
         remove(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Service producers can use this method to update DNS record sets from private DNS zones in the shared producer host project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.dnsRecordSets.update({
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork",
+         *       //   "existingDnsRecordSet": {},
+         *       //   "newDnsRecordSet": {},
+         *       //   "zone": "my_zone"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        update(params: Params$Resource$Services$Dnsrecordsets$Update, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        update(params?: Params$Resource$Services$Dnsrecordsets$Update, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        update(params: Params$Resource$Services$Dnsrecordsets$Update, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        update(params?: Params$Resource$Services$Dnsrecordsets$Update, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         update(params: Params$Resource$Services$Dnsrecordsets$Update, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         update(params: Params$Resource$Services$Dnsrecordsets$Update, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         update(params: Params$Resource$Services$Dnsrecordsets$Update, callback: BodyResponseCallback<Schema$Operation>): void;
@@ -2851,28 +4014,153 @@ export declare namespace servicenetworking_v1 {
         constructor(context: APIRequestContext);
         /**
          * Service producers can use this method to add private DNS zones in the shared producer host project and matching peering zones in the consumer project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.dnsZones.add({
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork",
+         *       //   "dnsSuffix": "my_dnsSuffix",
+         *       //   "name": "my_name"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        add(params: Params$Resource$Services$Dnszones$Add, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        add(params?: Params$Resource$Services$Dnszones$Add, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        add(params: Params$Resource$Services$Dnszones$Add, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        add(params?: Params$Resource$Services$Dnszones$Add, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         add(params: Params$Resource$Services$Dnszones$Add, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         add(params: Params$Resource$Services$Dnszones$Add, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         add(params: Params$Resource$Services$Dnszones$Add, callback: BodyResponseCallback<Schema$Operation>): void;
         add(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Service producers can use this method to remove private DNS zones in the shared producer host project and matching peering zones in the consumer project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.dnsZones.remove({
+         *     // Required. The service that is managing peering connectivity for a service producer's organization. For Google services that support this functionality, this value is `services/servicenetworking.googleapis.com`.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork",
+         *       //   "name": "my_name"
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        remove(params: Params$Resource$Services$Dnszones$Remove, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        remove(params?: Params$Resource$Services$Dnszones$Remove, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        remove(params: Params$Resource$Services$Dnszones$Remove, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        remove(params?: Params$Resource$Services$Dnszones$Remove, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         remove(params: Params$Resource$Services$Dnszones$Remove, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         remove(params: Params$Resource$Services$Dnszones$Remove, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         remove(params: Params$Resource$Services$Dnszones$Remove, callback: BodyResponseCallback<Schema$Operation>): void;
@@ -2915,42 +4203,222 @@ export declare namespace servicenetworking_v1 {
         constructor(context: APIRequestContext);
         /**
          * Service producers use this method to get the configuration of their connection including the import/export of custom routes and subnetwork routes with public IP.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.projects.global.networks.get({
+         *     // Optional. When true, include the used IP ranges as part of the GetConsumerConfig output. This includes routes created inside the service networking network, consumer network, peers of the consumer network, and reserved ranges inside the service networking network. By default, this is false
+         *     includeUsedIpRanges: 'placeholder-value',
+         *     // Required. Name of the consumer config to retrieve in the format: `services/{service\}/projects/{project\}/global/networks/{network\}`. {service\} is the peering service that is managing connectivity for the service producer's organization. For Google services that support this functionality, this value is `servicenetworking.googleapis.com`. {project\} is a project number e.g. `12345` that contains the service consumer's VPC network. {network\} is the name of the service consumer's VPC network.
+         *     name: 'services/my-service/projects/my-project/global/networks/my-network',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "cloudsqlConfigs": [],
+         *   //   "consumerExportCustomRoutes": false,
+         *   //   "consumerExportSubnetRoutesWithPublicIp": false,
+         *   //   "consumerImportCustomRoutes": false,
+         *   //   "consumerImportSubnetRoutesWithPublicIp": false,
+         *   //   "producerExportCustomRoutes": false,
+         *   //   "producerExportSubnetRoutesWithPublicIp": false,
+         *   //   "producerImportCustomRoutes": false,
+         *   //   "producerImportSubnetRoutesWithPublicIp": false,
+         *   //   "producerNetwork": "my_producerNetwork",
+         *   //   "reservedRanges": [],
+         *   //   "usedIpRanges": [],
+         *   //   "vpcScReferenceArchitectureEnabled": false
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        get(params: Params$Resource$Services$Projects$Global$Networks$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Services$Projects$Global$Networks$Get, options?: MethodOptions): GaxiosPromise<Schema$ConsumerConfig>;
+        get(params: Params$Resource$Services$Projects$Global$Networks$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Services$Projects$Global$Networks$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ConsumerConfig>>;
         get(params: Params$Resource$Services$Projects$Global$Networks$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Services$Projects$Global$Networks$Get, options: MethodOptions | BodyResponseCallback<Schema$ConsumerConfig>, callback: BodyResponseCallback<Schema$ConsumerConfig>): void;
         get(params: Params$Resource$Services$Projects$Global$Networks$Get, callback: BodyResponseCallback<Schema$ConsumerConfig>): void;
         get(callback: BodyResponseCallback<Schema$ConsumerConfig>): void;
         /**
          * Consumers use this method to find out the state of VPC Service Controls. The controls could be enabled or disabled for a connection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.projects.global.networks.getVpcServiceControls(
+         *       {
+         *         // Required. Name of the VPC Service Controls config to retrieve in the format: `services/{service\}/projects/{project\}/global/networks/{network\}`. {service\} is the peering service that is managing connectivity for the service producer's organization. For Google services that support this functionality, this value is `servicenetworking.googleapis.com`. {project\} is a project number e.g. `12345` that contains the service consumer's VPC network. {network\} is the name of the service consumer's VPC network.
+         *         name: 'services/my-service/projects/my-project/global/networks/my-network',
+         *       },
+         *     );
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "enabled": false
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        getVpcServiceControls(params: Params$Resource$Services$Projects$Global$Networks$Getvpcservicecontrols, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        getVpcServiceControls(params?: Params$Resource$Services$Projects$Global$Networks$Getvpcservicecontrols, options?: MethodOptions): GaxiosPromise<Schema$VpcServiceControls>;
+        getVpcServiceControls(params: Params$Resource$Services$Projects$Global$Networks$Getvpcservicecontrols, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        getVpcServiceControls(params?: Params$Resource$Services$Projects$Global$Networks$Getvpcservicecontrols, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$VpcServiceControls>>;
         getVpcServiceControls(params: Params$Resource$Services$Projects$Global$Networks$Getvpcservicecontrols, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         getVpcServiceControls(params: Params$Resource$Services$Projects$Global$Networks$Getvpcservicecontrols, options: MethodOptions | BodyResponseCallback<Schema$VpcServiceControls>, callback: BodyResponseCallback<Schema$VpcServiceControls>): void;
         getVpcServiceControls(params: Params$Resource$Services$Projects$Global$Networks$Getvpcservicecontrols, callback: BodyResponseCallback<Schema$VpcServiceControls>): void;
         getVpcServiceControls(callback: BodyResponseCallback<Schema$VpcServiceControls>): void;
         /**
          * Service producers use this method to update the configuration of their connection including the import/export of custom routes and subnetwork routes with public IP.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.projects.global.networks.updateConsumerConfig(
+         *       {
+         *         // Required. Parent resource identifying the connection for which the consumer config is being updated in the format: `services/{service\}/projects/{project\}/global/networks/{network\}` {service\} is the peering service that is managing connectivity for the service producer's organization. For Google services that support this functionality, this value is `servicenetworking.googleapis.com`. {project\} is the number of the project that contains the service consumer's VPC network e.g. `12345`. {network\} is the name of the service consumer's VPC network.
+         *         parent:
+         *           'services/my-service/projects/my-project/global/networks/my-network',
+         *
+         *         // Request body metadata
+         *         requestBody: {
+         *           // request body parameters
+         *           // {
+         *           //   "consumerConfig": {}
+         *           // }
+         *         },
+         *       },
+         *     );
+         *   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.
          */
-        updateConsumerConfig(params: Params$Resource$Services$Projects$Global$Networks$Updateconsumerconfig, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        updateConsumerConfig(params?: Params$Resource$Services$Projects$Global$Networks$Updateconsumerconfig, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        updateConsumerConfig(params: Params$Resource$Services$Projects$Global$Networks$Updateconsumerconfig, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        updateConsumerConfig(params?: Params$Resource$Services$Projects$Global$Networks$Updateconsumerconfig, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         updateConsumerConfig(params: Params$Resource$Services$Projects$Global$Networks$Updateconsumerconfig, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         updateConsumerConfig(params: Params$Resource$Services$Projects$Global$Networks$Updateconsumerconfig, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         updateConsumerConfig(params: Params$Resource$Services$Projects$Global$Networks$Updateconsumerconfig, callback: BodyResponseCallback<Schema$Operation>): void;
@@ -2987,28 +4455,130 @@ export declare namespace servicenetworking_v1 {
         constructor(context: APIRequestContext);
         /**
          * Service producers can use this method to retrieve a DNS zone in the shared producer host project and the matching peering zones in consumer project
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.projects.global.networks.dnsZones.get({
+         *       // Required. The network that the consumer is using to connect with services. Must be in the form of services/{service\}/projects/{project\}/global/networks/{network\}/dnsZones/{zoneName\} Where {service\} is the peering service that is managing connectivity for the service producer's organization. For Google services that support this {project\} is the project number, as in '12345' {network\} is the network name. {zoneName\} is the DNS zone name
+         *       name: 'services/my-service/projects/my-project/global/networks/my-network/dnsZones/my-dnsZone',
+         *     });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "consumerPeeringZone": {},
+         *   //   "producerPrivateZone": {}
+         *   // }
+         * }
+         *
+         * 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$Services$Projects$Global$Networks$Dnszones$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Services$Projects$Global$Networks$Dnszones$Get, options?: MethodOptions): GaxiosPromise<Schema$GetDnsZoneResponse>;
+        get(params: Params$Resource$Services$Projects$Global$Networks$Dnszones$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Services$Projects$Global$Networks$Dnszones$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$GetDnsZoneResponse>>;
         get(params: Params$Resource$Services$Projects$Global$Networks$Dnszones$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Services$Projects$Global$Networks$Dnszones$Get, options: MethodOptions | BodyResponseCallback<Schema$GetDnsZoneResponse>, callback: BodyResponseCallback<Schema$GetDnsZoneResponse>): void;
         get(params: Params$Resource$Services$Projects$Global$Networks$Dnszones$Get, callback: BodyResponseCallback<Schema$GetDnsZoneResponse>): void;
         get(callback: BodyResponseCallback<Schema$GetDnsZoneResponse>): void;
         /**
          * * Service producers can use this method to retrieve a list of available DNS zones in the shared producer host project and the matching peering zones in the consumer project. *
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.projects.global.networks.dnsZones.list({
+         *       // Required. Parent resource identifying the connection which owns this collection of DNS zones in the format services/{service\}/projects/{project\}/global/networks/{network\} Service: The service that is managing connectivity for the service producer's organization. For Google services that support this functionality, this value is `servicenetworking.googleapis.com`. Projects: the consumer project containing the consumer network. Network: The consumer network accessible from the tenant project.
+         *       parent:
+         *         'services/my-service/projects/my-project/global/networks/my-network',
+         *     });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "dnsZonePairs": []
+         *   // }
+         * }
+         *
+         * 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$Services$Projects$Global$Networks$Dnszones$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Services$Projects$Global$Networks$Dnszones$List, options?: MethodOptions): GaxiosPromise<Schema$ListDnsZonesResponse>;
+        list(params: Params$Resource$Services$Projects$Global$Networks$Dnszones$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Services$Projects$Global$Networks$Dnszones$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListDnsZonesResponse>>;
         list(params: Params$Resource$Services$Projects$Global$Networks$Dnszones$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Services$Projects$Global$Networks$Dnszones$List, options: MethodOptions | BodyResponseCallback<Schema$ListDnsZonesResponse>, callback: BodyResponseCallback<Schema$ListDnsZonesResponse>): void;
         list(params: Params$Resource$Services$Projects$Global$Networks$Dnszones$List, callback: BodyResponseCallback<Schema$ListDnsZonesResponse>): void;
@@ -3031,42 +4601,217 @@ export declare namespace servicenetworking_v1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a peered DNS domain which sends requests for records in given namespace originating in the service producer VPC network to the consumer VPC network to be resolved.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.projects.global.networks.peeredDnsDomains.create(
+         *       {
+         *         // Required. Parent resource identifying the connection for which the peered DNS domain will be created in the format: `services/{service\}/projects/{project\}/global/networks/{network\}` {service\} is the peering service that is managing connectivity for the service producer's organization. For Google services that support this functionality, this value is `servicenetworking.googleapis.com`. {project\} is the number of the project that contains the service consumer's VPC network e.g. `12345`. {network\} is the name of the service consumer's VPC network.
+         *         parent:
+         *           'services/my-service/projects/my-project/global/networks/my-network',
+         *
+         *         // Request body metadata
+         *         requestBody: {
+         *           // request body parameters
+         *           // {
+         *           //   "dnsSuffix": "my_dnsSuffix",
+         *           //   "name": "my_name"
+         *           // }
+         *         },
+         *       },
+         *     );
+         *   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$Services$Projects$Global$Networks$Peereddnsdomains$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Create, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        create(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         create(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         create(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Create, callback: BodyResponseCallback<Schema$Operation>): void;
         create(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Deletes a peered DNS domain.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.projects.global.networks.peeredDnsDomains.delete(
+         *       {
+         *         // Required. The name of the peered DNS domain to delete in the format: `services/{service\}/projects/{project\}/global/networks/{network\}/peeredDnsDomains/{name\}`. {service\} is the peering service that is managing connectivity for the service producer's organization. For Google services that support this functionality, this value is `servicenetworking.googleapis.com`. {project\} is the number of the project that contains the service consumer's VPC network e.g. `12345`. {network\} is the name of the service consumer's VPC network. {name\} is the name of the peered DNS domain.
+         *         name: 'services/my-service/projects/my-project/global/networks/my-network/peeredDnsDomains/my-peeredDnsDomain',
+         *       },
+         *     );
+         *   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$Services$Projects$Global$Networks$Peereddnsdomains$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Delete, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        delete(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         delete(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Delete, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         delete(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$Delete, callback: BodyResponseCallback<Schema$Operation>): void;
         delete(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Lists peered DNS domains for a connection.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.projects.global.networks.peeredDnsDomains.list(
+         *       {
+         *         // Required. Parent resource identifying the connection which owns this collection of peered DNS domains in the format: `services/{service\}/projects/{project\}/global/networks/{network\}`. {service\} is the peering service that is managing connectivity for the service producer's organization. For Google services that support this functionality, this value is `servicenetworking.googleapis.com`. {project\} is a project number e.g. `12345` that contains the service consumer's VPC network. {network\} is the name of the service consumer's VPC network.
+         *         parent:
+         *           'services/my-service/projects/my-project/global/networks/my-network',
+         *       },
+         *     );
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "peeredDnsDomains": []
+         *   // }
+         * }
+         *
+         * 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$Services$Projects$Global$Networks$Peereddnsdomains$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$List, options?: MethodOptions): GaxiosPromise<Schema$ListPeeredDnsDomainsResponse>;
+        list(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListPeeredDnsDomainsResponse>>;
         list(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$List, options: MethodOptions | BodyResponseCallback<Schema$ListPeeredDnsDomainsResponse>, callback: BodyResponseCallback<Schema$ListPeeredDnsDomainsResponse>): void;
         list(params: Params$Resource$Services$Projects$Global$Networks$Peereddnsdomains$List, callback: BodyResponseCallback<Schema$ListPeeredDnsDomainsResponse>): void;
@@ -3099,14 +4844,76 @@ export declare namespace servicenetworking_v1 {
         constructor(context: APIRequestContext);
         /**
          * Service producers can use this method to add roles in the shared VPC host project. Each role is bound to the provided member. Each role must be selected from within an allowlisted set of roles. Each role is applied at only the granularity specified in the allowlist.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/servicenetworking.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 servicenetworking = google.servicenetworking('v1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/service.management',
+         *     ],
+         *   });
+         *
+         *   // 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 servicenetworking.services.roles.add({
+         *     // Required. This is in a form services/{service\} where {service\} is the name of the private access management service. For example 'service-peering.example.com'.
+         *     parent: 'services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "consumerNetwork": "my_consumerNetwork",
+         *       //   "policyBinding": []
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        add(params: Params$Resource$Services$Roles$Add, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        add(params?: Params$Resource$Services$Roles$Add, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        add(params: Params$Resource$Services$Roles$Add, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        add(params?: Params$Resource$Services$Roles$Add, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         add(params: Params$Resource$Services$Roles$Add, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         add(params: Params$Resource$Services$Roles$Add, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         add(params: Params$Resource$Services$Roles$Add, callback: BodyResponseCallback<Schema$Operation>): void;