@googleapis/serviceusage 15.0.2 → 17.1.0

package/build/v1beta1.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 serviceusage_v1beta1 {
     export interface Options extends GlobalOptions {
@@ -211,7 +211,7 @@ export declare namespace serviceusage_v1beta1 {
          */
         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;
@@ -390,6 +390,73 @@ export declare namespace serviceusage_v1beta1 {
          */
         services?: Schema$GoogleApiServiceusageV1Service[];
     }
+    /**
+     * `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
      */
@@ -1777,6 +1844,10 @@ export declare namespace serviceusage_v1beta1 {
          * 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
          */
@@ -2556,28 +2627,137 @@ export declare namespace serviceusage_v1beta1 {
         constructor(context: APIRequestContext);
         /**
          * 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/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.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/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.operations.list({
+         *     // The standard list filter.
+         *     filter: 'placeholder-value',
+         *     // The name of the operation's parent resource.
+         *     name: 'placeholder-value',
+         *     // 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;
@@ -2613,84 +2793,424 @@ export declare namespace serviceusage_v1beta1 {
         constructor(context: APIRequestContext);
         /**
          * Enables multiple services on a project. The operation is atomic: if enabling any service fails, then the entire batch fails, and no state changes occur. Operation response type: `google.protobuf.Empty`
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.batchEnable({
+         *     // Parent to enable services on. An example name would be: `projects/123` where `123` is the project number (not project ID). The `BatchEnableServices` method currently only supports projects.
+         *     parent: '[^/]+/[^/]+',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {
+         *       //   "serviceIds": []
+         *       // }
+         *     },
+         *   });
+         *   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.
          */
-        batchEnable(params: Params$Resource$Services$Batchenable, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        batchEnable(params?: Params$Resource$Services$Batchenable, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        batchEnable(params: Params$Resource$Services$Batchenable, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        batchEnable(params?: Params$Resource$Services$Batchenable, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         batchEnable(params: Params$Resource$Services$Batchenable, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         batchEnable(params: Params$Resource$Services$Batchenable, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         batchEnable(params: Params$Resource$Services$Batchenable, callback: BodyResponseCallback<Schema$Operation>): void;
         batchEnable(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Disables a service so that it can no longer be used with a project. This prevents unintended usage that may cause unexpected billing charges or security leaks. It is not valid to call the disable method on a service that is not currently enabled. Callers will receive a `FAILED_PRECONDITION` status if the target service is not currently enabled. Operation response type: `google.protobuf.Empty`
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.disable({
+         *     // Name of the consumer and service to disable the service on. The enable and disable methods currently only support projects. An example name would be: `projects/123/services/serviceusage.googleapis.com` where `123` is the project number (not project ID).
+         *     name: '[^/]+/[^/]+/services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   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.
          */
-        disable(params: Params$Resource$Services$Disable, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        disable(params?: Params$Resource$Services$Disable, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        disable(params: Params$Resource$Services$Disable, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        disable(params?: Params$Resource$Services$Disable, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         disable(params: Params$Resource$Services$Disable, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         disable(params: Params$Resource$Services$Disable, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         disable(params: Params$Resource$Services$Disable, callback: BodyResponseCallback<Schema$Operation>): void;
         disable(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Enables a service so that it can be used with a project. Operation response type: `google.protobuf.Empty`
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.enable({
+         *     // Name of the consumer and service to enable the service on. The `EnableService` and `DisableService` methods currently only support projects. Enabling a service requires that the service is public or is shared with the user enabling the service. An example name would be: `projects/123/services/serviceusage.googleapis.com` where `123` is the project number (not project ID).
+         *     name: '[^/]+/[^/]+/services/my-service',
+         *
+         *     // Request body metadata
+         *     requestBody: {
+         *       // request body parameters
+         *       // {}
+         *     },
+         *   });
+         *   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.
          */
-        enable(params: Params$Resource$Services$Enable, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        enable(params?: Params$Resource$Services$Enable, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        enable(params: Params$Resource$Services$Enable, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        enable(params?: Params$Resource$Services$Enable, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         enable(params: Params$Resource$Services$Enable, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         enable(params: Params$Resource$Services$Enable, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         enable(params: Params$Resource$Services$Enable, callback: BodyResponseCallback<Schema$Operation>): void;
         enable(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Generates service identity for service.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.generateServiceIdentity({
+         *     // Name of the consumer and service to generate an identity for. The `GenerateServiceIdentity` methods currently support projects, folders, organizations. Example parents would be: `projects/123/services/example.googleapis.com` `folders/123/services/example.googleapis.com` `organizations/123/services/example.googleapis.com`
+         *     parent: '[^/]+/[^/]+/services/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.
          */
-        generateServiceIdentity(params: Params$Resource$Services$Generateserviceidentity, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        generateServiceIdentity(params?: Params$Resource$Services$Generateserviceidentity, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        generateServiceIdentity(params: Params$Resource$Services$Generateserviceidentity, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        generateServiceIdentity(params?: Params$Resource$Services$Generateserviceidentity, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         generateServiceIdentity(params: Params$Resource$Services$Generateserviceidentity, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         generateServiceIdentity(params: Params$Resource$Services$Generateserviceidentity, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         generateServiceIdentity(params: Params$Resource$Services$Generateserviceidentity, callback: BodyResponseCallback<Schema$Operation>): void;
         generateServiceIdentity(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Returns the service configuration and enabled state for a given service.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *     ],
+         *   });
+         *
+         *   // 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 serviceusage.services.get({
+         *     // Name of the consumer and service to get the `ConsumerState` for. An example name would be: `projects/123/services/serviceusage.googleapis.com` where `123` is the project number (not project ID).
+         *     name: '[^/]+/[^/]+/services/my-service',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "config": {},
+         *   //   "name": "my_name",
+         *   //   "parent": "my_parent",
+         *   //   "state": "my_state"
+         *   // }
+         * }
+         *
+         * 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$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Services$Get, options?: MethodOptions): GaxiosPromise<Schema$Service>;
+        get(params: Params$Resource$Services$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Services$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Service>>;
         get(params: Params$Resource$Services$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Services$Get, options: MethodOptions | BodyResponseCallback<Schema$Service>, callback: BodyResponseCallback<Schema$Service>): void;
         get(params: Params$Resource$Services$Get, callback: BodyResponseCallback<Schema$Service>): void;
         get(callback: BodyResponseCallback<Schema$Service>): void;
         /**
          * Lists all services available to the specified project, and the current state of those services with respect to the project. The list includes all public services, all services for which the calling user has the `servicemanagement.services.bind` permission, and all services that have already been enabled on the project. The list can be filtered to only include services in a specific state, for example to only include services enabled on the project.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *     ],
+         *   });
+         *
+         *   // 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 serviceusage.services.list({
+         *     // Only list services that conform to the given filter. The allowed filter strings are `state:ENABLED` and `state:DISABLED`.
+         *     filter: 'placeholder-value',
+         *     // Requested size of the next page of data. Requested page size cannot exceed 200. If not set, the default page size is 50.
+         *     pageSize: 'placeholder-value',
+         *     // Token identifying which result to start with, which is returned by a previous list call.
+         *     pageToken: 'placeholder-value',
+         *     // Parent to search for services on. An example name would be: `projects/123` where `123` is the project number (not project ID).
+         *     parent: '[^/]+/[^/]+',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "services": []
+         *   // }
+         * }
+         *
+         * 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$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Services$List, options?: MethodOptions): GaxiosPromise<Schema$ListServicesResponse>;
+        list(params: Params$Resource$Services$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Services$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListServicesResponse>>;
         list(params: Params$Resource$Services$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Services$List, options: MethodOptions | BodyResponseCallback<Schema$ListServicesResponse>, callback: BodyResponseCallback<Schema$ListServicesResponse>): void;
         list(params: Params$Resource$Services$List, callback: BodyResponseCallback<Schema$ListServicesResponse>): void;
@@ -2762,56 +3282,296 @@ export declare namespace serviceusage_v1beta1 {
         constructor(context: APIRequestContext);
         /**
          * Retrieves a summary of quota information for a specific quota metric
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *     ],
+         *   });
+         *
+         *   // 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 serviceusage.services.consumerQuotaMetrics.get({
+         *     // The resource name of the quota. An example name would be: `projects/123/services/serviceusage.googleapis.com/consumerQuotaMetrics/serviceusage.googleapis.com%2Fmutate_requests`
+         *     name: '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric',
+         *     // Specifies the level of detail for quota information in the response.
+         *     view: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "consumerQuotaLimits": [],
+         *   //   "descendantConsumerQuotaLimits": [],
+         *   //   "displayName": "my_displayName",
+         *   //   "metric": "my_metric",
+         *   //   "name": "my_name",
+         *   //   "unit": "my_unit"
+         *   // }
+         * }
+         *
+         * 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$Consumerquotametrics$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Services$Consumerquotametrics$Get, options?: MethodOptions): GaxiosPromise<Schema$ConsumerQuotaMetric>;
+        get(params: Params$Resource$Services$Consumerquotametrics$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Services$Consumerquotametrics$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ConsumerQuotaMetric>>;
         get(params: Params$Resource$Services$Consumerquotametrics$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Services$Consumerquotametrics$Get, options: MethodOptions | BodyResponseCallback<Schema$ConsumerQuotaMetric>, callback: BodyResponseCallback<Schema$ConsumerQuotaMetric>): void;
         get(params: Params$Resource$Services$Consumerquotametrics$Get, callback: BodyResponseCallback<Schema$ConsumerQuotaMetric>): void;
         get(callback: BodyResponseCallback<Schema$ConsumerQuotaMetric>): void;
         /**
          * Creates or updates multiple admin overrides atomically, all on the same consumer, but on many different metrics or limits. The name field in the quota override message should not be set.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.consumerQuotaMetrics.importAdminOverrides({
+         *       // The resource name of the consumer. An example name would be: `projects/123/services/compute.googleapis.com`
+         *       parent: '[^/]+/[^/]+/services/my-service',
+         *
+         *       // Request body metadata
+         *       requestBody: {
+         *         // request body parameters
+         *         // {
+         *         //   "force": false,
+         *         //   "forceOnly": [],
+         *         //   "inlineSource": {}
+         *         // }
+         *       },
+         *     });
+         *   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.
          */
-        importAdminOverrides(params: Params$Resource$Services$Consumerquotametrics$Importadminoverrides, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        importAdminOverrides(params?: Params$Resource$Services$Consumerquotametrics$Importadminoverrides, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        importAdminOverrides(params: Params$Resource$Services$Consumerquotametrics$Importadminoverrides, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        importAdminOverrides(params?: Params$Resource$Services$Consumerquotametrics$Importadminoverrides, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         importAdminOverrides(params: Params$Resource$Services$Consumerquotametrics$Importadminoverrides, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         importAdminOverrides(params: Params$Resource$Services$Consumerquotametrics$Importadminoverrides, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         importAdminOverrides(params: Params$Resource$Services$Consumerquotametrics$Importadminoverrides, callback: BodyResponseCallback<Schema$Operation>): void;
         importAdminOverrides(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Creates or updates multiple consumer overrides atomically, all on the same consumer, but on many different metrics or limits. The name field in the quota override message should not be set.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.consumerQuotaMetrics.importConsumerOverrides({
+         *       // The resource name of the consumer. An example name would be: `projects/123/services/compute.googleapis.com`
+         *       parent: '[^/]+/[^/]+/services/my-service',
+         *
+         *       // Request body metadata
+         *       requestBody: {
+         *         // request body parameters
+         *         // {
+         *         //   "force": false,
+         *         //   "forceOnly": [],
+         *         //   "inlineSource": {}
+         *         // }
+         *       },
+         *     });
+         *   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.
          */
-        importConsumerOverrides(params: Params$Resource$Services$Consumerquotametrics$Importconsumeroverrides, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        importConsumerOverrides(params?: Params$Resource$Services$Consumerquotametrics$Importconsumeroverrides, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        importConsumerOverrides(params: Params$Resource$Services$Consumerquotametrics$Importconsumeroverrides, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        importConsumerOverrides(params?: Params$Resource$Services$Consumerquotametrics$Importconsumeroverrides, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         importConsumerOverrides(params: Params$Resource$Services$Consumerquotametrics$Importconsumeroverrides, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         importConsumerOverrides(params: Params$Resource$Services$Consumerquotametrics$Importconsumeroverrides, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         importConsumerOverrides(params: Params$Resource$Services$Consumerquotametrics$Importconsumeroverrides, callback: BodyResponseCallback<Schema$Operation>): void;
         importConsumerOverrides(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Retrieves a summary of all quota information visible to the service consumer, organized by service metric. Each metric includes information about all of its defined limits. Each limit includes the limit configuration (quota unit, preciseness, default value), the current effective limit value, and all of the overrides applied to the limit.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *     ],
+         *   });
+         *
+         *   // 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 serviceusage.services.consumerQuotaMetrics.list({
+         *     // Requested size of the next page of data.
+         *     pageSize: 'placeholder-value',
+         *     // Token identifying which result to start with; returned by a previous list call.
+         *     pageToken: 'placeholder-value',
+         *     // Parent of the quotas resource. Some example names would be: `projects/123/services/serviceconsumermanagement.googleapis.com` `folders/345/services/serviceconsumermanagement.googleapis.com` `organizations/456/services/serviceconsumermanagement.googleapis.com`
+         *     parent: '[^/]+/[^/]+/services/my-service',
+         *     // Specifies the level of detail for quota information in the response.
+         *     view: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "metrics": [],
+         *   //   "nextPageToken": "my_nextPageToken"
+         *   // }
+         * }
+         *
+         * main().catch(e => {
+         *   console.error(e);
+         *   throw e;
+         * });
+         *
+         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
          * @param callback - Optional callback that handles the response.
          * @returns A promise if used with async/await, or void if used with a callback.
          */
-        list(params: Params$Resource$Services$Consumerquotametrics$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Services$Consumerquotametrics$List, options?: MethodOptions): GaxiosPromise<Schema$ListConsumerQuotaMetricsResponse>;
+        list(params: Params$Resource$Services$Consumerquotametrics$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Services$Consumerquotametrics$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListConsumerQuotaMetricsResponse>>;
         list(params: Params$Resource$Services$Consumerquotametrics$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Services$Consumerquotametrics$List, options: MethodOptions | BodyResponseCallback<Schema$ListConsumerQuotaMetricsResponse>, callback: BodyResponseCallback<Schema$ListConsumerQuotaMetricsResponse>): void;
         list(params: Params$Resource$Services$Consumerquotametrics$List, callback: BodyResponseCallback<Schema$ListConsumerQuotaMetricsResponse>): void;
@@ -2872,14 +3632,71 @@ export declare namespace serviceusage_v1beta1 {
         constructor(context: APIRequestContext);
         /**
          * Retrieves a summary of quota information for a specific quota limit.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *     ],
+         *   });
+         *
+         *   // 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 serviceusage.services.consumerQuotaMetrics.limits.get({
+         *     // The resource name of the quota limit. Use the quota limit resource name returned by previous ListConsumerQuotaMetrics and GetConsumerQuotaMetric API calls.
+         *     name: '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit',
+         *     // Specifies the level of detail for quota information in the response.
+         *     view: 'placeholder-value',
+         *   });
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "allowsAdminOverrides": false,
+         *   //   "isPrecise": false,
+         *   //   "metric": "my_metric",
+         *   //   "name": "my_name",
+         *   //   "quotaBuckets": [],
+         *   //   "supportedLocations": [],
+         *   //   "unit": "my_unit"
+         *   // }
+         * }
+         *
+         * 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$Consumerquotametrics$Limits$Get, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        get(params?: Params$Resource$Services$Consumerquotametrics$Limits$Get, options?: MethodOptions): GaxiosPromise<Schema$ConsumerQuotaLimit>;
+        get(params: Params$Resource$Services$Consumerquotametrics$Limits$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        get(params?: Params$Resource$Services$Consumerquotametrics$Limits$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ConsumerQuotaLimit>>;
         get(params: Params$Resource$Services$Consumerquotametrics$Limits$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         get(params: Params$Resource$Services$Consumerquotametrics$Limits$Get, options: MethodOptions | BodyResponseCallback<Schema$ConsumerQuotaLimit>, callback: BodyResponseCallback<Schema$ConsumerQuotaLimit>): void;
         get(params: Params$Resource$Services$Consumerquotametrics$Limits$Get, callback: BodyResponseCallback<Schema$ConsumerQuotaLimit>): void;
@@ -2900,56 +3717,323 @@ export declare namespace serviceusage_v1beta1 {
         constructor(context: APIRequestContext);
         /**
          * Creates an admin override. An admin override is applied by an administrator of a parent folder or parent organization of the consumer receiving the override. An admin override is intended to limit the amount of quota the consumer can use out of the total quota pool allocated to all children of the folder or organization.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.consumerQuotaMetrics.limits.adminOverrides.create(
+         *       {
+         *         // Whether to force the creation of the quota override. Setting the force parameter to 'true' ignores all quota safety checks that would fail the request. QuotaSafetyCheck lists all such validations. If force is set to true, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         force: 'placeholder-value',
+         *         // The list of quota safety checks to ignore before the override mutation. Unlike 'force' field that ignores all the quota safety checks, the 'force_only' field ignores only the specified checks; other checks are still enforced. The 'force' and 'force_only' fields cannot both be set. If force_only is specified, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         forceOnly: 'placeholder-value',
+         *         // The resource name of the parent quota limit, returned by a ListConsumerQuotaMetrics or GetConsumerQuotaMetric call. An example name would be: `projects/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion`
+         *         parent:
+         *           '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit',
+         *
+         *         // Request body metadata
+         *         requestBody: {
+         *           // request body parameters
+         *           // {
+         *           //   "adminOverrideAncestor": "my_adminOverrideAncestor",
+         *           //   "dimensions": {},
+         *           //   "metric": "my_metric",
+         *           //   "name": "my_name",
+         *           //   "overrideValue": "my_overrideValue",
+         *           //   "unit": "my_unit"
+         *           // }
+         *         },
+         *       },
+         *     );
+         *   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$Consumerquotametrics$Limits$Adminoverrides$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Create, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        create(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         create(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         create(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Create, callback: BodyResponseCallback<Schema$Operation>): void;
         create(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Deletes an admin override.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.consumerQuotaMetrics.limits.adminOverrides.delete(
+         *       {
+         *         // Whether to force the deletion of the quota override. Setting the force parameter to 'true' ignores all quota safety checks that would fail the request. QuotaSafetyCheck lists all such validations. If force is set to true, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         force: 'placeholder-value',
+         *         // The list of quota safety checks to ignore before the override mutation. Unlike 'force' field that ignores all the quota safety checks, the 'force_only' field ignores only the specified checks; other checks are still enforced. The 'force' and 'force_only' fields cannot both be set. If force_only is specified, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         forceOnly: 'placeholder-value',
+         *         // The resource name of the override to delete. An example name would be: `projects/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion/adminOverrides/4a3f2c1d`
+         *         name: '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit/adminOverrides/my-adminOverride',
+         *       },
+         *     );
+         *   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$Consumerquotametrics$Limits$Adminoverrides$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Delete, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        delete(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         delete(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Delete, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         delete(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Delete, callback: BodyResponseCallback<Schema$Operation>): void;
         delete(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Lists all admin overrides on this limit.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *     ],
+         *   });
+         *
+         *   // 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 serviceusage.services.consumerQuotaMetrics.limits.adminOverrides.list(
+         *       {
+         *         // Requested size of the next page of data.
+         *         pageSize: 'placeholder-value',
+         *         // Token identifying which result to start with; returned by a previous list call.
+         *         pageToken: 'placeholder-value',
+         *         // The resource name of the parent quota limit, returned by a ListConsumerQuotaMetrics or GetConsumerQuotaMetric call. An example name would be: `projects/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion`
+         *         parent:
+         *           '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit',
+         *       },
+         *     );
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "overrides": []
+         *   // }
+         * }
+         *
+         * 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$Consumerquotametrics$Limits$Adminoverrides$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$List, options?: MethodOptions): GaxiosPromise<Schema$ListAdminOverridesResponse>;
+        list(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListAdminOverridesResponse>>;
         list(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$List, options: MethodOptions | BodyResponseCallback<Schema$ListAdminOverridesResponse>, callback: BodyResponseCallback<Schema$ListAdminOverridesResponse>): void;
         list(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$List, callback: BodyResponseCallback<Schema$ListAdminOverridesResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListAdminOverridesResponse>): void;
         /**
          * Updates an admin override.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.consumerQuotaMetrics.limits.adminOverrides.patch(
+         *       {
+         *         // Whether to force the update of the quota override. Setting the force parameter to 'true' ignores all quota safety checks that would fail the request. QuotaSafetyCheck lists all such validations. If force is set to true, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         force: 'placeholder-value',
+         *         // The list of quota safety checks to ignore before the override mutation. Unlike 'force' field that ignores all the quota safety checks, the 'force_only' field ignores only the specified checks; other checks are still enforced. The 'force' and 'force_only' fields cannot both be set. If force_only is specified, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         forceOnly: 'placeholder-value',
+         *         // The resource name of the override to update. An example name would be: `projects/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion/adminOverrides/4a3f2c1d`
+         *         name: '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit/adminOverrides/my-adminOverride',
+         *         // Update only the specified fields of the override. If unset, all fields will be updated.
+         *         updateMask: 'placeholder-value',
+         *
+         *         // Request body metadata
+         *         requestBody: {
+         *           // request body parameters
+         *           // {
+         *           //   "adminOverrideAncestor": "my_adminOverrideAncestor",
+         *           //   "dimensions": {},
+         *           //   "metric": "my_metric",
+         *           //   "name": "my_name",
+         *           //   "overrideValue": "my_overrideValue",
+         *           //   "unit": "my_unit"
+         *           // }
+         *         },
+         *       },
+         *     );
+         *   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$Consumerquotametrics$Limits$Adminoverrides$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        patch(params?: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Patch, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        patch(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         patch(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         patch(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Patch, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         patch(params: Params$Resource$Services$Consumerquotametrics$Limits$Adminoverrides$Patch, callback: BodyResponseCallback<Schema$Operation>): void;
@@ -3028,56 +4112,323 @@ export declare namespace serviceusage_v1beta1 {
         constructor(context: APIRequestContext);
         /**
          * Creates a consumer override. A consumer override is applied to the consumer on its own authority to limit its own quota usage. Consumer overrides cannot be used to grant more quota than would be allowed by admin overrides, producer overrides, or the default limit of the service.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.consumerQuotaMetrics.limits.consumerOverrides.create(
+         *       {
+         *         // Whether to force the creation of the quota override. Setting the force parameter to 'true' ignores all quota safety checks that would fail the request. QuotaSafetyCheck lists all such validations. If force is set to true, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         force: 'placeholder-value',
+         *         // The list of quota safety checks to ignore before the override mutation. Unlike 'force' field that ignores all the quota safety checks, the 'force_only' field ignores only the specified checks; other checks are still enforced. The 'force' and 'force_only' fields cannot both be set. If force_only is specified, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         forceOnly: 'placeholder-value',
+         *         // The resource name of the parent quota limit, returned by a ListConsumerQuotaMetrics or GetConsumerQuotaMetric call. An example name would be: `projects/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion`
+         *         parent:
+         *           '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit',
+         *
+         *         // Request body metadata
+         *         requestBody: {
+         *           // request body parameters
+         *           // {
+         *           //   "adminOverrideAncestor": "my_adminOverrideAncestor",
+         *           //   "dimensions": {},
+         *           //   "metric": "my_metric",
+         *           //   "name": "my_name",
+         *           //   "overrideValue": "my_overrideValue",
+         *           //   "unit": "my_unit"
+         *           // }
+         *         },
+         *       },
+         *     );
+         *   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$Consumerquotametrics$Limits$Consumeroverrides$Create, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        create(params?: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Create, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        create(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        create(params?: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         create(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         create(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Create, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         create(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Create, callback: BodyResponseCallback<Schema$Operation>): void;
         create(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Deletes a consumer override.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.consumerQuotaMetrics.limits.consumerOverrides.delete(
+         *       {
+         *         // Whether to force the deletion of the quota override. Setting the force parameter to 'true' ignores all quota safety checks that would fail the request. QuotaSafetyCheck lists all such validations. If force is set to true, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         force: 'placeholder-value',
+         *         // The list of quota safety checks to ignore before the override mutation. Unlike 'force' field that ignores all the quota safety checks, the 'force_only' field ignores only the specified checks; other checks are still enforced. The 'force' and 'force_only' fields cannot both be set. If force_only is specified, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         forceOnly: 'placeholder-value',
+         *         // The resource name of the override to delete. An example name would be: `projects/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion/consumerOverrides/4a3f2c1d`
+         *         name: '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit/consumerOverrides/my-consumerOverride',
+         *       },
+         *     );
+         *   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$Consumerquotametrics$Limits$Consumeroverrides$Delete, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        delete(params?: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Delete, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        delete(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        delete(params?: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         delete(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         delete(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Delete, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         delete(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Delete, callback: BodyResponseCallback<Schema$Operation>): void;
         delete(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Lists all consumer overrides on this limit.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * async function main() {
+         *   const auth = new google.auth.GoogleAuth({
+         *     // Scopes can be specified either as an array or as a single, space-delimited string.
+         *     scopes: [
+         *       'https://www.googleapis.com/auth/cloud-platform',
+         *       'https://www.googleapis.com/auth/cloud-platform.read-only',
+         *     ],
+         *   });
+         *
+         *   // 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 serviceusage.services.consumerQuotaMetrics.limits.consumerOverrides.list(
+         *       {
+         *         // Requested size of the next page of data.
+         *         pageSize: 'placeholder-value',
+         *         // Token identifying which result to start with; returned by a previous list call.
+         *         pageToken: 'placeholder-value',
+         *         // The resource name of the parent quota limit, returned by a ListConsumerQuotaMetrics or GetConsumerQuotaMetric call. An example name would be: `projects/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion`
+         *         parent:
+         *           '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit',
+         *       },
+         *     );
+         *   console.log(res.data);
+         *
+         *   // Example response
+         *   // {
+         *   //   "nextPageToken": "my_nextPageToken",
+         *   //   "overrides": []
+         *   // }
+         * }
+         *
+         * 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$Consumerquotametrics$Limits$Consumeroverrides$List, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        list(params?: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$List, options?: MethodOptions): GaxiosPromise<Schema$ListConsumerOverridesResponse>;
+        list(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        list(params?: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListConsumerOverridesResponse>>;
         list(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         list(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$List, options: MethodOptions | BodyResponseCallback<Schema$ListConsumerOverridesResponse>, callback: BodyResponseCallback<Schema$ListConsumerOverridesResponse>): void;
         list(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$List, callback: BodyResponseCallback<Schema$ListConsumerOverridesResponse>): void;
         list(callback: BodyResponseCallback<Schema$ListConsumerOverridesResponse>): void;
         /**
          * Updates a consumer override.
+         * @example
+         * ```js
+         * // Before running the sample:
+         * // - Enable the API at:
+         * //   https://console.developers.google.com/apis/api/serviceusage.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 serviceusage = google.serviceusage('v1beta1');
+         *
+         * 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 serviceusage.services.consumerQuotaMetrics.limits.consumerOverrides.patch(
+         *       {
+         *         // Whether to force the update of the quota override. Setting the force parameter to 'true' ignores all quota safety checks that would fail the request. QuotaSafetyCheck lists all such validations. If force is set to true, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         force: 'placeholder-value',
+         *         // The list of quota safety checks to ignore before the override mutation. Unlike 'force' field that ignores all the quota safety checks, the 'force_only' field ignores only the specified checks; other checks are still enforced. The 'force' and 'force_only' fields cannot both be set. If force_only is specified, it is recommended to include a case id in "X-Goog-Request-Reason" header when sending the request.
+         *         forceOnly: 'placeholder-value',
+         *         // The resource name of the override to update. An example name would be: `projects/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion/consumerOverrides/4a3f2c1d`
+         *         name: '[^/]+/[^/]+/services/my-service/consumerQuotaMetrics/my-consumerQuotaMetric/limits/my-limit/consumerOverrides/my-consumerOverride',
+         *         // Update only the specified fields of the override. If unset, all fields will be updated.
+         *         updateMask: 'placeholder-value',
+         *
+         *         // Request body metadata
+         *         requestBody: {
+         *           // request body parameters
+         *           // {
+         *           //   "adminOverrideAncestor": "my_adminOverrideAncestor",
+         *           //   "dimensions": {},
+         *           //   "metric": "my_metric",
+         *           //   "name": "my_name",
+         *           //   "overrideValue": "my_overrideValue",
+         *           //   "unit": "my_unit"
+         *           // }
+         *         },
+         *       },
+         *     );
+         *   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$Consumerquotametrics$Limits$Consumeroverrides$Patch, options: StreamMethodOptions): GaxiosPromise<Readable>;
-        patch(params?: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Patch, options?: MethodOptions): GaxiosPromise<Schema$Operation>;
+        patch(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
+        patch(params?: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Operation>>;
         patch(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
         patch(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Patch, options: MethodOptions | BodyResponseCallback<Schema$Operation>, callback: BodyResponseCallback<Schema$Operation>): void;
         patch(params: Params$Resource$Services$Consumerquotametrics$Limits$Consumeroverrides$Patch, callback: BodyResponseCallback<Schema$Operation>): void;