@googleapis/serviceusage 7.0.0 → 9.0.0

package/build/v1.d.ts

@@ -72,6 +72,24 @@ export declare namespace serviceusage_v1 {
         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_v1 {
          */
         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_v1 {
          * 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.
@@ -331,6 +359,95 @@ export declare namespace serviceusage_v1 {
      */
     export interface Schema$CancelOperationRequest {
     }
+    /**
+     * 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;
+    }
     /**
      * `Context` defines which contexts an API requests. Example: context: rules: - selector: "*" requested: - google.rpc.context.ProjectContext - google.rpc.context.OriginContext The above specifies that all methods in the API request `google.rpc.context.ProjectContext` and `google.rpc.context.OriginContext`. Available context types are defined in package `google.rpc.context`. This also provides mechanism to allowlist any protobuf message extension that can be sent in grpc metadata using “x-goog-ext--bin” and “x-goog-ext--jspb” format. For example, list any service specific protobuf types that can appear in grpc metadata as follows in your yaml file: Example: context: rules: - selector: "google.example.library.v1.LibraryService.CreateBook" allowed_request_extensions: - google.foo.v1.NewExtension allowed_response_extensions: - google.foo.v1.NewExtension You can also specify extension ID instead of fully qualified extension name here.
      */
@@ -366,13 +483,26 @@ export declare namespace serviceusage_v1 {
         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.
@@ -446,7 +576,7 @@ export declare namespace serviceusage_v1 {
         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 {
         /**
@@ -465,6 +595,10 @@ export declare namespace serviceusage_v1 {
          * 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.
          */
@@ -486,11 +620,48 @@ export declare namespace serviceusage_v1 {
          * 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); \}
      */
@@ -509,6 +680,27 @@ export declare namespace serviceusage_v1 {
          */
         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.
      */
@@ -527,6 +719,10 @@ export declare namespace serviceusage_v1 {
      * `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.
          */
@@ -544,6 +740,10 @@ export declare namespace serviceusage_v1 {
      * Enum type definition.
      */
     export interface Schema$Enum {
+        /**
+         * The source edition string, only valid when syntax is SYNTAX_EDITIONS.
+         */
+        edition?: string | null;
         /**
          * Enum value definitions.
          */
@@ -627,6 +827,23 @@ export declare namespace serviceusage_v1 {
          */
         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.
      */
@@ -729,6 +946,10 @@ export declare namespace serviceusage_v1 {
          * 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.
          */
@@ -859,6 +1080,15 @@ export declare namespace serviceusage_v1 {
          */
         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.
      */
@@ -959,6 +1189,25 @@ export declare namespace serviceusage_v1 {
          */
         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.
      */
@@ -1070,6 +1319,27 @@ export declare namespace serviceusage_v1 {
          */
         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.
      */
@@ -1103,6 +1373,32 @@ export declare namespace serviceusage_v1 {
          */
         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.
      */
@@ -1185,7 +1481,7 @@ export declare namespace serviceusage_v1 {
         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 {
         /**
@@ -1252,6 +1548,15 @@ export declare namespace serviceusage_v1 {
          */
         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.
      */
@@ -1284,7 +1589,7 @@ export declare namespace serviceusage_v1 {
          */
         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;
@@ -1331,6 +1636,69 @@ export declare namespace serviceusage_v1 {
          */
         subpages?: Schema$Page[];
     }
+    /**
+     * Settings for Php client libraries.
+     */
+    export interface Schema$PhpSettings {
+        /**
+         * Some settings.
+         */
+        common?: Schema$CommonLanguageSettings;
+    }
+    /**
+     * 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
      */
@@ -1422,6 +1790,33 @@ export declare namespace serviceusage_v1 {
          */
         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;
+    }
     /**
      * Service identity for a service. This is the identity that service producer should use to access consumer resources.
      */
@@ -1517,6 +1912,10 @@ export declare namespace serviceusage_v1 {
      * 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.
          */
@@ -1547,6 +1946,11 @@ export declare namespace serviceusage_v1 {
      */
     export interface Schema$UpdateAdminQuotaPolicyMetadata {
     }
+    /**
+     * Metadata for the `UpdateConsumerPolicy` method.
+     */
+    export interface Schema$UpdateConsumerPolicyMetadata {
+    }
     /**
      * Configuration controlling usage of a service.
      */
@@ -1586,55 +1990,6 @@ export declare namespace serviceusage_v1 {
         constructor(context: APIRequestContext);
         /**
          * Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`. Clients can use Operations.GetOperation or other methods to check whether the cancellation succeeded or whether the operation completed despite cancellation. On successful cancellation, the operation is not deleted; instead, it becomes an operation with an Operation.error value with a google.rpc.Status.code of 1, corresponding to `Code.CANCELLED`.
-         * @example
-         * ```js
-         * // Before running the sample:
-         * // - Enable the API at:
-         * //   https://console.developers.google.com/apis/api/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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/service.management',
-         *     ],
-         *   });
-         *
-         *   // Acquire an auth client, and bind it to all future calls
-         *   const authClient = await auth.getClient();
-         *   google.options({auth: authClient});
-         *
-         *   // Do the magic
-         *   const res = await serviceusage.operations.cancel({
-         *     // The name of the operation resource to be cancelled.
-         *     name: 'operations/.*',
-         *
-         *     // Request body metadata
-         *     requestBody: {
-         *       // request body parameters
-         *       // {}
-         *     },
-         *   });
-         *   console.log(res.data);
-         *
-         *   // Example response
-         *   // {}
-         * }
-         *
-         * main().catch(e => {
-         *   console.error(e);
-         *   throw e;
-         * });
-         *
-         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1649,49 +2004,6 @@ export declare namespace serviceusage_v1 {
         cancel(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Deletes a long-running operation. This method indicates that the client is no longer interested in the operation result. It does not cancel the operation. If the server doesn't support this method, it returns `google.rpc.Code.UNIMPLEMENTED`.
-         * @example
-         * ```js
-         * // Before running the sample:
-         * // - Enable the API at:
-         * //   https://console.developers.google.com/apis/api/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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/service.management',
-         *     ],
-         *   });
-         *
-         *   // Acquire an auth client, and bind it to all future calls
-         *   const authClient = await auth.getClient();
-         *   google.options({auth: authClient});
-         *
-         *   // Do the magic
-         *   const res = await serviceusage.operations.delete({
-         *     // The name of the operation resource to be deleted.
-         *     name: 'operations/.*',
-         *   });
-         *   console.log(res.data);
-         *
-         *   // Example response
-         *   // {}
-         * }
-         *
-         * main().catch(e => {
-         *   console.error(e);
-         *   throw e;
-         * });
-         *
-         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -1706,55 +2018,6 @@ export declare namespace serviceusage_v1 {
         delete(callback: BodyResponseCallback<Schema$Empty>): void;
         /**
          * Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.
-         * @example
-         * ```js
-         * // Before running the sample:
-         * // - Enable the API at:
-         * //   https://console.developers.google.com/apis/api/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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/service.management',
-         *     ],
-         *   });
-         *
-         *   // Acquire an auth client, and bind it to all future calls
-         *   const authClient = await auth.getClient();
-         *   google.options({auth: authClient});
-         *
-         *   // Do the magic
-         *   const res = await 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`.
@@ -1768,59 +2031,7 @@ export declare namespace serviceusage_v1 {
         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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/service.management',
-         *     ],
-         *   });
-         *
-         *   // Acquire an auth client, and bind it to all future calls
-         *   const authClient = await auth.getClient();
-         *   google.options({auth: authClient});
-         *
-         *   // Do the magic
-         *   const res = await 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`.
@@ -1879,63 +2090,6 @@ export declare namespace serviceusage_v1 {
         constructor(context: APIRequestContext);
         /**
          * Enable multiple services on a project. The operation is atomic: if enabling any service fails, then the entire batch fails, and no state changes occur. To enable a single service, use the `EnableService` method instead.
-         * @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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/service.management',
-         *     ],
-         *   });
-         *
-         *   // Acquire an auth client, and bind it to all future calls
-         *   const authClient = await auth.getClient();
-         *   google.options({auth: authClient});
-         *
-         *   // Do the magic
-         *   const res = await serviceusage.services.batchEnable({
-         *     // Parent to enable services on. An example name would be: `projects/123` where `123` is the project number. 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`.
@@ -1950,53 +2104,6 @@ export declare namespace serviceusage_v1 {
         batchEnable(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Returns the service configurations and enabled states for a given list of services.
-         * @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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/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.batchGet({
-         *     // Names of the services to retrieve. An example name would be: `projects/123/services/serviceusage.googleapis.com` where `123` is the project number. A single request can get a maximum of 30 services at a time.
-         *     names: 'placeholder-value',
-         *     // Parent to retrieve services from. If this is set, the parent of all of the services specified in `names` must match this field. An example name would be: `projects/123` where `123` is the project number. The `BatchGetServices` method currently only supports projects.
-         *     parent: '[^/]+/[^/]+',
-         *   });
-         *   console.log(res.data);
-         *
-         *   // Example response
-         *   // {
-         *   //   "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`.
@@ -2011,64 +2118,6 @@ export declare namespace serviceusage_v1 {
         batchGet(callback: BodyResponseCallback<Schema$BatchGetServicesResponse>): void;
         /**
          * Disable 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.
-         * @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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/service.management',
-         *     ],
-         *   });
-         *
-         *   // Acquire an auth client, and bind it to all future calls
-         *   const authClient = await auth.getClient();
-         *   google.options({auth: authClient});
-         *
-         *   // Do the magic
-         *   const res = await 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.
-         *     name: '[^/]+/[^/]+/services/my-service',
-         *
-         *     // Request body metadata
-         *     requestBody: {
-         *       // request body parameters
-         *       // {
-         *       //   "checkIfServiceHasUsage": "my_checkIfServiceHasUsage",
-         *       //   "disableDependentServices": false
-         *       // }
-         *     },
-         *   });
-         *   console.log(res.data);
-         *
-         *   // Example response
-         *   // {
-         *   //   "done": false,
-         *   //   "error": {},
-         *   //   "metadata": {},
-         *   //   "name": "my_name",
-         *   //   "response": {}
-         *   // }
-         * }
-         *
-         * main().catch(e => {
-         *   console.error(e);
-         *   throw e;
-         * });
-         *
-         * ```
          *
          * @param params - Parameters for request
          * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
@@ -2083,61 +2132,6 @@ export declare namespace serviceusage_v1 {
         disable(callback: BodyResponseCallback<Schema$Operation>): void;
         /**
          * Enable a service so that it can be used with a 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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/service.management',
-         *     ],
-         *   });
-         *
-         *   // Acquire an auth client, and bind it to all future calls
-         *   const authClient = await auth.getClient();
-         *   google.options({auth: authClient});
-         *
-         *   // Do the magic
-         *   const res = await 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.
-         *     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`.
@@ -2152,54 +2146,6 @@ export declare namespace serviceusage_v1 {
         enable(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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/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.
-         *     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`.
@@ -2214,58 +2160,6 @@ export declare namespace serviceusage_v1 {
         get(callback: BodyResponseCallback<Schema$GoogleApiServiceusageV1Service>): void;
         /**
          * List 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. WARNING: If you need to query enabled services frequently or across an organization, you should use [Cloud Asset Inventory API](https://cloud.google.com/asset-inventory/docs/apis), which provides higher throughput and richer filtering capability.
-         * @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('v1');
-         *
-         * async function main() {
-         *   const auth = new google.auth.GoogleAuth({
-         *     // Scopes can be specified either as an array or as a single, space-delimited string.
-         *     scopes: [
-         *       'https://www.googleapis.com/auth/cloud-platform',
-         *       'https://www.googleapis.com/auth/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.
-         *     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`.