@googleapis/serviceusage 14.0.0 → 15.0.1

package/v1.ts

@@ -252,6 +252,19 @@ export namespace serviceusage_v1 {
      */
     version?: string | null;
   }
+  /**
+   * Aspect represents Generic aspect. It is used to configure an aspect without making direct changes to service.proto
+   */
+  export interface Schema$Aspect {
+    /**
+     * The type of this aspect configuration.
+     */
+    kind?: string | null;
+    /**
+     * Content of the configuration. The underlying schema should be defined by Aspect owners as protobuf message under `apiserving/configaspects/proto`.
+     */
+    spec?: {[key: string]: any} | null;
+  }
   /**
    * `Authentication` defines the authentication configuration for API methods provided by an API service. Example: name: calendar.googleapis.com authentication: providers: - id: google_calendar_auth jwks_uri: https://www.googleapis.com/oauth2/v1/certs issuer: https://securetoken.google.com rules: - selector: "*" requirements: provider_id: google_calendar_auth - selector: google.calendar.Delegate oauth: canonical_scopes: https://www.googleapis.com/auth/calendar.read
    */
@@ -357,6 +370,10 @@ export 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;
+    /**
+     * The load balancing policy used for connection to the application backend. Defined as an arbitrary string to accomondate custom load balancing policies supported by the underlying channel, but suggest most users use one of the standard policies, such as the default, "RoundRobin".
+     */
+    loadBalancingPolicy?: string | null;
     /**
      * Deprecated, do not use.
      */
@@ -515,6 +532,10 @@ export namespace serviceusage_v1 {
      * Link to automatically generated reference documentation. Example: https://cloud.google.com/nodejs/docs/reference/asset/latest
      */
     referenceDocsUri?: string | null;
+    /**
+     * Configuration for which RPCs should be generated in the GAPIC client.
+     */
+    selectiveGapicGeneration?: Schema$SelectiveGapicGeneration;
   }
   /**
    * Consumer Policy is a set of rules that define what services or service groups can be used for a cloud resource hierarchy.
@@ -670,6 +691,10 @@ export namespace serviceusage_v1 {
    * `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 {
+    /**
+     * Optional information about the IAM configuration. This is typically used to link to documentation about a product's IAM roles and permissions.
+     */
+    additionalIamInfo?: string | null;
     /**
      * The URL to the root of documentation.
      */
@@ -687,7 +712,7 @@ export namespace serviceusage_v1 {
      */
     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
+     * Specifies section and content to override the boilerplate content. Currently overrides following sections: 1. rest.service.client_libraries
      */
     sectionOverrides?: Schema$Page[];
     /**
@@ -712,7 +737,7 @@ export namespace serviceusage_v1 {
      */
     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.
+     * String of comma or space separated case-sensitive words for which method/field name replacement will be disabled.
      */
     disableReplacementWords?: string | null;
     /**
@@ -867,6 +892,23 @@ export namespace serviceusage_v1 {
      */
     options?: Schema$Option[];
   }
+  /**
+   * Experimental features to be included during client library generation. These fields will be deprecated once the feature graduates and is enabled by default.
+   */
+  export interface Schema$ExperimentalFeatures {
+    /**
+     * Enables generation of protobuf code using new types that are more Pythonic which are included in `protobuf\>=5.29.x`. This feature will be enabled by default 1 month after launching the feature in preview packages.
+     */
+    protobufPythonicTypesEnabled?: boolean | null;
+    /**
+     * Enables generation of asynchronous REST clients if `rest` transport is enabled. By default, asynchronous REST clients will not be generated. This feature will be enabled by default 1 month after launching the feature in preview packages.
+     */
+    restAsyncIoEnabled?: boolean | null;
+    /**
+     * Disables generation of an unversioned Python package for this client library. This means that the module names will need to be versioned in import statements. For example `import google.cloud.library_v2` instead of `import google.cloud.library`.
+     */
+    unversionedPackageDisabled?: boolean | null;
+  }
   /**
    * A single field of a message type.
    */
@@ -954,6 +996,10 @@ export namespace serviceusage_v1 {
      * A list of API interfaces exported by this service. Only the `name` field of the google.protobuf.Api needs to be provided by the configuration author, as the remaining fields will be derived from the IDL during the normalization process. It is an error to specify an API interface here which cannot be resolved against the associated IDL files.
      */
     apis?: Schema$Api[];
+    /**
+     * Configuration aspects. This is a repeated field to allow multiple aspects to be configured. The kind field in each ConfigAspect specifies the type of aspect. The spec field contains the configuration for that aspect. The schema for the spec field is defined by the backend service owners.
+     */
+    aspects?: Schema$Aspect[];
     /**
      * Auth configuration.
      */
@@ -1206,6 +1252,108 @@ export namespace serviceusage_v1 {
    * Metadata for the `UpdateConsumerPolicy` method.
    */
   export interface Schema$GoogleApiServiceusageV2alphaUpdateConsumerPolicyMetadata {}
+  /**
+   * A message to group the analysis information.
+   */
+  export interface Schema$GoogleApiServiceusageV2betaAnalysis {
+    /**
+     * Output only. Analysis result of updating a policy.
+     */
+    analysisResult?: Schema$GoogleApiServiceusageV2betaAnalysisResult;
+    /**
+     * Output only. The type of analysis.
+     */
+    analysisType?: string | null;
+    /**
+     * Output only. The user friendly display name of the analysis type. E.g. service dependency analysis, service resource usage analysis, etc.
+     */
+    displayName?: string | null;
+    /**
+     * The names of the service that has analysis result of warnings or blockers. Example: `services/storage.googleapis.com`.
+     */
+    service?: string | null;
+  }
+  /**
+   * An analysis result including blockers and warnings.
+   */
+  export interface Schema$GoogleApiServiceusageV2betaAnalysisResult {
+    /**
+     * Blocking information that would prevent the policy changes at runtime.
+     */
+    blockers?: Schema$GoogleApiServiceusageV2betaImpact[];
+    /**
+     * Warning information indicating that the policy changes might be unsafe, but will not block the changes at runtime.
+     */
+    warnings?: Schema$GoogleApiServiceusageV2betaImpact[];
+  }
+  /**
+   * Metadata for the `AnalyzeConsumerPolicy` method.
+   */
+  export interface Schema$GoogleApiServiceusageV2betaAnalyzeConsumerPolicyMetadata {}
+  /**
+   * The response of analyzing a consumer policy update.
+   */
+  export interface Schema$GoogleApiServiceusageV2betaAnalyzeConsumerPolicyResponse {
+    /**
+     * The list of analyses returned from performing the intended policy update analysis. The analysis is grouped by service name and different analysis types. The empty analysis list means that the consumer policy can be updated without any warnings or blockers.
+     */
+    analysis?: Schema$GoogleApiServiceusageV2betaAnalysis[];
+  }
+  /**
+   * 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$GoogleApiServiceusageV2betaConsumerPolicy {
+    /**
+     * 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;
+    /**
+     * Output only. The time the policy was created. For singleton policies, this is the first touch of the policy.
+     */
+    createTime?: string | null;
+    /**
+     * Enable rules define usable services, groups, and categories. There can currently be at most one `EnableRule`. This restriction will be lifted in later releases.
+     */
+    enableRules?: Schema$GoogleApiServiceusageV2betaEnableRule[];
+    /**
+     * Output only. 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. Only the `default` policy is supported: `projects/12345/consumerPolicies/default`, `folders/12345/consumerPolicies/default`, `organizations/12345/consumerPolicies/default`.
+     */
+    name?: string | null;
+    /**
+     * Output only. The time the policy was last updated.
+     */
+    updateTime?: string | null;
+  }
+  /**
+   * The consumer policy rule that defines enabled services, groups, and categories.
+   */
+  export interface Schema$GoogleApiServiceusageV2betaEnableRule {
+    /**
+     * The names of the services that are enabled. Example: `services/storage.googleapis.com`.
+     */
+    services?: string[] | null;
+  }
+  /**
+   * A message to group impacts of updating a policy.
+   */
+  export interface Schema$GoogleApiServiceusageV2betaImpact {
+    /**
+     * Output only. User friendly impact detail in a free form message.
+     */
+    detail?: string | null;
+    /**
+     * Output only. The type of impact.
+     */
+    impactType?: string | null;
+  }
+  /**
+   * Metadata for the `UpdateConsumerPolicy` method.
+   */
+  export interface Schema$GoogleApiServiceusageV2betaUpdateConsumerPolicyMetadata {}
   /**
    * Settings for Go client libraries.
    */
@@ -1214,6 +1362,10 @@ export namespace serviceusage_v1 {
      * Some settings.
      */
     common?: Schema$CommonLanguageSettings;
+    /**
+     * Map of service names to renamed services. Keys are the package relative service names and values are the name to be used for the service client and call options. publishing: go_settings: renamed_services: Publisher: TopicAdmin
+     */
+    renamedServices?: {[key: string]: string} | null;
   }
   /**
    * 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.
@@ -1285,6 +1437,10 @@ export namespace serviceusage_v1 {
      * Output only. The type of impact.
      */
     impactType?: string | null;
+    /**
+     * The parent resource that the analysis is based on and the service name that the analysis is for. Example: `projects/100/services/compute.googleapis.com`, folders/101/services/compute.googleapis.com` and `organizations/102/services/compute.googleapis.com`. Usually, the parent resource here is same as the parent resource of the analyzed policy. However, for some analysis types, the parent can be different. For example, for resource existence analysis, if the parent resource of the analyzed policy is a folder or an organization, the parent resource here can still be the project that contains the resources.
+     */
+    parent?: string | null;
   }
   /**
    * Metadata message that provides information such as progress, partial failures, and similar information on each GetOperation call of LRO returned by ImportAdminOverrides.
@@ -1334,7 +1490,7 @@ export namespace serviceusage_v1 {
      */
     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
+     * 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: library_settings: java_settings: library_package: com.google.cloud.pubsub.v1
      */
     libraryPackage?: string | null;
     /**
@@ -1602,6 +1758,10 @@ export namespace serviceusage_v1 {
      * The sampling period of metric data points. For metrics which are written periodically, consecutive data points are stored at this time interval, excluding data loss due to errors. Metrics with a higher granularity have a smaller sampling period.
      */
     samplePeriod?: string | null;
+    /**
+     * The scope of the timeseries data of the metric.
+     */
+    timeSeriesResourceHierarchyLevel?: string[] | null;
   }
   /**
    * Bind API methods to metrics. Binding a method to a metric causes that metric's configured quota behaviors to apply to the method call.
@@ -1617,7 +1777,7 @@ export 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 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"; \} ... \}
+   * 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"; \} ... \}
    */
   export interface Schema$Mixin {
     /**
@@ -1754,7 +1914,7 @@ export namespace serviceusage_v1 {
    */
   export interface Schema$Page {
     /**
-     * The Markdown content of the page. You can use (== include {path\} ==) to include content from a Markdown file. The content can be used to produce the documentation page such as HTML format page.
+     * The Markdown content of the page. You can use ```(== include {path\} ==)``` to include content from a Markdown file. The content can be used to produce the documentation page such as HTML format page.
      */
     content?: string | null;
     /**
@@ -1832,6 +1992,10 @@ export namespace serviceusage_v1 {
      * Some settings.
      */
     common?: Schema$CommonLanguageSettings;
+    /**
+     * Experimental features to be included during client library generation.
+     */
+    experimentalFeatures?: Schema$ExperimentalFeatures;
   }
   /**
    * 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
@@ -1883,7 +2047,7 @@ export namespace serviceusage_v1 {
      */
     name?: string | null;
     /**
-     * Specify the unit of the quota limit. It uses the same syntax as Metric.unit. The supported unit kinds are determined by the quota backend system. Here are some examples: * "1/min/{project\}" for quota per minute per project. Note: the order of unit components is insignificant. The "1" at the beginning is required to follow the metric unit syntax.
+     * Specify the unit of the quota limit. It uses the same syntax as MetricDescriptor.unit. The supported unit kinds are determined by the quota backend system. Here are some examples: * "1/min/{project\}" for quota per minute per project. Note: the order of unit components is insignificant. The "1" at the beginning is required to follow the metric unit syntax.
      */
     unit?: string | null;
     /**
@@ -1946,6 +2110,19 @@ export namespace serviceusage_v1 {
      */
     common?: Schema$CommonLanguageSettings;
   }
+  /**
+   * This message is used to configure the generation of a subset of the RPCs in a service for client libraries.
+   */
+  export interface Schema$SelectiveGapicGeneration {
+    /**
+     * Setting this to true indicates to the client generators that methods that would be excluded from the generation should instead be generated in a way that indicates these methods should not be consumed by end users. How this is expressed is up to individual language implementations to decide. Some examples may be: added annotations, obfuscated identifiers, or other language idiomatic patterns.
+     */
+    generateOmittedAsInternal?: boolean | null;
+    /**
+     * An allowlist of the fully qualified names of RPCs that should be included on public client surfaces.
+     */
+    methods?: string[] | null;
+  }
   /**
    * Service identity for a service. This is the identity that service producer should use to access consumer resources.
    */
@@ -2092,11 +2269,11 @@ export namespace serviceusage_v1 {
     rules?: Schema$UsageRule[];
   }
   /**
-   * Usage configuration rules for the service. NOTE: Under development. Use this rule to configure unregistered calls for the service. Unregistered calls are calls that do not contain consumer project identity. (Example: calls that do not contain an API key). By default, API methods do not allow unregistered calls, and each method call must be identified by a consumer project identity. Use this rule to allow/disallow unregistered calls. Example of an API that wants to allow unregistered calls for entire service. usage: rules: - selector: "*" allow_unregistered_calls: true Example of a method that wants to allow unregistered calls. usage: rules: - selector: "google.example.library.v1.LibraryService.CreateBook" allow_unregistered_calls: true
+   * Usage configuration rules for the service.
    */
   export interface Schema$UsageRule {
     /**
-     * If true, the selected method allows unregistered calls, e.g. calls that don't identify any user or application.
+     *  Use this rule to configure unregistered calls for the service. Unregistered calls are calls that do not contain consumer project identity. (Example: calls that do not contain an API key). WARNING: By default, API methods do not allow unregistered calls, and each method call must be identified by a consumer project identity.
      */
     allowUnregisteredCalls?: boolean | null;
     /**
@@ -2116,7 +2293,7 @@ export namespace serviceusage_v1 {
     }
 
     /**
-     * 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`.
+     * 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`.
      *
      * @param params - Parameters for request
      * @param options - Optionally override request options, such as `url`, `method`, and `encoding`.