@googleapis/serviceusage 7.0.0 → 8.0.0

package/build/v1beta1.d.ts

@@ -72,6 +72,24 @@ export declare namespace serviceusage_v1beta1 {
         services: Resource$Services;
         constructor(options: GlobalOptions, google?: GoogleConfigurable);
     }
+    /**
+     * Metadata for the `AddEnableRules` method.
+     */
+    export interface Schema$AddEnableRulesMetadata {
+    }
+    /**
+     * The response message of "AddEnableRules" method.
+     */
+    export interface Schema$AddEnableRulesResponse {
+        /**
+         * The values added to the parent consumer policy.
+         */
+        addedValues?: string[] | null;
+        /**
+         * The parent consumer policy. It can be `projects/12345/consumerPolicies/default`, or `folders/12345/consumerPolicies/default`, or `organizations/12345/consumerPolicies/default`.
+         */
+        parent?: string | null;
+    }
     /**
      * Quota policy created by quota administrator.
      */
@@ -81,7 +99,7 @@ export declare namespace serviceusage_v1beta1 {
          */
         container?: string | null;
         /**
-         *  If this map is nonempty, then this policy applies only to specific values for dimensions defined in the limit unit. For example, an policy on a limit with the unit `1/{project\}/{region\}` could contain an entry with the key `region` and the value `us-east-1`; the policy is only applied to quota consumed in that region. This map has the following restrictions: * If `region` appears as a key, its value must be a valid Cloud region. * If `zone` appears as a key, its value must be a valid Cloud zone. * Keys other than `region` or `zone` are not valid.
+         *  If this map is nonempty, then this policy applies only to specific values for dimensions defined in the limit unit. For example, a policy on a limit with the unit `1/{project\}/{region\}` could contain an entry with the key `region` and the value `us-east-1`; the policy is only applied to quota consumed in that region. This map has the following restrictions: * If `region` appears as a key, its value must be a valid Cloud region. * If `zone` appears as a key, its value must be a valid Cloud zone. * Keys other than `region` or `zone` are not valid.
          */
         dimensions?: {
             [key: string]: string;
@@ -241,10 +259,20 @@ export declare namespace serviceusage_v1beta1 {
          * The JWT audience is used when generating a JWT ID token for the backend. This ID token will be added in the HTTP "authorization" header, and sent to the backend.
          */
         jwtAudience?: string | null;
+        /**
+         * Deprecated, do not use.
+         */
+        minDeadline?: number | null;
         /**
          * The number of seconds to wait for the completion of a long running operation. The default is no deadline.
          */
         operationDeadline?: number | null;
+        /**
+         * The map between request protocol and the backend address.
+         */
+        overridesByRequestProtocol?: {
+            [key: string]: Schema$BackendRule;
+        } | null;
         pathTranslation?: string | null;
         /**
          * The protocol used for sending a request to the backend. The supported values are "http/1.1" and "h2". The default value is inferred from the scheme in the address field: SCHEME PROTOCOL http:// http/1.1 https:// http/1.1 grpc:// h2 grpcs:// h2 For secure HTTP backends (https://) that support HTTP/2, set this field to "h2" for improved performance. Configuring this field to non-default values is only supported for secure HTTP backends. This field will be ignored for all other backends. See https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids for more details on the supported values.
@@ -317,6 +345,95 @@ export declare namespace serviceusage_v1beta1 {
          */
         monitoredResource?: string | null;
     }
+    /**
+     * Details about how and where to publish client libraries.
+     */
+    export interface Schema$ClientLibrarySettings {
+        /**
+         * Settings for C++ client libraries.
+         */
+        cppSettings?: Schema$CppSettings;
+        /**
+         * Settings for .NET client libraries.
+         */
+        dotnetSettings?: Schema$DotnetSettings;
+        /**
+         * Settings for Go client libraries.
+         */
+        goSettings?: Schema$GoSettings;
+        /**
+         * Settings for legacy Java features, supported in the Service YAML.
+         */
+        javaSettings?: Schema$JavaSettings;
+        /**
+         * Launch stage of this version of the API.
+         */
+        launchStage?: string | null;
+        /**
+         * Settings for Node client libraries.
+         */
+        nodeSettings?: Schema$NodeSettings;
+        /**
+         * Settings for PHP client libraries.
+         */
+        phpSettings?: Schema$PhpSettings;
+        /**
+         * Settings for Python client libraries.
+         */
+        pythonSettings?: Schema$PythonSettings;
+        /**
+         * When using transport=rest, the client request will encode enums as numbers rather than strings.
+         */
+        restNumericEnums?: boolean | null;
+        /**
+         * Settings for Ruby client libraries.
+         */
+        rubySettings?: Schema$RubySettings;
+        /**
+         * Version of the API to apply these settings to. This is the full protobuf package for the API, ending in the version element. Examples: "google.cloud.speech.v1" and "google.spanner.admin.database.v1".
+         */
+        version?: string | null;
+    }
+    /**
+     * Required information for every language.
+     */
+    export interface Schema$CommonLanguageSettings {
+        /**
+         * The destination where API teams want this client library to be published.
+         */
+        destinations?: string[] | null;
+        /**
+         * Link to automatically generated reference documentation. Example: https://cloud.google.com/nodejs/docs/reference/asset/latest
+         */
+        referenceDocsUri?: string | null;
+    }
+    /**
+     * Consumer Policy is a set of rules that define what services or service groups can be used for a cloud resource hierarchy.
+     */
+    export interface Schema$ConsumerPolicy {
+        /**
+         * Optional. Annotations is an unstructured key-value map stored with a policy that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. [AIP-128](https://google.aip.dev/128#annotations)
+         */
+        annotations?: {
+            [key: string]: string;
+        } | null;
+        /**
+         * Enable rules define usable services and service groups.
+         */
+        enableRules?: Schema$EnableRule[];
+        /**
+         * An opaque tag indicating the current version of the policy, used for concurrency control.
+         */
+        etag?: string | null;
+        /**
+         * Output only. The resource name of the policy. For example, We only allow consumer policy name as "default" for now: `projects/12345/consumerPolicies/default`, `folders/12345/consumerPolicies/default`, `organizations/12345/consumerPolicies/default`. Legacy format: `projects/12345/consumerPoly`
+         */
+        name?: string | null;
+        /**
+         * The last-modified time.
+         */
+        updateTime?: string | null;
+    }
     /**
      * Consumer quota settings for a quota limit.
      */
@@ -414,13 +531,26 @@ export declare namespace serviceusage_v1beta1 {
         selector?: string | null;
     }
     /**
-     * Selects and configures the service controller used by the service. The service controller handles two things: - **What is allowed:** for each API request, Chemist checks the project status, activation status, abuse status, billing status, service status, location restrictions, VPC Service Controls, SuperQuota, and other policies. - **What has happened:** for each API response, Chemist reports the telemetry data to analytics, auditing, billing, eventing, logging, monitoring, sawmill, and tracing. Chemist also accepts telemetry data not associated with API traffic, such as billing metrics. Example: control: environment: servicecontrol.googleapis.com
+     * Selects and configures the service controller used by the service. Example: control: environment: servicecontrol.googleapis.com
      */
     export interface Schema$Control {
         /**
          * The service controller environment to use. If empty, no control plane feature (like quota and billing) will be enabled. The recommended value for most services is servicecontrol.googleapis.com
          */
         environment?: string | null;
+        /**
+         * Defines policies applying to the API methods of the service.
+         */
+        methodPolicies?: Schema$MethodPolicy[];
+    }
+    /**
+     * Settings for C++ client libraries.
+     */
+    export interface Schema$CppSettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
     }
     /**
      * Metadata message that provides information such as progress, partial failures, and similar information on each GetOperation call of LRO returned by CreateAdminQuotaPolicy.
@@ -486,7 +616,7 @@ export declare namespace serviceusage_v1beta1 {
         service?: Schema$GoogleApiServiceusageV1Service;
     }
     /**
-     * `Documentation` provides the information for describing a service. Example: documentation: summary: \> The Google Calendar API gives access to most calendar features. pages: - name: Overview content: (== include google/foo/overview.md ==) - name: Tutorial content: (== include google/foo/tutorial.md ==) subpages; - name: Java content: (== include google/foo/tutorial_java.md ==) rules: - selector: google.calendar.Calendar.Get description: \> ... - selector: google.calendar.Calendar.Put description: \> ... Documentation is provided in markdown syntax. In addition to standard markdown features, definition lists, tables and fenced code blocks are supported. Section headers can be provided and are interpreted relative to the section nesting of the context where a documentation fragment is embedded. Documentation from the IDL is merged with documentation defined via the config at normalization time, where documentation provided by config rules overrides IDL provided. A number of constructs specific to the API platform are supported in documentation text. In order to reference a proto element, the following notation can be used: [fully.qualified.proto.name][] To override the display text used for the link, this can be used: [display text][fully.qualified.proto.name] Text can be excluded from doc using the following notation: (-- internal comment --) A few directives are available in documentation. Note that directives must appear on a single line to be properly identified. The `include` directive includes a markdown file from an external source: (== include path/to/file ==) The `resource_for` directive marks a message to be the resource of a collection in REST view. If it is not specified, tools attempt to infer the resource from the operations in a collection: (== resource_for v1.shelves.books ==) The directive `suppress_warning` does not directly affect documentation and is documented together with service config validation.
+     * `Documentation` provides the information for describing a service. Example: documentation: summary: \> The Google Calendar API gives access to most calendar features. pages: - name: Overview content: (== include google/foo/overview.md ==) - name: Tutorial content: (== include google/foo/tutorial.md ==) subpages: - name: Java content: (== include google/foo/tutorial_java.md ==) rules: - selector: google.calendar.Calendar.Get description: \> ... - selector: google.calendar.Calendar.Put description: \> ... Documentation is provided in markdown syntax. In addition to standard markdown features, definition lists, tables and fenced code blocks are supported. Section headers can be provided and are interpreted relative to the section nesting of the context where a documentation fragment is embedded. Documentation from the IDL is merged with documentation defined via the config at normalization time, where documentation provided by config rules overrides IDL provided. A number of constructs specific to the API platform are supported in documentation text. In order to reference a proto element, the following notation can be used: [fully.qualified.proto.name][] To override the display text used for the link, this can be used: [display text][fully.qualified.proto.name] Text can be excluded from doc using the following notation: (-- internal comment --) A few directives are available in documentation. Note that directives must appear on a single line to be properly identified. The `include` directive includes a markdown file from an external source: (== include path/to/file ==) The `resource_for` directive marks a message to be the resource of a collection in REST view. If it is not specified, tools attempt to infer the resource from the operations in a collection: (== resource_for v1.shelves.books ==) The directive `suppress_warning` does not directly affect documentation and is documented together with service config validation.
      */
     export interface Schema$Documentation {
         /**
@@ -505,6 +635,10 @@ export declare namespace serviceusage_v1beta1 {
          * A list of documentation rules that apply to individual API elements. **NOTE:** All service configuration rules follow "last one wins" order.
          */
         rules?: Schema$DocumentationRule[];
+        /**
+         * Specifies section and content to override boilerplate content provided by go/api-docgen. Currently overrides following sections: 1. rest.service.client_libraries
+         */
+        sectionOverrides?: Schema$Page[];
         /**
          * Specifies the service root url if the default one (the service name from the yaml file) is not suitable. This can be seen in any fully specified service urls as well as sections that show a base that other urls are relative to.
          */
@@ -526,11 +660,48 @@ export declare namespace serviceusage_v1beta1 {
          * Description of the selected proto element (e.g. a message, a method, a 'service' definition, or a field). Defaults to leading & trailing comments taken from the proto source definition of the proto element.
          */
         description?: string | null;
+        /**
+         * String of comma or space separated case-sensitive words for which method/field name replacement will be disabled by go/api-docgen.
+         */
+        disableReplacementWords?: string | null;
         /**
          * The selector is a comma-separated list of patterns for any element such as a method, a field, an enum value. Each pattern is a qualified name of the element which may end in "*", indicating a wildcard. Wildcards are only allowed at the end and for a whole component of the qualified name, i.e. "foo.*" is ok, but not "foo.b*" or "foo.*.bar". A wildcard will match one or more components. To specify a default for all applicable elements, the whole pattern "*" is used.
          */
         selector?: string | null;
     }
+    /**
+     * Settings for Dotnet client libraries.
+     */
+    export interface Schema$DotnetSettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
+        /**
+         * Namespaces which must be aliased in snippets due to a known (but non-generator-predictable) naming collision
+         */
+        forcedNamespaceAliases?: string[] | null;
+        /**
+         * Method signatures (in the form "service.method(signature)") which are provided separately, so shouldn't be generated. Snippets *calling* these methods are still generated, however.
+         */
+        handwrittenSignatures?: string[] | null;
+        /**
+         * List of full resource types to ignore during generation. This is typically used for API-specific Location resources, which should be handled by the generator as if they were actually the common Location resources. Example entry: "documentai.googleapis.com/Location"
+         */
+        ignoredResources?: string[] | null;
+        /**
+         * Map from full resource types to the effective short name for the resource. This is used when otherwise resource named from different services would cause naming collisions. Example entry: "datalabeling.googleapis.com/Dataset": "DataLabelingDataset"
+         */
+        renamedResources?: {
+            [key: string]: string;
+        } | null;
+        /**
+         * Map from original service names to renamed versions. This is used when the default generated types would cause a naming conflict. (Neither name is fully-qualified.) Example: Subscriber to SubscriberServiceApi.
+         */
+        renamedServices?: {
+            [key: string]: string;
+        } | null;
+    }
     /**
      * A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); \}
      */
@@ -549,6 +720,27 @@ export declare namespace serviceusage_v1beta1 {
          */
         serviceId?: string | null;
     }
+    /**
+     * The consumer policy rule that defines usable services and service groups.
+     */
+    export interface Schema$EnableRule {
+        /**
+         * Client and resource project enable type.
+         */
+        enableType?: string | null;
+        /**
+         * DEPRECATED: Please use field `values`. Service group should have prefix `groups/`. The names of the service groups that are enabled (Not Implemented). go/predefined-service-groups. Example: `groups/googleServices`.
+         */
+        groups?: string[] | null;
+        /**
+         * DEPRECATED: Please use field `values`. Service should have prefix `services/`. The names of the services that are enabled. Example: `storage.googleapis.com`.
+         */
+        services?: string[] | null;
+        /**
+         * The names of the services or service groups that are enabled. Example: `services/storage.googleapis.com`, groups/googleServices`, groups/allServices`.
+         */
+        values?: string[] | null;
+    }
     /**
      * Request message for the `EnableService` method.
      */
@@ -567,6 +759,10 @@ export declare namespace serviceusage_v1beta1 {
      * `Endpoint` describes a network address of a service that serves a set of APIs. It is commonly known as a service endpoint. A service may expose any number of service endpoints, and all service endpoints share the same service definition, such as quota limits and monitoring metrics. Example: type: google.api.Service name: library-example.googleapis.com endpoints: # Declares network address `https://library-example.googleapis.com` # for service `library-example.googleapis.com`. The `https` scheme # is implicit for all service endpoints. Other schemes may be # supported in the future. - name: library-example.googleapis.com allow_cors: false - name: content-staging-library-example.googleapis.com # Allows HTTP OPTIONS calls to be passed to the API frontend, for it # to decide whether the subsequent cross-origin request is allowed # to proceed. allow_cors: true
      */
     export interface Schema$Endpoint {
+        /**
+         * Unimplemented. Dot not use. DEPRECATED: This field is no longer supported. Instead of using aliases, please specify multiple google.api.Endpoint for each of the intended aliases. Additional names that this endpoint will be hosted on.
+         */
+        aliases?: string[] | null;
         /**
          * Allowing [CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing), aka cross-domain traffic, would allow the backends served from this endpoint to receive and respond to HTTP OPTIONS requests. The response will be used by the browser to determine whether the subsequent cross-origin request is allowed to proceed.
          */
@@ -584,6 +780,10 @@ export declare namespace serviceusage_v1beta1 {
      * Enum type definition.
      */
     export interface Schema$Enum {
+        /**
+         * The source edition string, only valid when syntax is SYNTAX_EDITIONS.
+         */
+        edition?: string | null;
         /**
          * Enum value definitions.
          */
@@ -667,6 +867,23 @@ export declare namespace serviceusage_v1beta1 {
          */
         typeUrl?: string | null;
     }
+    /**
+     * Google API Policy Annotation This message defines a simple API policy annotation that can be used to annotate API request and response message fields with applicable policies. One field may have multiple applicable policies that must all be satisfied before a request can be processed. This policy annotation is used to generate the overall policy that will be used for automatic runtime policy enforcement and documentation generation.
+     */
+    export interface Schema$FieldPolicy {
+        /**
+         * Specifies the required permission(s) for the resource referred to by the field. It requires the field contains a valid resource reference, and the request must pass the permission checks to proceed. For example, "resourcemanager.projects.get".
+         */
+        resourcePermission?: string | null;
+        /**
+         * Specifies the resource type for the resource referred to by the field.
+         */
+        resourceType?: string | null;
+        /**
+         * Selects one or more request or response message fields to apply this `FieldPolicy`. When a `FieldPolicy` is used in proto annotation, the selector must be left as empty. The service config generator will automatically fill the correct value. When a `FieldPolicy` is used in service config, the selector must be a comma-separated string with valid request or response field paths, such as "foo.bar" or "foo.bar,foo.baz".
+         */
+        selector?: string | null;
+    }
     /**
      * Metadata for the `GetServiceIdentity` method.
      */
@@ -769,6 +986,10 @@ export declare namespace serviceusage_v1beta1 {
          * The Google project that owns this service.
          */
         producerProjectId?: string | null;
+        /**
+         * Settings for [Google Cloud Client libraries](https://cloud.google.com/apis/docs/cloud-client-libraries) generated from APIs defined as protocol buffers.
+         */
+        publishing?: Schema$Publishing;
         /**
          * Quota configuration.
          */
@@ -899,6 +1120,15 @@ export declare namespace serviceusage_v1beta1 {
          */
         usage?: Schema$Usage;
     }
+    /**
+     * Settings for Go client libraries.
+     */
+    export interface Schema$GoSettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
+    }
     /**
      * Defines the HTTP configuration for an API service. It contains a list of HttpRule, each specifying the mapping of an RPC method to one or more HTTP REST API methods.
      */
@@ -1033,6 +1263,25 @@ export declare namespace serviceusage_v1beta1 {
          */
         overrides?: Schema$QuotaOverride[];
     }
+    /**
+     * Settings for Java client libraries.
+     */
+    export interface Schema$JavaSettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
+        /**
+         * The package name to use in Java. Clobbers the java_package option set in the protobuf. This should be used **only** by APIs who have already set the language_settings.java.package_name" field in gapic.yaml. API teams should use the protobuf java_package option where possible. Example of a YAML configuration:: publishing: java_settings: library_package: com.google.cloud.pubsub.v1
+         */
+        libraryPackage?: string | null;
+        /**
+         * Configure the Java class name to use instead of the service's for its corresponding generated GAPIC client. Keys are fully-qualified service names as they appear in the protobuf (including the full the language_settings.java.interface_names" field in gapic.yaml. API teams should otherwise use the service name as it appears in the protobuf. Example of a YAML configuration:: publishing: java_settings: service_class_names: - google.pubsub.v1.Publisher: TopicAdmin - google.pubsub.v1.Subscriber: SubscriptionAdmin
+         */
+        serviceClassNames?: {
+            [key: string]: string;
+        } | null;
+    }
     /**
      * Specifies a location to extract JWT from an API request.
      */
@@ -1183,6 +1432,27 @@ export declare namespace serviceusage_v1beta1 {
          */
         monitoredResource?: string | null;
     }
+    /**
+     * Describes settings to use when generating API methods that use the long-running operation pattern. All default values below are from those used in the client library generators (e.g. [Java](https://github.com/googleapis/gapic-generator-java/blob/04c2faa191a9b5a10b92392fe8482279c4404803/src/main/java/com/google/api/generator/gapic/composer/common/RetrySettingsComposer.java)).
+     */
+    export interface Schema$LongRunning {
+        /**
+         * Initial delay after which the first poll request will be made. Default value: 5 seconds.
+         */
+        initialPollDelay?: string | null;
+        /**
+         * Maximum time between two subsequent poll requests. Default value: 45 seconds.
+         */
+        maxPollDelay?: string | null;
+        /**
+         * Multiplier to gradually increase delay between subsequent polls until it reaches max_poll_delay. Default value: 1.5.
+         */
+        pollDelayMultiplier?: number | null;
+        /**
+         * Total polling timeout. Default value: 5 minutes.
+         */
+        totalPollTimeout?: string | null;
+    }
     /**
      * Method represents a method of an API interface.
      */
@@ -1216,6 +1486,32 @@ export declare namespace serviceusage_v1beta1 {
          */
         syntax?: string | null;
     }
+    /**
+     * Defines policies applying to an RPC method.
+     */
+    export interface Schema$MethodPolicy {
+        /**
+         * Policies that are applicable to the request message.
+         */
+        requestPolicies?: Schema$FieldPolicy[];
+        /**
+         * Selects a method to which these policies should be enforced, for example, "google.pubsub.v1.Subscriber.CreateSubscription". Refer to selector for syntax details. NOTE: This field must not be set in the proto annotation. It will be automatically filled by the service config compiler .
+         */
+        selector?: string | null;
+    }
+    /**
+     * Describes the generator configuration for a method.
+     */
+    export interface Schema$MethodSettings {
+        /**
+         * 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: seconds: 60 # 1 minute poll_delay_multiplier: 1.5 max_poll_delay: seconds: 360 # 6 minutes total_poll_timeout: seconds: 54000 # 90 minutes
+         */
+        longRunning?: Schema$LongRunning;
+        /**
+         * The fully qualified name of the method, for which the options below apply. This is used to find the method to apply the options.
+         */
+        selector?: string | null;
+    }
     /**
      * Defines a metric type and its schema. Once a metric descriptor is created, deleting or altering it stops data collection and makes the metric type's existing data unusable.
      */
@@ -1298,7 +1594,7 @@ export declare namespace serviceusage_v1beta1 {
         selector?: string | null;
     }
     /**
-     * Declares an API Interface to be included in this interface. The including interface must redeclare all the methods from the included interface, but documentation and options are inherited as follows: - If after comment and whitespace stripping, the documentation string of the redeclared method is empty, it will be inherited from the original method. - Each annotation belonging to the service config (http, visibility) which is not set in the redeclared method will be inherited. - If an http annotation is inherited, the path pattern will be modified as follows. Any version prefix will be replaced by the version of the including interface plus the root path if specified. Example of a simple mixin: package google.acl.v1; service AccessControl { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v1/{resource=**\}:getAcl"; \} \} package google.storage.v2; service Storage { // rpc GetAcl(GetAclRequest) returns (Acl); // Get a data record. rpc GetData(GetDataRequest) returns (Data) { option (google.api.http).get = "/v2/{resource=**\}"; \} \} Example of a mixin configuration: apis: - name: google.storage.v2.Storage mixins: - name: google.acl.v1.AccessControl The mixin construct implies that all methods in `AccessControl` are also declared with same name and request/response types in `Storage`. A documentation generator or annotation processor will see the effective `Storage.GetAcl` method after inheriting documentation and annotations as follows: service Storage { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v2/{resource=**\}:getAcl"; \} ... \} Note how the version in the path pattern changed from `v1` to `v2`. If the `root` field in the mixin is specified, it should be a relative path under which inherited HTTP paths are placed. Example: apis: - name: google.storage.v2.Storage mixins: - name: google.acl.v1.AccessControl root: acls This implies the following inherited HTTP annotation: service Storage { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v2/acls/{resource=**\}:getAcl"; \} ... \}
+     * Declares an API Interface to be included in this interface. The including interface must redeclare all the methods from the included interface, but documentation and options are inherited as follows: - If after comment and whitespace stripping, the documentation string of the redeclared method is empty, it will be inherited from the original method. - Each annotation belonging to the service config (http, visibility) which is not set in the redeclared method will be inherited. - If an http annotation is inherited, the path pattern will be modified as follows. Any version prefix will be replaced by the version of the including interface plus the root path if specified. Example of a simple mixin: package google.acl.v1; service AccessControl { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v1/{resource=**\}:getAcl"; \} \} package google.storage.v2; service Storage { // rpc GetAcl(GetAclRequest) returns (Acl); // Get a data record. rpc GetData(GetDataRequest) returns (Data) { option (google.api.http).get = "/v2/{resource=**\}"; \} \} Example of a mixin configuration: apis: - name: google.storage.v2.Storage mixins: - name: google.acl.v1.AccessControl The mixin construct implies that all methods in `AccessControl` are also declared with same name and request/response types in `Storage`. A documentation generator or annotation processor will see the effective `Storage.GetAcl` method after inherting documentation and annotations as follows: service Storage { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v2/{resource=**\}:getAcl"; \} ... \} Note how the version in the path pattern changed from `v1` to `v2`. If the `root` field in the mixin is specified, it should be a relative path under which inherited HTTP paths are placed. Example: apis: - name: google.storage.v2.Storage mixins: - name: google.acl.v1.AccessControl root: acls This implies the following inherited HTTP annotation: service Storage { // Get the underlying ACL object. rpc GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = "/v2/acls/{resource=**\}:getAcl"; \} ... \}
      */
     export interface Schema$Mixin {
         /**
@@ -1365,6 +1661,15 @@ export declare namespace serviceusage_v1beta1 {
          */
         monitoredResource?: string | null;
     }
+    /**
+     * Settings for Node client libraries.
+     */
+    export interface Schema$NodeSettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
+    }
     /**
      * OAuth scopes are a way to define data and permissions on data. For example, there are scopes defined for "Read-only access to Google Calendar" and "Access to Cloud Platform". Users can consent to a scope for an application, giving it permission to access that data on their behalf. OAuth scope specifications should be fairly coarse grained; a user will need to see and understand the text description of what your scope means. In most cases: use one or at most two OAuth scopes for an entire family of products. If your product has multiple APIs, you should probably be sharing the OAuth scope across all of those APIs. When you need finer grained OAuth consent screens: talk with your product management about how developers will use them in practice. Please note that even though each of the canonical scopes is enough for a request to be accepted and passed to the backend, a request can still fail due to the backend requiring additional scopes or permissions.
      */
@@ -1397,7 +1702,7 @@ export declare namespace serviceusage_v1beta1 {
          */
         name?: string | null;
         /**
-         * The normal response of the operation in case of success. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
+         * The normal, successful response of the operation. If the original method returns no data on success, such as `Delete`, the response is `google.protobuf.Empty`. If the original method is standard `Get`/`Create`/`Update`, the response should be the resource. For other methods, the response should have the type `XxxResponse`, where `Xxx` is the original method name. For example, if the original method name is `TakeSnapshot()`, the inferred response type is `TakeSnapshotResponse`.
          */
         response?: {
             [key: string]: any;
@@ -1453,6 +1758,100 @@ export declare namespace serviceusage_v1beta1 {
          */
         subpages?: Schema$Page[];
     }
+    /**
+     * Settings for Php client libraries.
+     */
+    export interface Schema$PhpSettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
+    }
+    /**
+     * Quota policy created by service producer.
+     */
+    export interface Schema$ProducerQuotaPolicy {
+        /**
+         * The cloud resource container at which the quota policy is created. The format is `{container_type\}/{container_number\}`
+         */
+        container?: string | null;
+        /**
+         *  If this map is nonempty, then this policy applies only to specific values for dimensions defined in the limit unit. For example, a policy on a limit with the unit `1/{project\}/{region\}` could contain an entry with the key `region` and the value `us-east-1`; the policy is only applied to quota consumed in that region. This map has the following restrictions: * Keys that are not defined in the limit's unit are not valid keys. Any string appearing in {brackets\} in the unit (besides {project\} or {user\}) is a defined key. * `project` is not a valid key; the project is already specified in the parent resource name. * `user` is not a valid key; the API does not support quota policies that apply only to a specific user. * If `region` appears as a key, its value must be a valid Cloud region. * If `zone` appears as a key, its value must be a valid Cloud zone. * If any valid key other than `region` or `zone` appears in the map, then all valid keys other than `region` or `zone` must also appear in the map.
+         */
+        dimensions?: {
+            [key: string]: string;
+        } | null;
+        /**
+         * The name of the metric to which this policy applies. An example name would be: `compute.googleapis.com/cpus`
+         */
+        metric?: string | null;
+        /**
+         * The resource name of the policy. This name is generated by the server when the policy is created. Example names would be: `organizations/123/services/compute.googleapis.com/consumerQuotaMetrics/compute.googleapis.com%2Fcpus/limits/%2Fproject%2Fregion/producerQuotaPolicies/4a3f2c1d`
+         */
+        name?: string | null;
+        /**
+         * The quota policy value. Can be any nonnegative integer, or -1 (unlimited quota).
+         */
+        policyValue?: string | null;
+        /**
+         * The limit unit of the limit to which this policy applies. An example unit would be: `1/{project\}/{region\}` Note that `{project\}` and `{region\}` are not placeholders in this example; the literal characters `{` and `\}` occur in the string.
+         */
+        unit?: string | null;
+    }
+    /**
+     * This message configures the settings for publishing [Google Cloud Client libraries](https://cloud.google.com/apis/docs/cloud-client-libraries) generated from the service config.
+     */
+    export interface Schema$Publishing {
+        /**
+         * Used as a tracking tag when collecting data about the APIs developer relations artifacts like docs, packages delivered to package managers, etc. Example: "speech".
+         */
+        apiShortName?: string | null;
+        /**
+         * GitHub teams to be added to CODEOWNERS in the directory in GitHub containing source code for the client libraries for this API.
+         */
+        codeownerGithubTeams?: string[] | null;
+        /**
+         * A prefix used in sample code when demarking regions to be included in documentation.
+         */
+        docTagPrefix?: string | null;
+        /**
+         * Link to product home page. Example: https://cloud.google.com/asset-inventory/docs/overview
+         */
+        documentationUri?: string | null;
+        /**
+         * GitHub label to apply to issues and pull requests opened for this API.
+         */
+        githubLabel?: string | null;
+        /**
+         * Client library settings. If the same version string appears multiple times in this list, then the last one wins. Settings from earlier settings with the same version string are discarded.
+         */
+        librarySettings?: Schema$ClientLibrarySettings[];
+        /**
+         * A list of API method settings, e.g. the behavior for methods that use the long-running operation pattern.
+         */
+        methodSettings?: Schema$MethodSettings[];
+        /**
+         * Link to a *public* URI where users can report issues. Example: https://issuetracker.google.com/issues/new?component=190865&template=1161103
+         */
+        newIssueUri?: string | null;
+        /**
+         * For whom the client library is being published.
+         */
+        organization?: string | null;
+        /**
+         * Optional link to proto reference documentation. Example: https://cloud.google.com/pubsub/lite/docs/reference/rpc
+         */
+        protoReferenceDocumentationUri?: string | null;
+    }
+    /**
+     * Settings for Python client libraries.
+     */
+    export interface Schema$PythonSettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
+    }
     /**
      * Quota configuration helps to achieve fairness and budgeting in service usage. The metric based quota configuration works this way: - The service configuration defines a set of metrics. - For API calls, the quota.metric_rules maps methods to metrics with corresponding costs. - The quota.limits defines limits on the metrics, which will be used for quota checks at runtime. An example quota configuration in yaml format: quota: limits: - name: apiWriteQpsPerProject metric: library.googleapis.com/write_calls unit: "1/min/{project\}" # rate limit for consumer projects values: STANDARD: 10000 (The metric rules bind all methods to the read_calls metric, except for the UpdateBook and DeleteBook methods. These two methods are mapped to the write_calls metric, with the UpdateBook method consuming at twice rate as the DeleteBook method.) metric_rules: - selector: "*" metric_costs: library.googleapis.com/read_calls: 1 - selector: google.example.library.v1.LibraryService.UpdateBook metric_costs: library.googleapis.com/write_calls: 2 - selector: google.example.library.v1.LibraryService.DeleteBook metric_costs: library.googleapis.com/write_calls: 1 Corresponding Metric definition: metrics: - name: library.googleapis.com/read_calls display_name: Read requests metric_kind: DELTA value_type: INT64 - name: library.googleapis.com/write_calls display_name: Write requests metric_kind: DELTA value_type: INT64
      */
@@ -1496,6 +1895,10 @@ export declare namespace serviceusage_v1beta1 {
          * Producer override on this quota bucket.
          */
         producerOverride?: Schema$QuotaOverride;
+        /**
+         * Producer policy inherited from the closet ancestor of the current consumer.
+         */
+        producerQuotaPolicy?: Schema$ProducerQuotaPolicy;
     }
     /**
      * `QuotaLimit` defines a specific limit that applies over a specified duration for a limit type. There can be at most one limit for a duration and limit type combination defined within a `QuotaGroup`.
@@ -1575,6 +1978,33 @@ export declare namespace serviceusage_v1beta1 {
          */
         unit?: string | null;
     }
+    /**
+     * Metadata for the `RemoveEnableRules` method.
+     */
+    export interface Schema$RemoveEnableRulesMetadata {
+    }
+    /**
+     * The response message of "RemoveEnableRules" method.
+     */
+    export interface Schema$RemoveEnableRulesResponse {
+        /**
+         * The parent consumer policy. It can be `projects/12345/consumerPolicies/default`, or `folders/12345/consumerPolicies/default`, or `organizations/12345/consumerPolicies/default`.
+         */
+        parent?: string | null;
+        /**
+         * The values removed from the parent consumer policy.
+         */
+        removedValues?: string[] | null;
+    }
+    /**
+     * Settings for Ruby client libraries.
+     */
+    export interface Schema$RubySettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
+    }
     /**
      * A service that is available for use by the consumer.
      */
@@ -1736,6 +2166,10 @@ export declare namespace serviceusage_v1beta1 {
      * A protocol buffer message type.
      */
     export interface Schema$Type {
+        /**
+         * The source edition string, only valid when syntax is SYNTAX_EDITIONS.
+         */
+        edition?: string | null;
         /**
          * The list of fields.
          */
@@ -1766,6 +2200,11 @@ export declare namespace serviceusage_v1beta1 {
      */
     export interface Schema$UpdateAdminQuotaPolicyMetadata {
     }
+    /**
+     * Metadata for the `UpdateConsumerPolicy` method.
+     */
+    export interface Schema$UpdateConsumerPolicyMetadata {
+    }
     /**
      * Configuration controlling usage of a service.
      */
@@ -1805,55 +2244,6 @@ 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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -1867,59 +2257,7 @@ export declare namespace serviceusage_v1beta1 {
         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`. NOTE: the `name` binding allows API services to override the binding to use different resource name schemes, such as `users/x/operations`. To override the binding, API services can add a binding such as `"/v1/{name=users/x\}/operations"` to their service configuration. For backwards compatibility, the default name includes the operations collection id, however overriding users must ensure the name binding is the parent resource, without the operations collection id.
-         * @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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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;
-         * });
-         *
-         * ```
+         * Lists operations that match the specified filter in the request. If the server doesn't support this method, it returns `UNIMPLEMENTED`.
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1963,63 +2301,6 @@ 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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2034,61 +2315,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2103,61 +2329,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2172,55 +2343,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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 only support projects. An example name would be: `projects/123/services/example.googleapis.com` where `123` is the project number.
-         *     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`.
@@ -2235,54 +2357,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2297,58 +2371,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2394,7 +2416,7 @@ export declare namespace serviceusage_v1beta1 {
     }
     export interface Params$Resource$Services$Generateserviceidentity extends StandardParameters {
         /**
-         * Name of the consumer and service to generate an identity for. The `GenerateServiceIdentity` methods currently only support projects. An example name would be: `projects/123/services/example.googleapis.com` where `123` is the project number.
+         * 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?: string;
     }
@@ -2428,58 +2450,6 @@ 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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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 limit. An example name would be: `projects/123/services/serviceusage.googleapis.com/quotas/metrics/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`.
@@ -2494,66 +2464,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2568,66 +2478,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2642,58 +2492,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2762,59 +2560,6 @@ 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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -2843,76 +2588,6 @@ 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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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.
-         *         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.
-         *         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`.
@@ -2927,62 +2602,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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.
-         *         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.
-         *         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`.
@@ -2997,60 +2616,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -3065,77 +2630,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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.
-         *         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.
-         *         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`.
@@ -3222,76 +2716,6 @@ 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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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.
-         *         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.
-         *         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`.
@@ -3306,62 +2730,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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.
-         *         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.
-         *         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`.
@@ -3376,60 +2744,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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`.
@@ -3444,77 +2758,6 @@ export declare namespace serviceusage_v1beta1 {
         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:
-         * //   `$ gcloud auth application-default login`
-         * // - Install the npm module by running:
-         * //   `$ 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.
-         *         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.
-         *         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`.