,
}
/// Exactly one of these three fields must be set.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Options {
/// The linear bucket.
#[prost(message, tag = "1")]
LinearBuckets(Linear),
/// The exponential buckets.
#[prost(message, tag = "2")]
ExponentialBuckets(Exponential),
/// The explicit buckets.
#[prost(message, tag = "3")]
ExplicitBuckets(Explicit),
}
}
/// Exemplars are example points that may be used to annotate aggregated
/// distribution values. They are metadata that gives information about a
/// particular value added to a Distribution bucket, such as a trace ID that
/// was active when a value was added. They may contain further information,
/// such as a example values and timestamps, origin, etc.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Exemplar {
/// Value of the exemplar point. This value determines to which bucket the
/// exemplar belongs.
#[prost(double, tag = "1")]
pub value: f64,
/// The observation (sampling) time of the above value.
#[prost(message, optional, tag = "2")]
pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
/// Contextual information about the example value. Examples are:
///
/// Trace: type.googleapis.com/google.monitoring.v3.SpanContext
///
/// Literal string: type.googleapis.com/google.protobuf.StringValue
///
/// Labels dropped during aggregation:
/// type.googleapis.com/google.monitoring.v3.DroppedLabels
///
/// There may be only a single attachment of any given message type in a
/// single exemplar, and this is enforced by the system.
#[prost(message, repeated, tag = "3")]
pub attachments: ::prost::alloc::vec::Vec<::prost_types::Any>,
}
}
/// `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.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Documentation {
/// A short summary of what the service does. Can only be provided by
/// plain text.
#[prost(string, tag = "1")]
pub summary: ::prost::alloc::string::String,
/// The top level pages for the documentation set.
#[prost(message, repeated, tag = "5")]
pub pages: ::prost::alloc::vec::Vec,
/// A list of documentation rules that apply to individual API elements.
///
/// **NOTE:** All service configuration rules follow "last one wins" order.
#[prost(message, repeated, tag = "3")]
pub rules: ::prost::alloc::vec::Vec,
/// The URL to the root of documentation.
#[prost(string, tag = "4")]
pub documentation_root_url: ::prost::alloc::string::String,
/// 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.
#[prost(string, tag = "6")]
pub service_root_url: ::prost::alloc::string::String,
/// Declares a single overview page. For example:
/// documentation:
/// summary: ...
/// overview: (== include overview.md ==)
///
/// This is a shortcut for the following declaration (using pages style):
/// documentation:
/// summary: ...
/// pages:
/// - name: Overview
/// content: (== include overview.md ==)
///
/// Note: you cannot specify both `overview` field and `pages` field.
#[prost(string, tag = "2")]
pub overview: ::prost::alloc::string::String,
}
/// A documentation rule provides information about individual API elements.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DocumentationRule {
/// The selector is a comma-separated list of patterns. 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.
#[prost(string, tag = "1")]
pub selector: ::prost::alloc::string::String,
/// Description of the selected API(s).
#[prost(string, tag = "2")]
pub description: ::prost::alloc::string::String,
/// Deprecation description of the selected element(s). It can be provided if
/// an element is marked as `deprecated`.
#[prost(string, tag = "3")]
pub deprecation_description: ::prost::alloc::string::String,
}
/// Represents a documentation page. A page can contain subpages to represent
/// nested documentation set structure.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Page {
/// The name of the page. It will be used as an identity of the page to
/// generate URI of the page, text of the link to this page in navigation,
/// etc. The full page name (start from the root page name to this page
/// concatenated with `.`) can be used as reference to the page in your
/// documentation. For example:
/// pages:
/// - name: Tutorial
/// content: (== include tutorial.md ==)
/// subpages:
/// - name: Java
/// content: (== include tutorial_java.md ==)
///
/// You can reference `Java` page using Markdown reference link syntax:
/// `\[Java][Tutorial.Java\]`.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// The Markdown content of the page. You can use (== include {path}
/// ==) to include content from a Markdown file.
#[prost(string, tag = "2")]
pub content: ::prost::alloc::string::String,
/// Subpages of this page. The order of subpages specified here will be
/// honored in the generated docset.
#[prost(message, repeated, tag = "3")]
pub subpages: ::prost::alloc::vec::Vec,
}
/// `Endpoint` describes a network endpoint 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 service configuration:
///
/// name: library-example.googleapis.com
/// endpoints:
/// # Below entry makes 'google.example.library.v1.Library'
/// # API be served from endpoint address library-example.googleapis.com.
/// # It also allows HTTP OPTIONS calls to be passed to the backend, for
/// # it to decide whether the subsequent cross-origin request is
/// # allowed to proceed.
/// - name: library-example.googleapis.com
/// allow_cors: true
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Endpoint {
/// The canonical name of this endpoint.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Unimplemented. Dot not use.
///
/// DEPRECATED: This field is no longer supported. Instead of using aliases,
/// please specify multiple \[google.api.Endpoint][google.api.Endpoint\] for each of the intended
/// aliases.
///
/// Additional names that this endpoint will be hosted on.
#[deprecated]
#[prost(string, repeated, tag = "2")]
pub aliases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// The specification of an Internet routable address of API frontend that will
/// handle requests to this [API
/// Endpoint](). It should be
/// either a valid IPv4 address or a fully-qualified domain name. For example,
/// "8.8.8.8" or "myservice.appspot.com".
#[prost(string, tag = "101")]
pub target: ::prost::alloc::string::String,
/// Allowing
/// \[CORS\](), 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.
#[prost(bool, tag = "5")]
pub allow_cors: bool,
}
/// Defines the supported values for `google.rpc.ErrorInfo.reason` for the
/// `googleapis.com` error domain. This error domain is reserved for [Service
/// Infrastructure]().
/// For each error info of this domain, the metadata key "service" refers to the
/// logical identifier of an API service, such as "pubsub.googleapis.com". The
/// "consumer" refers to the entity that consumes an API Service. It typically is
/// a Google project that owns the client application or the server resource,
/// such as "projects/123". Other metadata keys are specific to each error
/// reason. For more information, see the definition of the specific error
/// reason.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ErrorReason {
/// Do not use this default value.
Unspecified = 0,
/// The request is calling a disabled service for a consumer.
///
/// Example of an ErrorInfo when the consumer "projects/123" contacting
/// "pubsub.googleapis.com" service which is disabled:
///
/// { "reason": "SERVICE_DISABLED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "pubsub.googleapis.com"
/// }
/// }
///
/// This response indicates the "pubsub.googleapis.com" has been disabled in
/// "projects/123".
ServiceDisabled = 1,
/// The request whose associated billing account is disabled.
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to contact
/// "pubsub.googleapis.com" service because the associated billing account is
/// disabled:
///
/// { "reason": "BILLING_DISABLED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "pubsub.googleapis.com"
/// }
/// }
///
/// This response indicates the billing account associated has been disabled.
BillingDisabled = 2,
/// The request is denied because the provided [API
/// key]() is invalid. It
/// may be in a bad format, cannot be found, or has been expired).
///
/// Example of an ErrorInfo when the request is contacting
/// "storage.googleapis.com" service with an invalid API key:
///
/// { "reason": "API_KEY_INVALID",
/// "domain": "googleapis.com",
/// "metadata": {
/// "service": "storage.googleapis.com",
/// }
/// }
ApiKeyInvalid = 3,
/// The request is denied because it violates [API key API
/// restrictions]().
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to call the
/// "storage.googleapis.com" service because this service is restricted in the
/// API key:
///
/// { "reason": "API_KEY_SERVICE_BLOCKED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com"
/// }
/// }
ApiKeyServiceBlocked = 4,
/// The request is denied because it violates [API key HTTP
/// restrictions]().
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to call
/// "storage.googleapis.com" service because the http referrer of the request
/// violates API key HTTP restrictions:
///
/// { "reason": "API_KEY_HTTP_REFERRER_BLOCKED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com",
/// }
/// }
ApiKeyHttpReferrerBlocked = 7,
/// The request is denied because it violates [API key IP address
/// restrictions]().
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to call
/// "storage.googleapis.com" service because the caller IP of the request
/// violates API key IP address restrictions:
///
/// { "reason": "API_KEY_IP_ADDRESS_BLOCKED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com",
/// }
/// }
ApiKeyIpAddressBlocked = 8,
/// The request is denied because it violates [API key Android application
/// restrictions]().
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to call
/// "storage.googleapis.com" service because the request from the Android apps
/// violates the API key Android application restrictions:
///
/// { "reason": "API_KEY_ANDROID_APP_BLOCKED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com"
/// }
/// }
ApiKeyAndroidAppBlocked = 9,
/// The request is denied because it violates [API key iOS application
/// restrictions]().
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to call
/// "storage.googleapis.com" service because the request from the iOS apps
/// violates the API key iOS application restrictions:
///
/// { "reason": "API_KEY_IOS_APP_BLOCKED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com"
/// }
/// }
ApiKeyIosAppBlocked = 13,
/// The request is denied because there is not enough rate quota for the
/// consumer.
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to contact
/// "pubsub.googleapis.com" service because consumer's rate quota usage has
/// reached the maximum value set for the quota limit
/// "ReadsPerMinutePerProject" on the quota metric
/// "pubsub.googleapis.com/read_requests":
///
/// { "reason": "RATE_LIMIT_EXCEEDED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "pubsub.googleapis.com",
/// "quota_metric": "pubsub.googleapis.com/read_requests",
/// "quota_limit": "ReadsPerMinutePerProject"
/// }
/// }
///
/// Example of an ErrorInfo when the consumer "projects/123" checks quota on
/// the service "dataflow.googleapis.com" and hits the organization quota
/// limit "DefaultRequestsPerMinutePerOrganization" on the metric
/// "dataflow.googleapis.com/default_requests".
///
/// { "reason": "RATE_LIMIT_EXCEEDED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "dataflow.googleapis.com",
/// "quota_metric": "dataflow.googleapis.com/default_requests",
/// "quota_limit": "DefaultRequestsPerMinutePerOrganization"
/// }
/// }
RateLimitExceeded = 5,
/// The request is denied because there is not enough resource quota for the
/// consumer.
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to contact
/// "compute.googleapis.com" service because consumer's resource quota usage
/// has reached the maximum value set for the quota limit "VMsPerProject"
/// on the quota metric "compute.googleapis.com/vms":
///
/// { "reason": "RESOURCE_QUOTA_EXCEEDED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "compute.googleapis.com",
/// "quota_metric": "compute.googleapis.com/vms",
/// "quota_limit": "VMsPerProject"
/// }
/// }
///
/// Example of an ErrorInfo when the consumer "projects/123" checks resource
/// quota on the service "dataflow.googleapis.com" and hits the organization
/// quota limit "jobs-per-organization" on the metric
/// "dataflow.googleapis.com/job_count".
///
/// { "reason": "RESOURCE_QUOTA_EXCEEDED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "dataflow.googleapis.com",
/// "quota_metric": "dataflow.googleapis.com/job_count",
/// "quota_limit": "jobs-per-organization"
/// }
/// }
ResourceQuotaExceeded = 6,
/// The request whose associated billing account address is in a tax restricted
/// location, violates the local tax restrictions when creating resources in
/// the restricted region.
///
/// Example of an ErrorInfo when creating the Cloud Storage Bucket in the
/// container "projects/123" under a tax restricted region
/// "locations/asia-northeast3":
///
/// { "reason": "LOCATION_TAX_POLICY_VIOLATED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com",
/// "location": "locations/asia-northeast3"
/// }
/// }
///
/// This response indicates creating the Cloud Storage Bucket in
/// "locations/asia-northeast3" violates the location tax restriction.
LocationTaxPolicyViolated = 10,
/// The request is denied because the caller does not have required permission
/// on the user project "projects/123" or the user project is invalid. For more
/// information, check the [userProject System
/// Parameters]().
///
/// Example of an ErrorInfo when the caller is calling Cloud Storage service
/// with insufficient permissions on the user project:
///
/// { "reason": "USER_PROJECT_DENIED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com"
/// }
/// }
UserProjectDenied = 11,
/// The request is denied because the consumer "projects/123" is suspended due
/// to Terms of Service(Tos) violations. Check [Project suspension
/// guidelines]()
/// for more information.
///
/// Example of an ErrorInfo when calling Cloud Storage service with the
/// suspended consumer "projects/123":
///
/// { "reason": "CONSUMER_SUSPENDED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com"
/// }
/// }
ConsumerSuspended = 12,
/// The request is denied because the associated consumer is invalid. It may be
/// in a bad format, cannot be found, or have been deleted.
///
/// Example of an ErrorInfo when calling Cloud Storage service with the
/// invalid consumer "projects/123":
///
/// { "reason": "CONSUMER_INVALID",
/// "domain": "googleapis.com",
/// "metadata": {
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com"
/// }
/// }
ConsumerInvalid = 14,
/// The request is denied because it violates [VPC Service
/// Controls]().
/// The 'uid' field is a random generated identifier that customer can use it
/// to search the audit log for a request rejected by VPC Service Controls. For
/// more information, please refer [VPC Service Controls
/// Troubleshooting]()
///
/// Example of an ErrorInfo when the consumer "projects/123" fails to call
/// Cloud Storage service because the request is prohibited by the VPC Service
/// Controls.
///
/// { "reason": "SECURITY_POLICY_VIOLATED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "uid": "123456789abcde",
/// "consumer": "projects/123",
/// "service": "storage.googleapis.com"
/// }
/// }
SecurityPolicyViolated = 15,
/// The request is denied because the provided access token has expired.
///
/// Example of an ErrorInfo when the request is calling Cloud Storage service
/// with an expired access token:
///
/// { "reason": "ACCESS_TOKEN_EXPIRED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "service": "storage.googleapis.com",
/// "method": "google.storage.v1.Storage.GetObject"
/// }
/// }
AccessTokenExpired = 16,
/// The request is denied because the provided access token doesn't have at
/// least one of the acceptable scopes required for the API. Please check
/// [OAuth 2.0 Scopes for Google
/// APIs]() for
/// the list of the OAuth 2.0 scopes that you might need to request to access
/// the API.
///
/// Example of an ErrorInfo when the request is calling Cloud Storage service
/// with an access token that is missing required scopes:
///
/// { "reason": "ACCESS_TOKEN_SCOPE_INSUFFICIENT",
/// "domain": "googleapis.com",
/// "metadata": {
/// "service": "storage.googleapis.com",
/// "method": "google.storage.v1.Storage.GetObject"
/// }
/// }
AccessTokenScopeInsufficient = 17,
/// The request is denied because the account associated with the provided
/// access token is in an invalid state, such as disabled or deleted.
/// For more information, see
///
/// Warning: For privacy reasons, the server may not be able to disclose the
/// email address for some accounts. The client MUST NOT depend on the
/// availability of the `email` attribute.
///
/// Example of an ErrorInfo when the request is to the Cloud Storage API with
/// an access token that is associated with a disabled or deleted [service
/// account]():
///
/// { "reason": "ACCOUNT_STATE_INVALID",
/// "domain": "googleapis.com",
/// "metadata": {
/// "service": "storage.googleapis.com",
/// "method": "google.storage.v1.Storage.GetObject",
/// "email": "user@123.iam.gserviceaccount.com"
/// }
/// }
AccountStateInvalid = 18,
/// The request is denied because the type of the provided access token is not
/// supported by the API being called.
///
/// Example of an ErrorInfo when the request is to the Cloud Storage API with
/// an unsupported token type.
///
/// { "reason": "ACCESS_TOKEN_TYPE_UNSUPPORTED",
/// "domain": "googleapis.com",
/// "metadata": {
/// "service": "storage.googleapis.com",
/// "method": "google.storage.v1.Storage.GetObject"
/// }
/// }
AccessTokenTypeUnsupported = 19,
}
/// Message that represents an arbitrary HTTP body. It should only be used for
/// payload formats that can't be represented as JSON, such as raw binary or
/// an HTML page.
///
///
/// This message can be used both in streaming and non-streaming API methods in
/// the request as well as the response.
///
/// It can be used as a top-level request field, which is convenient if one
/// wants to extract parameters from either the URL or HTTP template into the
/// request fields and also want access to the raw HTTP body.
///
/// Example:
///
/// message GetResourceRequest {
/// // A unique request id.
/// string request_id = 1;
///
/// // The raw HTTP body is bound to this field.
/// google.api.HttpBody http_body = 2;
///
/// }
///
/// service ResourceService {
/// rpc GetResource(GetResourceRequest)
/// returns (google.api.HttpBody);
/// rpc UpdateResource(google.api.HttpBody)
/// returns (google.protobuf.Empty);
///
/// }
///
/// Example with streaming methods:
///
/// service CaldavService {
/// rpc GetCalendar(stream google.api.HttpBody)
/// returns (stream google.api.HttpBody);
/// rpc UpdateCalendar(stream google.api.HttpBody)
/// returns (stream google.api.HttpBody);
///
/// }
///
/// Use of this type only changes how the request and response bodies are
/// handled, all other features will continue to work unchanged.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpBody {
/// The HTTP Content-Type header value specifying the content type of the body.
#[prost(string, tag = "1")]
pub content_type: ::prost::alloc::string::String,
/// The HTTP request/response body as raw binary.
#[prost(bytes = "vec", tag = "2")]
pub data: ::prost::alloc::vec::Vec,
/// Application specific response metadata. Must be set in the first response
/// for streaming APIs.
#[prost(message, repeated, tag = "3")]
pub extensions: ::prost::alloc::vec::Vec<::prost_types::Any>,
}
/// A description of a log type. Example in YAML format:
///
/// - name: library.googleapis.com/activity_history
/// description: The history of borrowing and returning library items.
/// display_name: Activity
/// labels:
/// - key: /customer_id
/// description: Identifier of a library customer
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LogDescriptor {
/// The name of the log. It must be less than 512 characters long and can
/// include the following characters: upper- and lower-case alphanumeric
/// characters \[A-Za-z0-9\], and punctuation characters including
/// slash, underscore, hyphen, period \[/_-.\].
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// The set of labels that are available to describe a specific log entry.
/// Runtime requests that contain labels not specified here are
/// considered invalid.
#[prost(message, repeated, tag = "2")]
pub labels: ::prost::alloc::vec::Vec,
/// A human-readable description of this log. This information appears in
/// the documentation and can contain details.
#[prost(string, tag = "3")]
pub description: ::prost::alloc::string::String,
/// The human-readable name for this log. This information appears on
/// the user interface and should be concise.
#[prost(string, tag = "4")]
pub display_name: ::prost::alloc::string::String,
}
/// Logging configuration of the service.
///
/// The following example shows how to configure logs to be sent to the
/// producer and consumer projects. In the example, the `activity_history`
/// log is sent to both the producer and consumer projects, whereas the
/// `purchase_history` log is only sent to the producer project.
///
/// monitored_resources:
/// - type: library.googleapis.com/branch
/// labels:
/// - key: /city
/// description: The city where the library branch is located in.
/// - key: /name
/// description: The name of the branch.
/// logs:
/// - name: activity_history
/// labels:
/// - key: /customer_id
/// - name: purchase_history
/// logging:
/// producer_destinations:
/// - monitored_resource: library.googleapis.com/branch
/// logs:
/// - activity_history
/// - purchase_history
/// consumer_destinations:
/// - monitored_resource: library.googleapis.com/branch
/// logs:
/// - activity_history
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Logging {
/// Logging configurations for sending logs to the producer project.
/// There can be multiple producer destinations, each one must have a
/// different monitored resource type. A log can be used in at most
/// one producer destination.
#[prost(message, repeated, tag = "1")]
pub producer_destinations: ::prost::alloc::vec::Vec,
/// Logging configurations for sending logs to the consumer project.
/// There can be multiple consumer destinations, each one must have a
/// different monitored resource type. A log can be used in at most
/// one consumer destination.
#[prost(message, repeated, tag = "2")]
pub consumer_destinations: ::prost::alloc::vec::Vec,
}
/// Nested message and enum types in `Logging`.
pub mod logging {
/// Configuration of a specific logging destination (the producer project
/// or the consumer project).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoggingDestination {
/// The monitored resource type. The type must be defined in the
/// \[Service.monitored_resources][google.api.Service.monitored_resources\] section.
#[prost(string, tag = "3")]
pub monitored_resource: ::prost::alloc::string::String,
/// Names of the logs to be sent to this destination. Each name must
/// be defined in the \[Service.logs][google.api.Service.logs\] section. If the log name is
/// not a domain scoped name, it will be automatically prefixed with
/// the service name followed by "/".
#[prost(string, repeated, tag = "1")]
pub logs: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
}
/// An object that describes the schema of a \[MonitoredResource][google.api.MonitoredResource\] object using a
/// type name and a set of labels. For example, the monitored resource
/// descriptor for Google Compute Engine VM instances has a type of
/// `"gce_instance"` and specifies the use of the labels `"instance_id"` and
/// `"zone"` to identify particular VM instances.
///
/// Different APIs can support different monitored resource types. APIs generally
/// provide a `list` method that returns the monitored resource descriptors used
/// by the API.
///
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MonitoredResourceDescriptor {
/// Optional. The resource name of the monitored resource descriptor:
/// `"projects/{project_id}/monitoredResourceDescriptors/{type}"` where
/// {type} is the value of the `type` field in this object and
/// {project_id} is a project ID that provides API-specific context for
/// accessing the type. APIs that do not use project information can use the
/// resource name format `"monitoredResourceDescriptors/{type}"`.
#[prost(string, tag = "5")]
pub name: ::prost::alloc::string::String,
/// Required. The monitored resource type. For example, the type
/// `"cloudsql_database"` represents databases in Google Cloud SQL.
#[prost(string, tag = "1")]
pub r#type: ::prost::alloc::string::String,
/// Optional. A concise name for the monitored resource type that might be
/// displayed in user interfaces. It should be a Title Cased Noun Phrase,
/// without any article or other determiners. For example,
/// `"Google Cloud SQL Database"`.
#[prost(string, tag = "2")]
pub display_name: ::prost::alloc::string::String,
/// Optional. A detailed description of the monitored resource type that might
/// be used in documentation.
#[prost(string, tag = "3")]
pub description: ::prost::alloc::string::String,
/// Required. A set of labels used to describe instances of this monitored
/// resource type. For example, an individual Google Cloud SQL database is
/// identified by values for the labels `"database_id"` and `"zone"`.
#[prost(message, repeated, tag = "4")]
pub labels: ::prost::alloc::vec::Vec,
/// Optional. The launch stage of the monitored resource definition.
#[prost(enumeration = "LaunchStage", tag = "7")]
pub launch_stage: i32,
}
/// An object representing a resource that can be used for monitoring, logging,
/// billing, or other purposes. Examples include virtual machine instances,
/// databases, and storage devices such as disks. The `type` field identifies a
/// \[MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor\] object that describes the resource's
/// schema. Information in the `labels` field identifies the actual resource and
/// its attributes according to the schema. For example, a particular Compute
/// Engine VM instance could be represented by the following object, because the
/// \[MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor\] for `"gce_instance"` has labels
/// `"instance_id"` and `"zone"`:
///
/// { "type": "gce_instance",
/// "labels": { "instance_id": "12345678901234",
/// "zone": "us-central1-a" }}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MonitoredResource {
/// Required. The monitored resource type. This field must match
/// the `type` field of a \[MonitoredResourceDescriptor][google.api.MonitoredResourceDescriptor\] object. For
/// example, the type of a Compute Engine VM instance is `gce_instance`.
#[prost(string, tag = "1")]
pub r#type: ::prost::alloc::string::String,
/// Required. Values for all of the labels listed in the associated monitored
/// resource descriptor. For example, Compute Engine VM instances use the
/// labels `"project_id"`, `"instance_id"`, and `"zone"`.
#[prost(map = "string, string", tag = "2")]
pub labels:
::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
/// Auxiliary metadata for a \[MonitoredResource][google.api.MonitoredResource\] object.
/// \[MonitoredResource][google.api.MonitoredResource\] objects contain the minimum set of information to
/// uniquely identify a monitored resource instance. There is some other useful
/// auxiliary metadata. Monitoring and Logging use an ingestion
/// pipeline to extract metadata for cloud resources of all types, and store
/// the metadata in this message.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MonitoredResourceMetadata {
/// Output only. Values for predefined system metadata labels.
/// System labels are a kind of metadata extracted by Google, including
/// "machine_image", "vpc", "subnet_id",
/// "security_group", "name", etc.
/// System label values can be only strings, Boolean values, or a list of
/// strings. For example:
///
/// { "name": "my-test-instance",
/// "security_group": ["a", "b", "c"],
/// "spot_instance": false }
#[prost(message, optional, tag = "1")]
pub system_labels: ::core::option::Option<::prost_types::Struct>,
/// Output only. A map of user-defined metadata labels.
#[prost(map = "string, string", tag = "2")]
pub user_labels:
::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
}
/// Monitoring configuration of the service.
///
/// The example below shows how to configure monitored resources and metrics
/// for monitoring. In the example, a monitored resource and two metrics are
/// defined. The `library.googleapis.com/book/returned_count` metric is sent
/// to both producer and consumer projects, whereas the
/// `library.googleapis.com/book/num_overdue` metric is only sent to the
/// consumer project.
///
/// monitored_resources:
/// - type: library.googleapis.com/Branch
/// display_name: "Library Branch"
/// description: "A branch of a library."
/// launch_stage: GA
/// labels:
/// - key: resource_container
/// description: "The Cloud container (ie. project id) for the Branch."
/// - key: location
/// description: "The location of the library branch."
/// - key: branch_id
/// description: "The id of the branch."
/// metrics:
/// - name: library.googleapis.com/book/returned_count
/// display_name: "Books Returned"
/// description: "The count of books that have been returned."
/// launch_stage: GA
/// metric_kind: DELTA
/// value_type: INT64
/// unit: "1"
/// labels:
/// - key: customer_id
/// description: "The id of the customer."
/// - name: library.googleapis.com/book/num_overdue
/// display_name: "Books Overdue"
/// description: "The current number of overdue books."
/// launch_stage: GA
/// metric_kind: GAUGE
/// value_type: INT64
/// unit: "1"
/// labels:
/// - key: customer_id
/// description: "The id of the customer."
/// monitoring:
/// producer_destinations:
/// - monitored_resource: library.googleapis.com/Branch
/// metrics:
/// - library.googleapis.com/book/returned_count
/// consumer_destinations:
/// - monitored_resource: library.googleapis.com/Branch
/// metrics:
/// - library.googleapis.com/book/returned_count
/// - library.googleapis.com/book/num_overdue
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Monitoring {
/// Monitoring configurations for sending metrics to the producer project.
/// There can be multiple producer destinations. A monitored resource type may
/// appear in multiple monitoring destinations if different aggregations are
/// needed for different sets of metrics associated with that monitored
/// resource type. A monitored resource and metric pair may only be used once
/// in the Monitoring configuration.
#[prost(message, repeated, tag = "1")]
pub producer_destinations: ::prost::alloc::vec::Vec,
/// Monitoring configurations for sending metrics to the consumer project.
/// There can be multiple consumer destinations. A monitored resource type may
/// appear in multiple monitoring destinations if different aggregations are
/// needed for different sets of metrics associated with that monitored
/// resource type. A monitored resource and metric pair may only be used once
/// in the Monitoring configuration.
#[prost(message, repeated, tag = "2")]
pub consumer_destinations: ::prost::alloc::vec::Vec,
}
/// Nested message and enum types in `Monitoring`.
pub mod monitoring {
/// Configuration of a specific monitoring destination (the producer project
/// or the consumer project).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MonitoringDestination {
/// The monitored resource type. The type must be defined in
/// \[Service.monitored_resources][google.api.Service.monitored_resources\] section.
#[prost(string, tag = "1")]
pub monitored_resource: ::prost::alloc::string::String,
/// Types of the metrics to report to this monitoring destination.
/// Each type must be defined in \[Service.metrics][google.api.Service.metrics\] section.
#[prost(string, repeated, tag = "2")]
pub metrics: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
}
/// 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
///
///
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Quota {
/// List of `QuotaLimit` definitions for the service.
#[prost(message, repeated, tag = "3")]
pub limits: ::prost::alloc::vec::Vec,
/// List of `MetricRule` definitions, each one mapping a selected method to one
/// or more metrics.
#[prost(message, repeated, tag = "4")]
pub metric_rules: ::prost::alloc::vec::Vec,
}
/// Bind API methods to metrics. Binding a method to a metric causes that
/// metric's configured quota behaviors to apply to the method call.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MetricRule {
/// Selects the methods to which this rule applies.
///
/// Refer to \[selector][google.api.DocumentationRule.selector\] for syntax details.
#[prost(string, tag = "1")]
pub selector: ::prost::alloc::string::String,
/// Metrics to update when the selected methods are called, and the associated
/// cost applied to each metric.
///
/// The key of the map is the metric name, and the values are the amount
/// increased for the metric against which the quota limits are defined.
/// The value must not be negative.
#[prost(map = "string, int64", tag = "2")]
pub metric_costs: ::std::collections::HashMap<::prost::alloc::string::String, i64>,
}
/// `QuotaLimit` defines a specific limit that applies over a specified duration
/// for a limit type. There can be at most one limit for a duration and limit
/// type combination defined within a `QuotaGroup`.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QuotaLimit {
/// Name of the quota limit.
///
/// The name must be provided, and it must be unique within the service. The
/// name can only include alphanumeric characters as well as '-'.
///
/// The maximum length of the limit name is 64 characters.
#[prost(string, tag = "6")]
pub name: ::prost::alloc::string::String,
/// Optional. User-visible, extended description for this quota limit.
/// Should be used only when more context is needed to understand this limit
/// than provided by the limit's display name (see: `display_name`).
#[prost(string, tag = "2")]
pub description: ::prost::alloc::string::String,
/// Default number of tokens that can be consumed during the specified
/// duration. This is the number of tokens assigned when a client
/// application developer activates the service for his/her project.
///
/// Specifying a value of 0 will block all requests. This can be used if you
/// are provisioning quota to selected consumers and blocking others.
/// Similarly, a value of -1 will indicate an unlimited quota. No other
/// negative values are allowed.
///
/// Used by group-based quotas only.
#[prost(int64, tag = "3")]
pub default_limit: i64,
/// Maximum number of tokens that can be consumed during the specified
/// duration. Client application developers can override the default limit up
/// to this maximum. If specified, this value cannot be set to a value less
/// than the default limit. If not specified, it is set to the default limit.
///
/// To allow clients to apply overrides with no upper bound, set this to -1,
/// indicating unlimited maximum quota.
///
/// Used by group-based quotas only.
#[prost(int64, tag = "4")]
pub max_limit: i64,
/// Free tier value displayed in the Developers Console for this limit.
/// The free tier is the number of tokens that will be subtracted from the
/// billed amount when billing is enabled.
/// This field can only be set on a limit with duration "1d", in a billable
/// group; it is invalid on any other limit. If this field is not set, it
/// defaults to 0, indicating that there is no free tier for this service.
///
/// Used by group-based quotas only.
#[prost(int64, tag = "7")]
pub free_tier: i64,
/// Duration of this limit in textual notation. Must be "100s" or "1d".
///
/// Used by group-based quotas only.
#[prost(string, tag = "5")]
pub duration: ::prost::alloc::string::String,
/// The name of the metric this quota limit applies to. The quota limits with
/// the same metric will be checked together during runtime. The metric must be
/// defined within the service config.
#[prost(string, tag = "8")]
pub metric: ::prost::alloc::string::String,
/// 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.
#[prost(string, tag = "9")]
pub unit: ::prost::alloc::string::String,
/// Tiered limit values. You must specify this as a key:value pair, with an
/// integer value that is the maximum number of requests allowed for the
/// specified unit. Currently only STANDARD is supported.
#[prost(map = "string, int64", tag = "10")]
pub values: ::std::collections::HashMap<::prost::alloc::string::String, i64>,
/// User-visible display name for this limit.
/// Optional. If not set, the UI will provide a default display name based on
/// the quota configuration. This field can be used to override the default
/// display name generated from the configuration.
#[prost(string, tag = "12")]
pub display_name: ::prost::alloc::string::String,
}
/// Specifies the routing information that should be sent along with the request
/// in the form of routing header.
/// **NOTE:** All service configuration rules follow the "last one wins" order.
///
/// The examples below will apply to an RPC which has the following request type:
///
/// Message Definition:
///
/// message Request {
/// // The name of the Table
/// // Values can be of the following formats:
/// // - `projects//tables/`
/// // - `projects//instances//tables/`
/// // - `region//zones//tables/`
/// string table_name = 1;
///
/// // This value specifies routing for replication.
/// // It can be in the following formats:
/// // - `profiles/`
/// // - a legacy `profile_id` that can be any string
/// string app_profile_id = 2;
/// }
///
/// Example message:
///
/// {
/// table_name: projects/proj_foo/instances/instance_bar/table/table_baz,
/// app_profile_id: profiles/prof_qux
/// }
///
/// The routing header consists of one or multiple key-value pairs. Every key
/// and value must be percent-encoded, and joined together in the format of
/// `key1=value1&key2=value2`.
/// In the examples below I am skipping the percent-encoding for readablity.
///
/// Example 1
///
/// Extracting a field from the request to put into the routing header
/// unchanged, with the key equal to the field name.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // Take the `app_profile_id`.
/// routing_parameters {
/// field: "app_profile_id"
/// }
/// };
///
/// result:
///
/// x-goog-request-params: app_profile_id=profiles/prof_qux
///
/// Example 2
///
/// Extracting a field from the request to put into the routing header
/// unchanged, with the key different from the field name.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // Take the `app_profile_id`, but name it `routing_id` in the header.
/// routing_parameters {
/// field: "app_profile_id"
/// path_template: "{routing_id=**}"
/// }
/// };
///
/// result:
///
/// x-goog-request-params: routing_id=profiles/prof_qux
///
/// Example 3
///
/// Extracting a field from the request to put into the routing
/// header, while matching a path template syntax on the field's value.
///
/// NB: it is more useful to send nothing than to send garbage for the purpose
/// of dynamic routing, since garbage pollutes cache. Thus the matching.
///
/// Sub-example 3a
///
/// The field matches the template.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // Take the `table_name`, if it's well-formed (with project-based
/// // syntax).
/// routing_parameters {
/// field: "table_name"
/// path_template: "{table_name=projects/*/instances/*/**}"
/// }
/// };
///
/// result:
///
/// x-goog-request-params:
/// table_name=projects/proj_foo/instances/instance_bar/table/table_baz
///
/// Sub-example 3b
///
/// The field does not match the template.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // Take the `table_name`, if it's well-formed (with region-based
/// // syntax).
/// routing_parameters {
/// field: "table_name"
/// path_template: "{table_name=regions/*/zones/*/**}"
/// }
/// };
///
/// result:
///
///
///
/// Sub-example 3c
///
/// Multiple alternative conflictingly named path templates are
/// specified. The one that matches is used to construct the header.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // Take the `table_name`, if it's well-formed, whether
/// // using the region- or projects-based syntax.
///
/// routing_parameters {
/// field: "table_name"
/// path_template: "{table_name=regions/*/zones/*/**}"
/// }
/// routing_parameters {
/// field: "table_name"
/// path_template: "{table_name=projects/*/instances/*/**}"
/// }
/// };
///
/// result:
///
/// x-goog-request-params:
/// table_name=projects/proj_foo/instances/instance_bar/table/table_baz
///
/// Example 4
///
/// Extracting a single routing header key-value pair by matching a
/// template syntax on (a part of) a single request field.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // Take just the project id from the `table_name` field.
/// routing_parameters {
/// field: "table_name"
/// path_template: "{routing_id=projects/*}/**"
/// }
/// };
///
/// result:
///
/// x-goog-request-params: routing_id=projects/proj_foo
///
/// Example 5
///
/// Extracting a single routing header key-value pair by matching
/// several conflictingly named path templates on (parts of) a single request
/// field. The last template to match "wins" the conflict.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // If the `table_name` does not have instances information,
/// // take just the project id for routing.
/// // Otherwise take project + instance.
///
/// routing_parameters {
/// field: "table_name"
/// path_template: "{routing_id=projects/*}/**"
/// }
/// routing_parameters {
/// field: "table_name"
/// path_template: "{routing_id=projects/*/instances/*}/**"
/// }
/// };
///
/// result:
///
/// x-goog-request-params:
/// routing_id=projects/proj_foo/instances/instance_bar
///
/// Example 6
///
/// Extracting multiple routing header key-value pairs by matching
/// several non-conflicting path templates on (parts of) a single request field.
///
/// Sub-example 6a
///
/// Make the templates strict, so that if the `table_name` does not
/// have an instance information, nothing is sent.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // The routing code needs two keys instead of one composite
/// // but works only for the tables with the "project-instance" name
/// // syntax.
///
/// routing_parameters {
/// field: "table_name"
/// path_template: "{project_id=projects/*}/instances/*/**"
/// }
/// routing_parameters {
/// field: "table_name"
/// path_template: "projects/*/{instance_id=instances/*}/**"
/// }
/// };
///
/// result:
///
/// x-goog-request-params:
/// project_id=projects/proj_foo&instance_id=instances/instance_bar
///
/// Sub-example 6b
///
/// Make the templates loose, so that if the `table_name` does not
/// have an instance information, just the project id part is sent.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // The routing code wants two keys instead of one composite
/// // but will work with just the `project_id` for tables without
/// // an instance in the `table_name`.
///
/// routing_parameters {
/// field: "table_name"
/// path_template: "{project_id=projects/*}/**"
/// }
/// routing_parameters {
/// field: "table_name"
/// path_template: "projects/*/{instance_id=instances/*}/**"
/// }
/// };
///
/// result (is the same as 6a for our example message because it has the instance
/// information):
///
/// x-goog-request-params:
/// project_id=projects/proj_foo&instance_id=instances/instance_bar
///
/// Example 7
///
/// Extracting multiple routing header key-value pairs by matching
/// several path templates on multiple request fields.
///
/// NB: note that here there is no way to specify sending nothing if one of the
/// fields does not match its template. E.g. if the `table_name` is in the wrong
/// format, the `project_id` will not be sent, but the `routing_id` will be.
/// The backend routing code has to be aware of that and be prepared to not
/// receive a full complement of keys if it expects multiple.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // The routing needs both `project_id` and `routing_id`
/// // (from the `app_profile_id` field) for routing.
///
/// routing_parameters {
/// field: "table_name"
/// path_template: "{project_id=projects/*}/**"
/// }
/// routing_parameters {
/// field: "app_profile_id"
/// path_template: "{routing_id=**}"
/// }
/// };
///
/// result:
///
/// x-goog-request-params:
/// project_id=projects/proj_foo&routing_id=profiles/prof_qux
///
/// Example 8
///
/// Extracting a single routing header key-value pair by matching
/// several conflictingly named path templates on several request fields. The
/// last template to match "wins" the conflict.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // The `routing_id` can be a project id or a region id depending on
/// // the table name format, but only if the `app_profile_id` is not set.
/// // If `app_profile_id` is set it should be used instead.
///
/// routing_parameters {
/// field: "table_name"
/// path_template: "{routing_id=projects/*}/**"
/// }
/// routing_parameters {
/// field: "table_name"
/// path_template: "{routing_id=regions/*}/**"
/// }
/// routing_parameters {
/// field: "app_profile_id"
/// path_template: "{routing_id=**}"
/// }
/// };
///
/// result:
///
/// x-goog-request-params: routing_id=profiles/prof_qux
///
/// Example 9
///
/// Bringing it all together.
///
/// annotation:
///
/// option (google.api.routing) = {
/// // For routing both `table_location` and a `routing_id` are needed.
/// //
/// // table_location can be either an instance id or a region+zone id.
/// //
/// // For `routing_id`, take the value of `app_profile_id`
/// // - If it's in the format `profiles/`, send
/// // just the `` part.
/// // - If it's any other literal, send it as is.
/// // If the `app_profile_id` is empty, and the `table_name` starts with
/// // the project_id, send that instead.
///
/// routing_parameters {
/// field: "table_name"
/// path_template: "projects/*/{table_location=instances/*}/tables/*"
/// }
/// routing_parameters {
/// field: "table_name"
/// path_template: "{table_location=regions/*/zones/*}/tables/*"
/// }
/// routing_parameters {
/// field: "table_name"
/// path_template: "{routing_id=projects/*}/**"
/// }
/// routing_parameters {
/// field: "app_profile_id"
/// path_template: "{routing_id=**}"
/// }
/// routing_parameters {
/// field: "app_profile_id"
/// path_template: "profiles/{routing_id=*}"
/// }
/// };
///
/// result:
///
/// x-goog-request-params:
/// table_location=instances/instance_bar&routing_id=prof_qux
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoutingRule {
/// A collection of Routing Parameter specifications.
/// **NOTE:** If multiple Routing Parameters describe the same key
/// (via the `path_template` field or via the `field` field when
/// `path_template` is not provided), "last one wins" rule
/// determines which Parameter gets used.
/// See the examples for more details.
#[prost(message, repeated, tag = "2")]
pub routing_parameters: ::prost::alloc::vec::Vec,
}
/// A projection from an input message to the GRPC or REST header.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RoutingParameter {
/// A request field to extract the header key-value pair from.
#[prost(string, tag = "1")]
pub field: ::prost::alloc::string::String,
/// A pattern matching the key-value field. Optional.
/// If not specified, the whole field specified in the `field` field will be
/// taken as value, and its name used as key. If specified, it MUST contain
/// exactly one named segment (along with any number of unnamed segments) The
/// pattern will be matched over the field specified in the `field` field, then
/// if the match is successful:
/// - the name of the single named segment will be used as a header name,
/// - the match value of the segment will be used as a header value;
/// if the match is NOT successful, nothing will be sent.
///
/// Example:
///
/// -- This is a field in the request message
/// | that the header value will be extracted from.
/// |
/// | -- This is the key name in the
/// | | routing header.
/// V |
/// field: "table_name" v
/// path_template: "projects/*/{table_location=instances/*}/tables/*"
/// ^ ^
/// | |
/// In the {} brackets is the pattern that -- |
/// specifies what to extract from the |
/// field as a value to be sent. |
/// |
/// The string in the field must match the whole pattern --
/// before brackets, inside brackets, after brackets.
///
/// When looking at this specific example, we can see that:
/// - A key-value pair with the key `table_location`
/// and the value matching `instances/*` should be added
/// to the x-goog-request-params routing header.
/// - The value is extracted from the request message's `table_name` field
/// if it matches the full pattern specified:
/// `projects/*/instances/*/tables/*`.
///
/// **NB:** If the `path_template` field is not provided, the key name is
/// equal to the field name, and the whole field should be sent as a value.
/// This makes the pattern for the field and the value functionally equivalent
/// to `**`, and the configuration
///
/// {
/// field: "table_name"
/// }
///
/// is a functionally equivalent shorthand to:
///
/// {
/// field: "table_name"
/// path_template: "{table_name=**}"
/// }
///
/// See Example 1 for more details.
#[prost(string, tag = "2")]
pub path_template: ::prost::alloc::string::String,
}
/// Source information used to create a Service Config
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SourceInfo {
/// All files used during config generation.
#[prost(message, repeated, tag = "1")]
pub source_files: ::prost::alloc::vec::Vec<::prost_types::Any>,
}
/// ### System parameter configuration
///
/// A system parameter is a special kind of parameter defined by the API
/// system, not by an individual API. It is typically mapped to an HTTP header
/// and/or a URL query parameter. This configuration specifies which methods
/// change the names of the system parameters.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SystemParameters {
/// Define system parameters.
///
/// The parameters defined here will override the default parameters
/// implemented by the system. If this field is missing from the service
/// config, default system parameters will be used. Default system parameters
/// and names is implementation-dependent.
///
/// Example: define api key for all methods
///
/// system_parameters
/// rules:
/// - selector: "*"
/// parameters:
/// - name: api_key
/// url_query_parameter: api_key
///
///
/// Example: define 2 api key names for a specific method.
///
/// system_parameters
/// rules:
/// - selector: "/ListShelves"
/// parameters:
/// - name: api_key
/// http_header: Api-Key1
/// - name: api_key
/// http_header: Api-Key2
///
/// **NOTE:** All service configuration rules follow "last one wins" order.
#[prost(message, repeated, tag = "1")]
pub rules: ::prost::alloc::vec::Vec,
}
/// Define a system parameter rule mapping system parameter definitions to
/// methods.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SystemParameterRule {
/// Selects the methods to which this rule applies. Use '*' to indicate all
/// methods in all APIs.
///
/// Refer to \[selector][google.api.DocumentationRule.selector\] for syntax details.
#[prost(string, tag = "1")]
pub selector: ::prost::alloc::string::String,
/// Define parameters. Multiple names may be defined for a parameter.
/// For a given method call, only one of them should be used. If multiple
/// names are used the behavior is implementation-dependent.
/// If none of the specified names are present the behavior is
/// parameter-dependent.
#[prost(message, repeated, tag = "2")]
pub parameters: ::prost::alloc::vec::Vec,
}
/// Define a parameter's name and location. The parameter may be passed as either
/// an HTTP header or a URL query parameter, and if both are passed the behavior
/// is implementation-dependent.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SystemParameter {
/// Define the name of the parameter, such as "api_key" . It is case sensitive.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// Define the HTTP header name to use for the parameter. It is case
/// insensitive.
#[prost(string, tag = "2")]
pub http_header: ::prost::alloc::string::String,
/// Define the URL query parameter name to use for the parameter. It is case
/// sensitive.
#[prost(string, tag = "3")]
pub url_query_parameter: ::prost::alloc::string::String,
}
/// Configuration controlling usage of a service.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Usage {
/// Requirements that must be satisfied before a consumer project can use the
/// service. Each requirement is of the form /;
/// for example 'serviceusage.googleapis.com/billing-enabled'.
///
/// For Google APIs, a Terms of Service requirement must be included here.
/// Google Cloud APIs must include "serviceusage.googleapis.com/tos/cloud".
/// Other Google APIs should include
/// "serviceusage.googleapis.com/tos/universal". Additional ToS can be
/// included based on the business needs.
#[prost(string, repeated, tag = "1")]
pub requirements: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
/// A list of usage rules that apply to individual API methods.
///
/// **NOTE:** All service configuration rules follow "last one wins" order.
#[prost(message, repeated, tag = "6")]
pub rules: ::prost::alloc::vec::Vec,
/// The full resource name of a channel used for sending notifications to the
/// service producer.
///
/// Google Service Management currently only supports
/// [Google Cloud Pub/Sub]() as a notification
/// channel. To use Google Cloud Pub/Sub as the channel, this must be the name
/// of a Cloud Pub/Sub topic that uses the Cloud Pub/Sub topic name format
/// documented in
#[prost(string, tag = "7")]
pub producer_notification_channel: ::prost::alloc::string::String,
}
/// 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
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UsageRule {
/// Selects the methods to which this rule applies. Use '*' to indicate all
/// methods in all APIs.
///
/// Refer to \[selector][google.api.DocumentationRule.selector\] for syntax details.
#[prost(string, tag = "1")]
pub selector: ::prost::alloc::string::String,
/// If true, the selected method allows unregistered calls, e.g. calls
/// that don't identify any user or application.
#[prost(bool, tag = "2")]
pub allow_unregistered_calls: bool,
/// If true, the selected method should skip service control and the control
/// plane features, such as quota and billing, will not be available.
/// This flag is used by Google Cloud Endpoints to bypass checks for internal
/// methods, such as service health check methods.
#[prost(bool, tag = "3")]
pub skip_service_control: bool,
}
/// `Service` is the root object of Google service configuration schema. It
/// describes basic information about a service, such as the name and the
/// title, and delegates other aspects to sub-sections. Each sub-section is
/// either a proto message or a repeated proto message that configures a
/// specific aspect, such as auth. See each proto message definition for details.
///
/// Example:
///
/// type: google.api.Service
/// name: calendar.googleapis.com
/// title: Google Calendar API
/// apis:
/// - name: google.calendar.v3.Calendar
/// authentication:
/// providers:
/// - id: google_calendar_auth
/// jwks_uri:
/// issuer:
/// rules:
/// - selector: "*"
/// requirements:
/// provider_id: google_calendar_auth
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Service {
/// The service name, which is a DNS-like logical identifier for the
/// service, such as `calendar.googleapis.com`. The service name
/// typically goes through DNS verification to make sure the owner
/// of the service also owns the DNS name.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
/// The product title for this service.
#[prost(string, tag = "2")]
pub title: ::prost::alloc::string::String,
/// The Google project that owns this service.
#[prost(string, tag = "22")]
pub producer_project_id: ::prost::alloc::string::String,
/// A unique ID for a specific instance of this message, typically assigned
/// by the client for tracking purpose. Must be no longer than 63 characters
/// and only lower case letters, digits, '.', '_' and '-' are allowed. If
/// empty, the server may choose to generate one instead.
#[prost(string, tag = "33")]
pub id: ::prost::alloc::string::String,
/// A list of API interfaces exported by this service. Only the `name` field
/// of the \[google.protobuf.Api][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.
#[prost(message, repeated, tag = "3")]
pub apis: ::prost::alloc::vec::Vec<::prost_types::Api>,
/// A list of all proto message types included in this API service.
/// Types referenced directly or indirectly by the `apis` are
/// automatically included. Messages which are not referenced but
/// shall be included, such as types used by the `google.protobuf.Any` type,
/// should be listed here by name. Example:
///
/// types:
/// - name: google.protobuf.Int32
#[prost(message, repeated, tag = "4")]
pub types: ::prost::alloc::vec::Vec<::prost_types::Type>,
/// A list of all enum types included in this API service. Enums
/// referenced directly or indirectly by the `apis` are automatically
/// included. Enums which are not referenced but shall be included
/// should be listed here by name. Example:
///
/// enums:
/// - name: google.someapi.v1.SomeEnum
#[prost(message, repeated, tag = "5")]
pub enums: ::prost::alloc::vec::Vec<::prost_types::Enum>,
/// Additional API documentation.
#[prost(message, optional, tag = "6")]
pub documentation: ::core::option::Option,
/// API backend configuration.
#[prost(message, optional, tag = "8")]
pub backend: ::core::option::Option,
/// HTTP configuration.
#[prost(message, optional, tag = "9")]
pub http: ::core::option::Option,
/// Quota configuration.
#[prost(message, optional, tag = "10")]
pub quota: ::core::option::Option,
/// Auth configuration.
#[prost(message, optional, tag = "11")]
pub authentication: ::core::option::Option,
/// Context configuration.
#[prost(message, optional, tag = "12")]
pub context: ::core::option::Option,
/// Configuration controlling usage of this service.
#[prost(message, optional, tag = "15")]
pub usage: ::core::option::Option,
/// Configuration for network endpoints. If this is empty, then an endpoint
/// with the same name as the service is automatically generated to service all
/// defined APIs.
#[prost(message, repeated, tag = "18")]
pub endpoints: ::prost::alloc::vec::Vec,
/// Configuration for the service control plane.
#[prost(message, optional, tag = "21")]
pub control: ::core::option::Option,
/// Defines the logs used by this service.
#[prost(message, repeated, tag = "23")]
pub logs: ::prost::alloc::vec::Vec,
/// Defines the metrics used by this service.
#[prost(message, repeated, tag = "24")]
pub metrics: ::prost::alloc::vec::Vec,
/// Defines the monitored resources used by this service. This is required
/// by the \[Service.monitoring][google.api.Service.monitoring\] and \[Service.logging][google.api.Service.logging\] configurations.
#[prost(message, repeated, tag = "25")]
pub monitored_resources: ::prost::alloc::vec::Vec,
/// Billing configuration.
#[prost(message, optional, tag = "26")]
pub billing: ::core::option::Option,
/// Logging configuration.
#[prost(message, optional, tag = "27")]
pub logging: ::core::option::Option,
/// Monitoring configuration.
#[prost(message, optional, tag = "28")]
pub monitoring: ::core::option::Option,
/// System parameter configuration.
#[prost(message, optional, tag = "29")]
pub system_parameters: ::core::option::Option,
/// Output only. The source information for this configuration if available.
#[prost(message, optional, tag = "37")]
pub source_info: ::core::option::Option,
/// Obsolete. Do not use.
///
/// This field has no semantic meaning. The service config compiler always
/// sets this field to `3`.
#[deprecated]
#[prost(message, optional, tag = "20")]
pub config_version: ::core::option::Option,
}
/// `Visibility` defines restrictions for the visibility of service
/// elements. Restrictions are specified using visibility labels
/// (e.g., PREVIEW) that are elsewhere linked to users and projects.
///
/// Users and projects can have access to more than one visibility label. The
/// effective visibility for multiple labels is the union of each label's
/// elements, plus any unrestricted elements.
///
/// If an element and its parents have no restrictions, visibility is
/// unconditionally granted.
///
/// Example:
///
/// visibility:
/// rules:
/// - selector: google.calendar.Calendar.EnhancedSearch
/// restriction: PREVIEW
/// - selector: google.calendar.Calendar.Delegate
/// restriction: INTERNAL
///
/// Here, all methods are publicly visible except for the restricted methods
/// EnhancedSearch and Delegate.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Visibility {
/// A list of visibility rules that apply to individual API elements.
///
/// **NOTE:** All service configuration rules follow "last one wins" order.
#[prost(message, repeated, tag = "1")]
pub rules: ::prost::alloc::vec::Vec,
}
/// A visibility rule provides visibility configuration for an individual API
/// element.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VisibilityRule {
/// Selects methods, messages, fields, enums, etc. to which this rule applies.
///
/// Refer to \[selector][google.api.DocumentationRule.selector\] for syntax details.
#[prost(string, tag = "1")]
pub selector: ::prost::alloc::string::String,
/// A comma-separated list of visibility labels that apply to the `selector`.
/// Any of the listed labels can be used to grant the visibility.
///
/// If a rule has multiple labels, removing one of the labels but not all of
/// them can break clients.
///
/// Example:
///
/// visibility:
/// rules:
/// - selector: google.calendar.Calendar.EnhancedSearch
/// restriction: INTERNAL, PREVIEW
///
/// Removing INTERNAL from this restriction will break clients that rely on
/// this method and only had access to it through INTERNAL.
#[prost(string, tag = "2")]
pub restriction: ::prost::alloc::string::String,
}