From 1fb68fa4db2ad27579f5731658eb1f518471a911 Mon Sep 17 00:00:00 2001 From: Garry Filakhtov Date: Mon, 13 Oct 2025 10:35:16 +0000 Subject: [PATCH 1/3] Initial implementation of Google API protobufs --- Cargo.toml | 1 + prost-googleapis/Cargo.toml | 13 + prost-googleapis/src/google/api/mod.rs | 3344 +++++++++++++++++ prost-googleapis/src/google/cloud/mod.rs | 53 + prost-googleapis/src/google/iam/admin/mod.rs | 1 + .../src/google/iam/admin/v1/mod.rs | 971 +++++ prost-googleapis/src/google/iam/mod.rs | 2 + .../src/google/iam/v1/logging/mod.rs | 10 + prost-googleapis/src/google/iam/v1/mod.rs | 348 ++ prost-googleapis/src/google/logging/mod.rs | 1 + .../src/google/logging/type/mod.rs | 140 + .../src/google/longrunning/mod.rs | 141 + prost-googleapis/src/google/mod.rs | 7 + .../src/google/rpc/context/mod.rs | 286 ++ prost-googleapis/src/google/rpc/mod.rs | 471 +++ prost-googleapis/src/google/type/mod.rs | 725 ++++ prost-googleapis/src/lib.rs | 1 + 17 files changed, 6515 insertions(+) create mode 100644 prost-googleapis/Cargo.toml create mode 100644 prost-googleapis/src/google/api/mod.rs create mode 100644 prost-googleapis/src/google/cloud/mod.rs create mode 100644 prost-googleapis/src/google/iam/admin/mod.rs create mode 100644 prost-googleapis/src/google/iam/admin/v1/mod.rs create mode 100644 prost-googleapis/src/google/iam/mod.rs create mode 100644 prost-googleapis/src/google/iam/v1/logging/mod.rs create mode 100644 prost-googleapis/src/google/iam/v1/mod.rs create mode 100644 prost-googleapis/src/google/logging/mod.rs create mode 100644 prost-googleapis/src/google/logging/type/mod.rs create mode 100644 prost-googleapis/src/google/longrunning/mod.rs create mode 100644 prost-googleapis/src/google/mod.rs create mode 100644 prost-googleapis/src/google/rpc/context/mod.rs create mode 100644 prost-googleapis/src/google/rpc/mod.rs create mode 100644 prost-googleapis/src/google/type/mod.rs create mode 100644 prost-googleapis/src/lib.rs diff --git a/Cargo.toml b/Cargo.toml index ef4169cb7..4924d7ab2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,6 +5,7 @@ members = [ "prost", "prost-build", "prost-derive", + "prost-googleapis", "prost-types", "protobuf", "tests", diff --git a/prost-googleapis/Cargo.toml b/prost-googleapis/Cargo.toml new file mode 100644 index 000000000..28fa24531 --- /dev/null +++ b/prost-googleapis/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "prost-googleapis" +description = "Prost definitions of Google API Protocol Buffers." +version.workspace = true +authors.workspace = true +license.workspace = true +repository.workspace = true +rust-version.workspace = true +edition.workspace = true + +[dependencies] +prost = { version = "0.14.1", path = "../prost", default-features = false } +prost-types = { version = "0.14.1", path = "../prost-types" } diff --git a/prost-googleapis/src/google/api/mod.rs b/prost-googleapis/src/google/api/mod.rs new file mode 100644 index 000000000..5fcd2a3cf --- /dev/null +++ b/prost-googleapis/src/google/api/mod.rs @@ -0,0 +1,3344 @@ +// This file is @generated by prost-build. +/// Defines the HTTP configuration for an API service. It contains a list of +/// \[HttpRule\]\[google.api.HttpRule\], each specifying the mapping of an RPC method +/// to one or more HTTP REST API methods. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Http { + /// A list of HTTP configuration rules that apply to individual API methods. + /// + /// **NOTE:** All service configuration rules follow "last one wins" order. + #[prost(message, repeated, tag = "1")] + pub rules: ::prost::alloc::vec::Vec, + /// When set to true, URL path parmeters will be fully URI-decoded except in + /// cases of single segment matches in reserved expansion, where "%2F" will be + /// left encoded. + /// + /// The default behavior is to not decode RFC 6570 reserved characters in multi + /// segment matches. + #[prost(bool, tag = "2")] + pub fully_decode_reserved_expansion: bool, +} +/// `HttpRule` defines the mapping of an RPC method to one or more HTTP +/// REST API methods. The mapping specifies how different portions of the RPC +/// request message are mapped to URL path, URL query parameters, and +/// HTTP request body. The mapping is typically specified as an +/// `google.api.http` annotation on the RPC method, +/// see "google/api/annotations.proto" for details. +/// +/// The mapping consists of a field specifying the path template and +/// method kind. The path template can refer to fields in the request +/// message, as in the example below which describes a REST GET +/// operation on a resource collection of messages: +/// +/// ```text +/// service Messaging { +/// rpc GetMessage(GetMessageRequest) returns (Message) { +/// option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}"; +/// } +/// } +/// message GetMessageRequest { +/// message SubMessage { +/// string subfield = 1; +/// } +/// string message_id = 1; // mapped to the URL +/// SubMessage sub = 2; // `sub.subfield` is url-mapped +/// } +/// message Message { +/// string text = 1; // content of the resource +/// } +/// ``` +/// +/// The same http annotation can alternatively be expressed inside the +/// `GRPC API Configuration` YAML file. +/// +/// ```text +/// http: +/// rules: +/// - selector: .Messaging.GetMessage +/// get: /v1/messages/{message_id}/{sub.subfield} +/// ``` +/// +/// This definition enables an automatic, bidrectional mapping of HTTP +/// JSON to RPC. Example: +/// +/// |HTTP|RPC| +/// |----|---| +/// |`GET /v1/messages/123456/foo`|`GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))`| +/// +/// In general, not only fields but also field paths can be referenced +/// from a path pattern. Fields mapped to the path pattern cannot be +/// repeated and must have a primitive (non-message) type. +/// +/// Any fields in the request message which are not bound by the path +/// pattern automatically become (optional) HTTP query +/// parameters. Assume the following definition of the request message: +/// +/// ```text +/// service Messaging { +/// rpc GetMessage(GetMessageRequest) returns (Message) { +/// option (google.api.http).get = "/v1/messages/{message_id}"; +/// } +/// } +/// message GetMessageRequest { +/// message SubMessage { +/// string subfield = 1; +/// } +/// string message_id = 1; // mapped to the URL +/// int64 revision = 2; // becomes a parameter +/// SubMessage sub = 3; // `sub.subfield` becomes a parameter +/// } +/// ``` +/// +/// This enables a HTTP JSON to RPC mapping as below: +/// +/// |HTTP|RPC| +/// |----|---| +/// |`GET /v1/messages/123456?revision=2&sub.subfield=foo`|`GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: "foo"))`| +/// +/// Note that fields which are mapped to HTTP parameters must have a +/// primitive type or a repeated primitive type. Message types are not +/// allowed. In the case of a repeated type, the parameter can be +/// repeated in the URL, as in `...?param=A¶m=B`. +/// +/// For HTTP method kinds which allow a request body, the `body` field +/// specifies the mapping. Consider a REST update method on the +/// message resource collection: +/// +/// ```text +/// service Messaging { +/// rpc UpdateMessage(UpdateMessageRequest) returns (Message) { +/// option (google.api.http) = { +/// put: "/v1/messages/{message_id}" +/// body: "message" +/// }; +/// } +/// } +/// message UpdateMessageRequest { +/// string message_id = 1; // mapped to the URL +/// Message message = 2; // mapped to the body +/// } +/// ``` +/// +/// The following HTTP JSON to RPC mapping is enabled, where the +/// representation of the JSON in the request body is determined by +/// protos JSON encoding: +/// +/// |HTTP|RPC| +/// |----|---| +/// |`PUT /v1/messages/123456 { "text": "Hi!" }`|`UpdateMessage(message_id: "123456" message { text: "Hi!" })`| +/// +/// The special name `*` can be used in the body mapping to define that +/// every field not bound by the path template should be mapped to the +/// request body. This enables the following alternative definition of +/// the update method: +/// +/// ```text +/// service Messaging { +/// rpc UpdateMessage(Message) returns (Message) { +/// option (google.api.http) = { +/// put: "/v1/messages/{message_id}" +/// body: "*" +/// }; +/// } +/// } +/// message Message { +/// string message_id = 1; +/// string text = 2; +/// } +/// ``` +/// +/// The following HTTP JSON to RPC mapping is enabled: +/// +/// |HTTP|RPC| +/// |----|---| +/// |`PUT /v1/messages/123456 { "text": "Hi!" }`|`UpdateMessage(message_id: "123456" text: "Hi!")`| +/// +/// Note that when using `*` in the body mapping, it is not possible to +/// have HTTP parameters, as all fields not bound by the path end in +/// the body. This makes this option more rarely used in practice of +/// defining REST APIs. The common usage of `*` is in custom methods +/// which don't use the URL at all for transferring data. +/// +/// It is possible to define multiple HTTP methods for one RPC by using +/// the `additional_bindings` option. Example: +/// +/// ```text +/// service Messaging { +/// rpc GetMessage(GetMessageRequest) returns (Message) { +/// option (google.api.http) = { +/// get: "/v1/messages/{message_id}" +/// additional_bindings { +/// get: "/v1/users/{user_id}/messages/{message_id}" +/// } +/// }; +/// } +/// } +/// message GetMessageRequest { +/// string message_id = 1; +/// string user_id = 2; +/// } +/// ``` +/// +/// This enables the following two alternative HTTP JSON to RPC +/// mappings: +/// +/// |HTTP|RPC| +/// |----|---| +/// |`GET /v1/messages/123456`|`GetMessage(message_id: "123456")`| +/// |`GET /v1/users/me/messages/123456`|`GetMessage(user_id: "me" message_id: "123456")`| +/// +/// # Rules for HTTP mapping +/// +/// The rules for mapping HTTP path, query parameters, and body fields +/// to the request message are as follows: +/// +/// 1. The `body` field specifies either `*` or a field path, or is +/// omitted. If omitted, it indicates there is no HTTP request body. +/// 1. Leaf fields (recursive expansion of nested messages in the +/// request) can be classified into three types: +/// (a) Matched in the URL template. +/// (b) Covered by body (if body is `*`, everything except (a) fields; +/// else everything under the body field) +/// (c) All other fields. +/// 1. URL query parameters found in the HTTP request are mapped to (c) fields. +/// 1. Any body sent with an HTTP request can contain only (b) fields. +/// +/// The syntax of the path template is as follows: +/// +/// ```text +/// Template = "/" Segments \[ Verb \] ; +/// Segments = Segment { "/" Segment } ; +/// Segment = "*" | "**" | LITERAL | Variable ; +/// Variable = "{" FieldPath \[ "=" Segments \] "}" ; +/// FieldPath = IDENT { "." IDENT } ; +/// Verb = ":" LITERAL ; +/// ``` +/// +/// The syntax `*` matches a single path segment. The syntax `**` matches zero +/// or more path segments, which must be the last part of the path except the +/// `Verb`. The syntax `LITERAL` matches literal text in the path. +/// +/// The syntax `Variable` matches part of the URL path as specified by its +/// template. A variable template must not contain other variables. If a variable +/// matches a single path segment, its template may be omitted, e.g. `{var}` +/// is equivalent to `{var=*}`. +/// +/// If a variable contains exactly one path segment, such as `"{var}"` or +/// `"{var=*}"`, when such a variable is expanded into a URL path, all characters +/// except `\[-_.~0-9a-zA-Z\]` are percent-encoded. Such variables show up in the +/// Discovery Document as `{var}`. +/// +/// If a variable contains one or more path segments, such as `"{var=foo/*}"` +/// or `"{var=**}"`, when such a variable is expanded into a URL path, all +/// characters except `\[-_.~/0-9a-zA-Z\]` are percent-encoded. Such variables +/// show up in the Discovery Document as `{+var}`. +/// +/// NOTE: While the single segment variable matches the semantics of +/// [RFC 6570]() Section 3.2.2 +/// Simple String Expansion, the multi segment variable **does not** match +/// RFC 6570 Reserved Expansion. The reason is that the Reserved Expansion +/// does not expand special characters like `?` and `#`, which would lead +/// to invalid URLs. +/// +/// NOTE: the field paths in variables and in the `body` must not refer to +/// repeated fields or map fields. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct HttpRule { + /// Selects 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, + /// The name of the request field whose value is mapped to the HTTP body, or + /// `*` for mapping all fields not captured by the path pattern to the HTTP + /// body. NOTE: the referred field must not be a repeated field and must be + /// present at the top-level of request message type. + #[prost(string, tag = "7")] + pub body: ::prost::alloc::string::String, + /// Optional. The name of the response field whose value is mapped to the HTTP + /// body of response. Other response fields are ignored. When + /// not set, the response message will be used as HTTP body of response. + #[prost(string, tag = "12")] + pub response_body: ::prost::alloc::string::String, + /// Additional HTTP bindings for the selector. Nested bindings must + /// not contain an `additional_bindings` field themselves (that is, + /// the nesting may only be one level deep). + #[prost(message, repeated, tag = "11")] + pub additional_bindings: ::prost::alloc::vec::Vec, + /// Determines the URL pattern is matched by this rules. This pattern can be + /// used with any of the {get|put|post|delete|patch} methods. A custom method + /// can be defined using the 'custom' field. + #[prost(oneof = "http_rule::Pattern", tags = "2, 3, 4, 5, 6, 8")] + pub pattern: ::core::option::Option, +} +/// Nested message and enum types in `HttpRule`. +pub mod http_rule { + /// Determines the URL pattern is matched by this rules. This pattern can be + /// used with any of the {get|put|post|delete|patch} methods. A custom method + /// can be defined using the 'custom' field. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum Pattern { + /// Used for listing and getting information about resources. + #[prost(string, tag = "2")] + Get(::prost::alloc::string::String), + /// Used for updating a resource. + #[prost(string, tag = "3")] + Put(::prost::alloc::string::String), + /// Used for creating a resource. + #[prost(string, tag = "4")] + Post(::prost::alloc::string::String), + /// Used for deleting a resource. + #[prost(string, tag = "5")] + Delete(::prost::alloc::string::String), + /// Used for updating a resource. + #[prost(string, tag = "6")] + Patch(::prost::alloc::string::String), + /// The custom pattern is used for specifying an HTTP method that is not + /// included in the `pattern` field, such as HEAD, or "\*" to leave the + /// HTTP method unspecified for this rule. The wild-card rule is useful + /// for services that provide content to Web (HTML) clients. + #[prost(message, tag = "8")] + Custom(super::CustomHttpPattern), + } +} +/// A custom pattern is used for defining custom HTTP verb. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CustomHttpPattern { + /// The name of this custom HTTP verb. + #[prost(string, tag = "1")] + pub kind: ::prost::alloc::string::String, + /// The path matched by this custom verb. + #[prost(string, tag = "2")] + pub path: ::prost::alloc::string::String, +} +/// An indicator of the behavior of a given field (for example, that a field +/// is required in requests, or given as output but ignored as input). +/// This **does not** change the behavior in protocol buffers itself; it only +/// denotes the behavior and may affect how API tooling handles the field. +/// +/// Note: This enum **may** receive new values in the future. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum FieldBehavior { + /// Conventional default for enums. Do not use this. + Unspecified = 0, + /// Specifically denotes a field as optional. + /// While all fields in protocol buffers are optional, this may be specified + /// for emphasis if appropriate. + Optional = 1, + /// Denotes a field as required. + /// This indicates that the field **must** be provided as part of the request, + /// and failure to do so will cause an error (usually `INVALID_ARGUMENT`). + Required = 2, + /// Denotes a field as output only. + /// This indicates that the field is provided in responses, but including the + /// field in a request does nothing (the server *must* ignore it and + /// *must not* throw an error as a result of the field's presence). + OutputOnly = 3, + /// Denotes a field as input only. + /// This indicates that the field is provided in requests, and the + /// corresponding field is not included in output. + InputOnly = 4, + /// Denotes a field as immutable. + /// This indicates that the field may be set once in a request to create a + /// resource, but may not be changed thereafter. + Immutable = 5, + /// Denotes that a (repeated) field is an unordered list. + /// This indicates that the service may provide the elements of the list + /// in any arbitrary order, rather than the order the user originally + /// provided. Additionally, the list's order may or may not be stable. + UnorderedList = 6, +} +impl FieldBehavior { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "FIELD_BEHAVIOR_UNSPECIFIED", + Self::Optional => "OPTIONAL", + Self::Required => "REQUIRED", + Self::OutputOnly => "OUTPUT_ONLY", + Self::InputOnly => "INPUT_ONLY", + Self::Immutable => "IMMUTABLE", + Self::UnorderedList => "UNORDERED_LIST", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "FIELD_BEHAVIOR_UNSPECIFIED" => Some(Self::Unspecified), + "OPTIONAL" => Some(Self::Optional), + "REQUIRED" => Some(Self::Required), + "OUTPUT_ONLY" => Some(Self::OutputOnly), + "INPUT_ONLY" => Some(Self::InputOnly), + "IMMUTABLE" => Some(Self::Immutable), + "UNORDERED_LIST" => Some(Self::UnorderedList), + _ => None, + } + } +} +/// A simple descriptor of a resource type. +/// +/// ResourceDescriptor annotates a resource message (either by means of a +/// protobuf annotation or use in the service config), and associates the +/// resource's schema, the resource type, and the pattern of the resource name. +/// +/// Example: +/// +/// ```text +/// message Topic { +/// // Indicates this message defines a resource schema. +/// // Declares the resource type in the format of {service}/{kind}. +/// // For Kubernetes resources, the format is {api group}/{kind}. +/// option (google.api.resource) = { +/// type: "pubsub.googleapis.com/Topic" +/// name_descriptor: { +/// pattern: "projects/{project}/topics/{topic}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// parent_name_extractor: "projects/{project}" +/// } +/// }; +/// } +/// ``` +/// +/// The ResourceDescriptor Yaml config will look like: +/// +/// ```text +/// resources: +/// - type: "pubsub.googleapis.com/Topic" +/// name_descriptor: +/// - pattern: "projects/{project}/topics/{topic}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// parent_name_extractor: "projects/{project}" +/// ``` +/// +/// Sometimes, resources have multiple patterns, typically because they can +/// live under multiple parents. +/// +/// Example: +/// +/// ```text +/// message LogEntry { +/// option (google.api.resource) = { +/// type: "logging.googleapis.com/LogEntry" +/// name_descriptor: { +/// pattern: "projects/{project}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// parent_name_extractor: "projects/{project}" +/// } +/// name_descriptor: { +/// pattern: "folders/{folder}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Folder" +/// parent_name_extractor: "folders/{folder}" +/// } +/// name_descriptor: { +/// pattern: "organizations/{organization}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Organization" +/// parent_name_extractor: "organizations/{organization}" +/// } +/// name_descriptor: { +/// pattern: "billingAccounts/{billing_account}/logs/{log}" +/// parent_type: "billing.googleapis.com/BillingAccount" +/// parent_name_extractor: "billingAccounts/{billing_account}" +/// } +/// }; +/// } +/// ``` +/// +/// The ResourceDescriptor Yaml config will look like: +/// +/// ```text +/// resources: +/// - type: 'logging.googleapis.com/LogEntry' +/// name_descriptor: +/// - pattern: "projects/{project}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// parent_name_extractor: "projects/{project}" +/// - pattern: "folders/{folder}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Folder" +/// parent_name_extractor: "folders/{folder}" +/// - pattern: "organizations/{organization}/logs/{log}" +/// parent_type: "cloudresourcemanager.googleapis.com/Organization" +/// parent_name_extractor: "organizations/{organization}" +/// - pattern: "billingAccounts/{billing_account}/logs/{log}" +/// parent_type: "billing.googleapis.com/BillingAccount" +/// parent_name_extractor: "billingAccounts/{billing_account}" +/// ``` +/// +/// For flexible resources, the resource name doesn't contain parent names, but +/// the resource itself has parents for policy evaluation. +/// +/// Example: +/// +/// ```text +/// message Shelf { +/// option (google.api.resource) = { +/// type: "library.googleapis.com/Shelf" +/// name_descriptor: { +/// pattern: "shelves/{shelf}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// } +/// name_descriptor: { +/// pattern: "shelves/{shelf}" +/// parent_type: "cloudresourcemanager.googleapis.com/Folder" +/// } +/// }; +/// } +/// ``` +/// +/// The ResourceDescriptor Yaml config will look like: +/// +/// ```text +/// resources: +/// - type: 'library.googleapis.com/Shelf' +/// name_descriptor: +/// - pattern: "shelves/{shelf}" +/// parent_type: "cloudresourcemanager.googleapis.com/Project" +/// - pattern: "shelves/{shelf}" +/// parent_type: "cloudresourcemanager.googleapis.com/Folder" +/// ``` +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ResourceDescriptor { + /// The resource type. It must be in the format of + /// {service_name}/{resource_type_kind}. The `resource_type_kind` must be + /// singular and must not include version numbers. + /// + /// Example: `storage.googleapis.com/Bucket` + /// + /// The value of the resource_type_kind must follow the regular expression + /// /\[A-Za-z\]\[a-zA-Z0-9\]+/. It should start with an upper case character and + /// should use PascalCase (UpperCamelCase). The maximum number of + /// characters allowed for the `resource_type_kind` is 100. + #[prost(string, tag = "1")] + pub r#type: ::prost::alloc::string::String, + /// Optional. The relative resource name pattern associated with this resource + /// type. The DNS prefix of the full resource name shouldn't be specified here. + /// + /// The path pattern must follow the syntax, which aligns with HTTP binding + /// syntax: + /// + /// ```text + /// Template = Segment { "/" Segment } ; + /// Segment = LITERAL | Variable ; + /// Variable = "{" LITERAL "}" ; + /// ``` + /// + /// Examples: + /// + /// ```text + /// - "projects/{project}/topics/{topic}" + /// - "projects/{project}/knowledgeBases/{knowledge_base}" + /// ``` + /// + /// The components in braces correspond to the IDs for each resource in the + /// hierarchy. It is expected that, if multiple patterns are provided, + /// the same component name (e.g. "project") refers to IDs of the same + /// type of resource. + #[prost(string, repeated, tag = "2")] + pub pattern: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Optional. The field on the resource that designates the resource name + /// field. If omitted, this is assumed to be "name". + #[prost(string, tag = "3")] + pub name_field: ::prost::alloc::string::String, + /// Optional. The historical or future-looking state of the resource pattern. + /// + /// Example: + /// + /// ```text + /// // The InspectTemplate message originally only supported resource + /// // names with organization, and project was added later. + /// message InspectTemplate { + /// option (google.api.resource) = { + /// type: "dlp.googleapis.com/InspectTemplate" + /// pattern: + /// "organizations/{organization}/inspectTemplates/{inspect_template}" + /// pattern: "projects/{project}/inspectTemplates/{inspect_template}" + /// history: ORIGINALLY_SINGLE_PATTERN + /// }; + /// } + /// ``` + #[prost(enumeration = "resource_descriptor::History", tag = "4")] + pub history: i32, + /// The plural name used in the resource name and permission names, such as + /// 'projects' for the resource name of 'projects/{project}' and the permission + /// name of 'cloudresourcemanager.googleapis.com/projects.get'. It is the same + /// concept of the `plural` field in k8s CRD spec + /// + /// + /// Note: The plural form is required even for singleton resources. See + /// + #[prost(string, tag = "5")] + pub plural: ::prost::alloc::string::String, + /// The same concept of the `singular` field in k8s CRD spec + /// + /// Such as "project" for the `resourcemanager.googleapis.com/Project` type. + #[prost(string, tag = "6")] + pub singular: ::prost::alloc::string::String, + /// Style flag(s) for this resource. + /// These indicate that a resource is expected to conform to a given + /// style. See the specific style flags for additional information. + #[prost(enumeration = "resource_descriptor::Style", repeated, tag = "10")] + pub style: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `ResourceDescriptor`. +pub mod resource_descriptor { + /// A description of the historical or future-looking state of the + /// resource pattern. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum History { + /// The "unset" value. + Unspecified = 0, + /// The resource originally had one pattern and launched as such, and + /// additional patterns were added later. + OriginallySinglePattern = 1, + /// The resource has one pattern, but the API owner expects to add more + /// later. (This is the inverse of ORIGINALLY_SINGLE_PATTERN, and prevents + /// that from being necessary once there are multiple patterns.) + FutureMultiPattern = 2, + } + impl History { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "HISTORY_UNSPECIFIED", + Self::OriginallySinglePattern => "ORIGINALLY_SINGLE_PATTERN", + Self::FutureMultiPattern => "FUTURE_MULTI_PATTERN", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "HISTORY_UNSPECIFIED" => Some(Self::Unspecified), + "ORIGINALLY_SINGLE_PATTERN" => Some(Self::OriginallySinglePattern), + "FUTURE_MULTI_PATTERN" => Some(Self::FutureMultiPattern), + _ => None, + } + } + } + /// A flag representing a specific style that a resource claims to conform to. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Style { + /// The unspecified value. Do not use. + Unspecified = 0, + /// This resource is intended to be "declarative-friendly". + /// + /// Declarative-friendly resources must be more strictly consistent, and + /// setting this to true communicates to tools that this resource should + /// adhere to declarative-friendly expectations. + /// + /// Note: This is used by the API linter (linter.aip.dev) to enable + /// additional checks. + DeclarativeFriendly = 1, + } + impl Style { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "STYLE_UNSPECIFIED", + Self::DeclarativeFriendly => "DECLARATIVE_FRIENDLY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "STYLE_UNSPECIFIED" => Some(Self::Unspecified), + "DECLARATIVE_FRIENDLY" => Some(Self::DeclarativeFriendly), + _ => None, + } + } + } +} +/// Defines a proto annotation that describes a string field that refers to +/// an API resource. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ResourceReference { + /// The resource type that the annotated field references. + /// + /// Example: + /// + /// ```text + /// message Subscription { + /// string topic = 2 [(google.api.resource_reference) = { + /// type: "pubsub.googleapis.com/Topic" + /// }]; + /// } + /// ``` + /// + /// Occasionally, a field may reference an arbitrary resource. In this case, + /// APIs use the special value * in their resource reference. + /// + /// Example: + /// + /// ```text + /// message GetIamPolicyRequest { + /// string resource = 2 [(google.api.resource_reference) = { + /// type: "*" + /// }]; + /// } + /// ``` + #[prost(string, tag = "1")] + pub r#type: ::prost::alloc::string::String, + /// The resource type of a child collection that the annotated field + /// references. This is useful for annotating the `parent` field that + /// doesn't have a fixed resource type. + /// + /// Example: + /// + /// ```text + /// message ListLogEntriesRequest { + /// string parent = 1 [(google.api.resource_reference) = { + /// child_type: "logging.googleapis.com/LogEntry" + /// }; + /// } + /// ``` + #[prost(string, tag = "2")] + pub child_type: ::prost::alloc::string::String, +} +/// `Context` defines which contexts an API requests. +/// +/// Example: +/// +/// ```text +/// context: +/// rules: +/// - selector: "*" +/// requested: +/// - google.rpc.context.ProjectContext +/// - google.rpc.context.OriginContext +/// ``` +/// +/// The above specifies that all methods in the API request +/// `google.rpc.context.ProjectContext` and +/// `google.rpc.context.OriginContext`. +/// +/// Available context types are defined in package +/// `google.rpc.context`. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Context { + /// A list of RPC context rules that apply to individual API methods. + /// + /// **NOTE:** All service configuration rules follow "last one wins" order. + #[prost(message, repeated, tag = "1")] + pub rules: ::prost::alloc::vec::Vec, +} +/// A context rule provides information about the context for an individual API +/// element. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ContextRule { + /// 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, + /// A list of full type names of requested contexts. + #[prost(string, repeated, tag = "2")] + pub requested: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// A list of full type names of provided contexts. + #[prost(string, repeated, tag = "3")] + pub provided: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// Output generated from semantically comparing two versions of a service +/// configuration. +/// +/// Includes detailed information about a field that have changed with +/// applicable advice about potential consequences for the change, such as +/// backwards-incompatibility. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ConfigChange { + /// Object hierarchy path to the change, with levels separated by a '.' + /// character. For repeated fields, an applicable unique identifier field is + /// used for the index (usually selector, name, or id). For maps, the term + /// 'key' is used. If the field has no unique identifier, the numeric index + /// is used. + /// Examples: + /// + /// * visibility.rules\[selector=="google.LibraryService.CreateBook"\].restriction + /// * quota.metric_rules\[selector=="google"\].metric_costs\[key=="reads"\].value + /// * logging.producer_destinations\[0\] + #[prost(string, tag = "1")] + pub element: ::prost::alloc::string::String, + /// Value of the changed object in the old Service configuration, + /// in JSON format. This field will not be populated if ChangeType == ADDED. + #[prost(string, tag = "2")] + pub old_value: ::prost::alloc::string::String, + /// Value of the changed object in the new Service configuration, + /// in JSON format. This field will not be populated if ChangeType == REMOVED. + #[prost(string, tag = "3")] + pub new_value: ::prost::alloc::string::String, + /// The type for this change, either ADDED, REMOVED, or MODIFIED. + #[prost(enumeration = "ChangeType", tag = "4")] + pub change_type: i32, + /// Collection of advice provided for this change, useful for determining the + /// possible impact of this change. + #[prost(message, repeated, tag = "5")] + pub advices: ::prost::alloc::vec::Vec, +} +/// Generated advice about this change, used for providing more +/// information about how a change will affect the existing service. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Advice { + /// Useful description for why this advice was applied and what actions should + /// be taken to mitigate any implied risks. + #[prost(string, tag = "2")] + pub description: ::prost::alloc::string::String, +} +/// Classifies set of possible modifications to an object in the service +/// configuration. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ChangeType { + /// No value was provided. + Unspecified = 0, + /// The changed object exists in the 'new' service configuration, but not + /// in the 'old' service configuration. + Added = 1, + /// The changed object exists in the 'old' service configuration, but not + /// in the 'new' service configuration. + Removed = 2, + /// The changed object exists in both service configurations, but its value + /// is different. + Modified = 3, +} +impl ChangeType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "CHANGE_TYPE_UNSPECIFIED", + Self::Added => "ADDED", + Self::Removed => "REMOVED", + Self::Modified => "MODIFIED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CHANGE_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "ADDED" => Some(Self::Added), + "REMOVED" => Some(Self::Removed), + "MODIFIED" => Some(Self::Modified), + _ => None, + } + } +} +/// ### 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 + /// + /// ```text + /// system_parameters + /// rules: + /// - selector: "*" + /// parameters: + /// - name: api_key + /// url_query_parameter: api_key + /// ``` + /// + /// Example: define 2 api key names for a specific method. + /// + /// ```text + /// 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, Eq, Hash, ::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, +} +/// 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/overdue_count` metric is only sent to the +/// consumer project. +/// +/// ```text +/// 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. +/// metrics: +/// - name: library.googleapis.com/book/returned_count +/// metric_kind: DELTA +/// value_type: INT64 +/// labels: +/// - key: /customer_id +/// - name: library.googleapis.com/book/overdue_count +/// metric_kind: GAUGE +/// value_type: INT64 +/// labels: +/// - key: /customer_id +/// 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/overdue_count +/// ``` +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Monitoring { + /// Monitoring configurations for sending metrics to the producer project. + /// There can be multiple producer destinations, each one must have a + /// different monitored resource type. A metric can be used in at most + /// one producer destination. + #[prost(message, repeated, tag = "1")] + pub producer_destinations: ::prost::alloc::vec::Vec< + monitoring::MonitoringDestination, + >, + /// Monitoring configurations for sending metrics to the consumer project. + /// There can be multiple consumer destinations, each one must have a + /// different monitored resource type. A metric can be used in at most + /// one consumer destination. + #[prost(message, repeated, tag = "2")] + pub consumer_destinations: ::prost::alloc::vec::Vec< + monitoring::MonitoringDestination, + >, +} +/// 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, Eq, Hash, ::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, + /// Names of the metrics to report to this monitoring destination. + /// Each name 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>, + } +} +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// { +/// 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: +/// +/// ```text +/// option (google.api.routing) = { +/// // Take the `app_profile_id`. +/// routing_parameters { +/// field: "app_profile_id" +/// } +/// }; +/// ``` +/// +/// result: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// +/// ``` +/// +/// Sub-example 3c +/// +/// Multiple alternative conflictingly named path templates are +/// specified. The one that matches is used to construct the header. +/// +/// annotation: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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): +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// x-goog-request-params: routing_id=profiles/prof_qux +/// ``` +/// +/// Example 9 +/// +/// Bringing it all together. +/// +/// annotation: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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, Eq, Hash, ::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: + /// + /// ```text + /// -- 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 + /// + /// ```text + /// { + /// field: "table_name" + /// } + /// ``` + /// + /// is a functionally equivalent shorthand to: + /// + /// ```text + /// { + /// field: "table_name" + /// path_template: "{table_name=**}" + /// } + /// ``` + /// + /// See Example 1 for more details. + #[prost(string, tag = "2")] + pub path_template: ::prost::alloc::string::String, +} +/// The launch stage as defined by [Google Cloud Platform +/// Launch Stages](). +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum LaunchStage { + /// Do not use this default value. + Unspecified = 0, + /// Early Access features are limited to a closed group of testers. To use + /// these features, you must sign up in advance and sign a Trusted Tester + /// agreement (which includes confidentiality provisions). These features may + /// be unstable, changed in backward-incompatible ways, and are not + /// guaranteed to be released. + EarlyAccess = 1, + /// Alpha is a limited availability test for releases before they are cleared + /// for widespread use. By Alpha, all significant design issues are resolved + /// and we are in the process of verifying functionality. Alpha customers + /// need to apply for access, agree to applicable terms, and have their + /// projects whitelisted. Alpha releases don’t have to be feature complete, + /// no SLAs are provided, and there are no technical support obligations, but + /// they will be far enough along that customers can actually use them in + /// test environments or for limited-use tests -- just like they would in + /// normal production cases. + Alpha = 2, + /// Beta is the point at which we are ready to open a release for any + /// customer to use. There are no SLA or technical support obligations in a + /// Beta release. Products will be complete from a feature perspective, but + /// may have some open outstanding issues. Beta releases are suitable for + /// limited production use cases. + Beta = 3, + /// GA features are open to all developers and are considered stable and + /// fully qualified for production use. + Ga = 4, + /// Deprecated features are scheduled to be shut down and removed. For more + /// information, see the “Deprecation Policy” section of our [Terms of + /// Service]() + /// and the [Google Cloud Platform Subject to the Deprecation + /// Policy]() documentation. + Deprecated = 5, +} +impl LaunchStage { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "LAUNCH_STAGE_UNSPECIFIED", + Self::EarlyAccess => "EARLY_ACCESS", + Self::Alpha => "ALPHA", + Self::Beta => "BETA", + Self::Ga => "GA", + Self::Deprecated => "DEPRECATED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "LAUNCH_STAGE_UNSPECIFIED" => Some(Self::Unspecified), + "EARLY_ACCESS" => Some(Self::EarlyAccess), + "ALPHA" => Some(Self::Alpha), + "BETA" => Some(Self::Beta), + "GA" => Some(Self::Ga), + "DEPRECATED" => Some(Self::Deprecated), + _ => None, + } + } +} +/// `Distribution` contains summary statistics for a population of values. It +/// optionally contains a histogram representing the distribution of those values +/// across a set of buckets. +/// +/// The summary statistics are the count, mean, sum of the squared deviation from +/// the mean, the minimum, and the maximum of the set of population of values. +/// The histogram is based on a sequence of buckets and gives a count of values +/// that fall into each bucket. The boundaries of the buckets are given either +/// explicitly or by formulas for buckets of fixed or exponentially increasing +/// widths. +/// +/// Although it is not forbidden, it is generally a bad idea to include +/// non-finite values (infinities or NaNs) in the population of values, as this +/// will render the `mean` and `sum_of_squared_deviation` fields meaningless. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Distribution { + /// The number of values in the population. Must be non-negative. This value + /// must equal the sum of the values in `bucket_counts` if a histogram is + /// provided. + #[prost(int64, tag = "1")] + pub count: i64, + /// The arithmetic mean of the values in the population. If `count` is zero + /// then this field must be zero. + #[prost(double, tag = "2")] + pub mean: f64, + /// The sum of squared deviations from the mean of the values in the + /// population. For values x_i this is: + /// + /// ```text + /// Sum[i=1..n]((x_i - mean)^2) + /// ``` + /// + /// Knuth, "The Art of Computer Programming", Vol. 2, page 323, 3rd edition + /// describes Welford's method for accumulating this sum in one pass. + /// + /// If `count` is zero then this field must be zero. + #[prost(double, tag = "3")] + pub sum_of_squared_deviation: f64, + /// If specified, contains the range of the population values. The field + /// must not be present if the `count` is zero. + #[prost(message, optional, tag = "4")] + pub range: ::core::option::Option, + /// Defines the histogram bucket boundaries. If the distribution does not + /// contain a histogram, then omit this field. + #[prost(message, optional, tag = "6")] + pub bucket_options: ::core::option::Option, + /// The number of values in each bucket of the histogram, as described in + /// `bucket_options`. If the distribution does not have a histogram, then omit + /// this field. If there is a histogram, then the sum of the values in + /// `bucket_counts` must equal the value in the `count` field of the + /// distribution. + /// + /// If present, `bucket_counts` should contain N values, where N is the number + /// of buckets specified in `bucket_options`. If you supply fewer than N + /// values, the remaining values are assumed to be 0. + /// + /// The order of the values in `bucket_counts` follows the bucket numbering + /// schemes described for the three bucket types. The first value must be the + /// count for the underflow bucket (number 0). The next N-2 values are the + /// counts for the finite buckets (number 1 through N-2). The N'th value in + /// `bucket_counts` is the count for the overflow bucket (number N-1). + #[prost(int64, repeated, tag = "7")] + pub bucket_counts: ::prost::alloc::vec::Vec, + /// Must be in increasing order of `value` field. + #[prost(message, repeated, tag = "10")] + pub exemplars: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `Distribution`. +pub mod distribution { + /// The range of the population values. + #[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct Range { + /// The minimum of the population values. + #[prost(double, tag = "1")] + pub min: f64, + /// The maximum of the population values. + #[prost(double, tag = "2")] + pub max: f64, + } + /// `BucketOptions` describes the bucket boundaries used to create a histogram + /// for the distribution. The buckets can be in a linear sequence, an + /// exponential sequence, or each bucket can be specified explicitly. + /// `BucketOptions` does not include the number of values in each bucket. + /// + /// A bucket has an inclusive lower bound and exclusive upper bound for the + /// values that are counted for that bucket. The upper bound of a bucket must + /// be strictly greater than the lower bound. The sequence of N buckets for a + /// distribution consists of an underflow bucket (number 0), zero or more + /// finite buckets (number 1 through N - 2) and an overflow bucket (number N - + /// 1). The buckets are contiguous: the lower bound of bucket i (i > 0) is the + /// same as the upper bound of bucket i - 1. The buckets span the whole range + /// of finite values: lower bound of the underflow bucket is -infinity and the + /// upper bound of the overflow bucket is +infinity. The finite buckets are + /// so-called because both bounds are finite. + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct BucketOptions { + /// Exactly one of these three fields must be set. + #[prost(oneof = "bucket_options::Options", tags = "1, 2, 3")] + pub options: ::core::option::Option, + } + /// Nested message and enum types in `BucketOptions`. + pub mod bucket_options { + /// Specifies a linear sequence of buckets that all have the same width + /// (except overflow and underflow). Each bucket represents a constant + /// absolute uncertainty on the specific value in the bucket. + /// + /// There are `num_finite_buckets + 2` (= N) buckets. Bucket `i` has the + /// following boundaries: + /// + /// ```text + /// Upper bound (0 <= i < N-1): offset + (width * i). + /// Lower bound (1 <= i < N): offset + (width * (i - 1)). + /// ``` + #[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct Linear { + /// Must be greater than 0. + #[prost(int32, tag = "1")] + pub num_finite_buckets: i32, + /// Must be greater than 0. + #[prost(double, tag = "2")] + pub width: f64, + /// Lower bound of the first bucket. + #[prost(double, tag = "3")] + pub offset: f64, + } + /// Specifies an exponential sequence of buckets that have a width that is + /// proportional to the value of the lower bound. Each bucket represents a + /// constant relative uncertainty on a specific value in the bucket. + /// + /// There are `num_finite_buckets + 2` (= N) buckets. Bucket `i` has the + /// following boundaries: + /// + /// ```text + /// Upper bound (0 <= i < N-1): scale * (growth_factor ^ i). + /// Lower bound (1 <= i < N): scale * (growth_factor ^ (i - 1)). + /// ``` + #[derive(Clone, Copy, PartialEq, ::prost::Message)] + pub struct Exponential { + /// Must be greater than 0. + #[prost(int32, tag = "1")] + pub num_finite_buckets: i32, + /// Must be greater than 1. + #[prost(double, tag = "2")] + pub growth_factor: f64, + /// Must be greater than 0. + #[prost(double, tag = "3")] + pub scale: f64, + } + /// Specifies a set of buckets with arbitrary widths. + /// + /// There are `size(bounds) + 1` (= N) buckets. Bucket `i` has the following + /// boundaries: + /// + /// ```text + /// Upper bound (0 <= i < N-1): bounds\[i\] + /// Lower bound (1 <= i < N); bounds\[i - 1\] + /// ``` + /// + /// The `bounds` field must contain at least one element. If `bounds` has + /// only one element, then there are no finite buckets, and that single + /// element is the common boundary of the overflow and underflow buckets. + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Explicit { + /// The values must be monotonically increasing. + #[prost(double, repeated, tag = "1")] + pub bounds: ::prost::alloc::vec::Vec, + } + /// 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 ID: type.googleapis.com/google.devtools.cloudtrace.v1.Trace + /// + /// 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>, + } +} +/// `Endpoint` describes a network endpoint that serves a set of APIs. +/// A service may expose any number of endpoints, and all endpoints share the +/// same service configuration, such as quota configuration and monitoring +/// configuration. +/// +/// Example service configuration: +/// +/// ```text +/// 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, Eq, Hash, ::prost::Message)] +pub struct Endpoint { + /// The canonical name of this endpoint. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// 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. + #[prost(string, repeated, tag = "2")] + pub aliases: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The list of features enabled on this endpoint. + #[prost(string, repeated, tag = "4")] + pub features: ::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, +} +/// 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'. + #[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. +/// +/// ```text +/// usage: +/// rules: +/// - selector: "*" +/// allow_unregistered_calls: true +/// ``` +/// +/// Example of a method that wants to allow unregistered calls. +/// +/// ```text +/// usage: +/// rules: +/// - selector: "google.example.library.v1.LibraryService.CreateBook" +/// allow_unregistered_calls: true +/// ``` +#[derive(Clone, PartialEq, Eq, Hash, ::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, +} +/// A description of a label. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct LabelDescriptor { + /// The label key. + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + /// The type of data that can be assigned to the label. + #[prost(enumeration = "label_descriptor::ValueType", tag = "2")] + pub value_type: i32, + /// A human-readable description for the label. + #[prost(string, tag = "3")] + pub description: ::prost::alloc::string::String, +} +/// Nested message and enum types in `LabelDescriptor`. +pub mod label_descriptor { + /// Value types that can be used as label values. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum ValueType { + /// A variable-length string. This is the default. + String = 0, + /// Boolean; true or false. + Bool = 1, + /// A 64-bit signed integer. + Int64 = 2, + } + impl ValueType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::String => "STRING", + Self::Bool => "BOOL", + Self::Int64 => "INT64", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "STRING" => Some(Self::String), + "BOOL" => Some(Self::Bool), + "INT64" => Some(Self::Int64), + _ => None, + } + } + } +} +/// 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. + /// The maximum length of this value is 256 characters. + #[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, +} +/// 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"`: +/// +/// ```text +/// { "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. Google Stackdriver Monitoring & Logging uses an ingestion +/// pipeline to extract metadata for cloud resources of all types , and stores +/// 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 Stackdriver. + /// Stackdriver determines what system labels are useful and how to obtain + /// their values. Some examples: "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: + /// + /// ```text + /// { "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, + >, +} +/// Selects and configures the service controller used by the service. The +/// service controller handles features like abuse, quota, billing, logging, +/// monitoring, etc. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Control { + /// The service control environment to use. If empty, no control plane + /// feature (like quota and billing) will be enabled. + #[prost(string, tag = "1")] + pub environment: ::prost::alloc::string::String, +} +/// Defines a metric type and its schema. Once a metric descriptor is created, +/// deleting or altering it stops data collection and makes the metric type's +/// existing data unusable. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct MetricDescriptor { + /// The resource name of the metric descriptor. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The metric type, including its DNS name prefix. The type is not + /// URL-encoded. All user-defined custom metric types have the DNS name + /// `custom.googleapis.com`. Metric types should use a natural hierarchical + /// grouping. For example: + /// + /// ```text + /// "custom.googleapis.com/invoice/paid/amount" + /// "appengine.googleapis.com/http/server/response_latencies" + /// ``` + #[prost(string, tag = "8")] + pub r#type: ::prost::alloc::string::String, + /// The set of labels that can be used to describe a specific + /// instance of this metric type. For example, the + /// `appengine.googleapis.com/http/server/response_latencies` metric + /// type has a label for the HTTP response code, `response_code`, so + /// you can look at latencies for successful responses or just + /// for responses that failed. + #[prost(message, repeated, tag = "2")] + pub labels: ::prost::alloc::vec::Vec, + /// Whether the metric records instantaneous values, changes to a value, etc. + /// Some combinations of `metric_kind` and `value_type` might not be supported. + #[prost(enumeration = "metric_descriptor::MetricKind", tag = "3")] + pub metric_kind: i32, + /// Whether the measurement is an integer, a floating-point number, etc. + /// Some combinations of `metric_kind` and `value_type` might not be supported. + #[prost(enumeration = "metric_descriptor::ValueType", tag = "4")] + pub value_type: i32, + /// The unit in which the metric value is reported. It is only applicable + /// if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. The + /// supported units are a subset of [The Unified Code for Units of + /// Measure]() standard: + /// + /// **Basic units (UNIT)** + /// + /// * `bit` bit + /// * `By` byte + /// * `s` second + /// * `min` minute + /// * `h` hour + /// * `d` day + /// + /// **Prefixes (PREFIX)** + /// + /// * `k` kilo (10\*\*3) + /// * `M` mega (10\*\*6) + /// * `G` giga (10\*\*9) + /// * `T` tera (10\*\*12) + /// * `P` peta (10\*\*15) + /// * `E` exa (10\*\*18) + /// * `Z` zetta (10\*\*21) + /// * `Y` yotta (10\*\*24) + /// * `m` milli (10\*\*-3) + /// * `u` micro (10\*\*-6) + /// * `n` nano (10\*\*-9) + /// * `p` pico (10\*\*-12) + /// * `f` femto (10\*\*-15) + /// * `a` atto (10\*\*-18) + /// * `z` zepto (10\*\*-21) + /// * `y` yocto (10\*\*-24) + /// * `Ki` kibi (2\*\*10) + /// * `Mi` mebi (2\*\*20) + /// * `Gi` gibi (2\*\*30) + /// * `Ti` tebi (2\*\*40) + /// + /// **Grammar** + /// + /// The grammar also includes these connectors: + /// + /// * `/` division (as an infix operator, e.g. `1/s`). + /// * `.` multiplication (as an infix operator, e.g. `GBy.d`) + /// + /// The grammar for a unit is as follows: + /// + /// ```text + /// Expression = Component { "." Component } { "/" Component } ; + /// + /// Component = ( \[ PREFIX \] UNIT | "%" ) \[ Annotation \] + /// | Annotation + /// | "1" + /// ; + /// + /// Annotation = "{" NAME "}" ; + /// ``` + /// + /// Notes: + /// + /// * `Annotation` is just a comment if it follows a `UNIT` and is + /// equivalent to `1` if it is used alone. For examples, + /// `{requests}/s == 1/s`, `By{transmitted}/s == By/s`. + /// * `NAME` is a sequence of non-blank printable ASCII characters not + /// containing '{' or '}'. + /// * `1` represents dimensionless value 1, such as in `1/s`. + /// * `%` represents dimensionless value 1/100, and annotates values giving + /// a percentage. + #[prost(string, tag = "5")] + pub unit: ::prost::alloc::string::String, + /// A detailed description of the metric, which can be used in documentation. + #[prost(string, tag = "6")] + pub description: ::prost::alloc::string::String, + /// A concise name for the metric, which can be displayed in user interfaces. + /// Use sentence case without an ending period, for example "Request count". + /// This field is optional but it is recommended to be set for any metrics + /// associated with user-visible concepts, such as Quota. + #[prost(string, tag = "7")] + pub display_name: ::prost::alloc::string::String, +} +/// Nested message and enum types in `MetricDescriptor`. +pub mod metric_descriptor { + /// The kind of measurement. It describes how the data is reported. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum MetricKind { + /// Do not use this default value. + Unspecified = 0, + /// An instantaneous measurement of a value. + Gauge = 1, + /// The change in a value during a time interval. + Delta = 2, + /// A value accumulated over a time interval. Cumulative + /// measurements in a time series should have the same start time + /// and increasing end times, until an event resets the cumulative + /// value to zero and sets a new start time for the following + /// points. + Cumulative = 3, + } + impl MetricKind { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "METRIC_KIND_UNSPECIFIED", + Self::Gauge => "GAUGE", + Self::Delta => "DELTA", + Self::Cumulative => "CUMULATIVE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "METRIC_KIND_UNSPECIFIED" => Some(Self::Unspecified), + "GAUGE" => Some(Self::Gauge), + "DELTA" => Some(Self::Delta), + "CUMULATIVE" => Some(Self::Cumulative), + _ => None, + } + } + } + /// The value type of a metric. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum ValueType { + /// Do not use this default value. + Unspecified = 0, + /// The value is a boolean. + /// This value type can be used only if the metric kind is `GAUGE`. + Bool = 1, + /// The value is a signed 64-bit integer. + Int64 = 2, + /// The value is a double precision floating point number. + Double = 3, + /// The value is a text string. + /// This value type can be used only if the metric kind is `GAUGE`. + String = 4, + /// The value is a \[`Distribution`\]\[google.api.Distribution\]. + Distribution = 5, + /// The value is money. + Money = 6, + } + impl ValueType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "VALUE_TYPE_UNSPECIFIED", + Self::Bool => "BOOL", + Self::Int64 => "INT64", + Self::Double => "DOUBLE", + Self::String => "STRING", + Self::Distribution => "DISTRIBUTION", + Self::Money => "MONEY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "VALUE_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "BOOL" => Some(Self::Bool), + "INT64" => Some(Self::Int64), + "DOUBLE" => Some(Self::Double), + "STRING" => Some(Self::String), + "DISTRIBUTION" => Some(Self::Distribution), + "MONEY" => Some(Self::Money), + _ => None, + } + } + } +} +/// A specific metric, identified by specifying values for all of the +/// labels of a \[`MetricDescriptor`\]\[google.api.MetricDescriptor\]. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Metric { + /// An existing metric type, see \[google.api.MetricDescriptor\]\[google.api.MetricDescriptor\]. + /// For example, `custom.googleapis.com/invoice/paid/amount`. + #[prost(string, tag = "3")] + pub r#type: ::prost::alloc::string::String, + /// The set of label values that uniquely identify this metric. All + /// labels listed in the `MetricDescriptor` must be assigned values. + #[prost(map = "string, string", tag = "2")] + pub labels: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// A descriptor for defining project properties for a service. One service may +/// have many consumer projects, and the service may want to behave differently +/// depending on some properties on the project. For example, a project may be +/// associated with a school, or a business, or a government agency, a business +/// type property on the project may affect how a service responds to the client. +/// This descriptor defines which properties are allowed to be set on a project. +/// +/// Example: +/// +/// ```text +/// project_properties: +/// properties: +/// - name: NO_WATERMARK +/// type: BOOL +/// description: Allows usage of the API without watermarks. +/// - name: EXTENDED_TILE_CACHE_PERIOD +/// type: INT64 +/// ``` +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ProjectProperties { + /// List of per consumer project-specific properties. + #[prost(message, repeated, tag = "1")] + pub properties: ::prost::alloc::vec::Vec, +} +/// Defines project properties. +/// +/// API services can define properties that can be assigned to consumer projects +/// so that backends can perform response customization without having to make +/// additional calls or maintain additional storage. For example, Maps API +/// defines properties that controls map tile cache period, or whether to embed a +/// watermark in a result. +/// +/// These values can be set via API producer console. Only API providers can +/// define and set these properties. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Property { + /// The name of the property (a.k.a key). + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The type of this property. + #[prost(enumeration = "property::PropertyType", tag = "2")] + pub r#type: i32, + /// The description of the property + #[prost(string, tag = "3")] + pub description: ::prost::alloc::string::String, +} +/// Nested message and enum types in `Property`. +pub mod property { + /// Supported data type of the property values + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum PropertyType { + /// The type is unspecified, and will result in an error. + Unspecified = 0, + /// The type is `int64`. + Int64 = 1, + /// The type is `bool`. + Bool = 2, + /// The type is `string`. + String = 3, + /// The type is 'double'. + Double = 4, + } + impl PropertyType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "UNSPECIFIED", + Self::Int64 => "INT64", + Self::Bool => "BOOL", + Self::String => "STRING", + Self::Double => "DOUBLE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNSPECIFIED" => Some(Self::Unspecified), + "INT64" => Some(Self::Int64), + "BOOL" => Some(Self::Bool), + "STRING" => Some(Self::String), + "DOUBLE" => Some(Self::Double), + _ => None, + } + } + } +} +/// A description of a log type. Example in YAML format: +/// +/// ```text +/// - 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, +} +/// Billing related configuration of the service. +/// +/// The following example shows how to configure monitored resources and metrics +/// for billing: +/// +/// ```text +/// 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. +/// metrics: +/// - name: library.googleapis.com/book/borrowed_count +/// metric_kind: DELTA +/// value_type: INT64 +/// billing: +/// consumer_destinations: +/// - monitored_resource: library.googleapis.com/branch +/// metrics: +/// - library.googleapis.com/book/borrowed_count +/// ``` +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Billing { + /// Billing configurations for sending metrics to the consumer project. + /// There can be multiple consumer destinations per service, each one must have + /// a different monitored resource type. A metric can be used in at most + /// one consumer destination. + #[prost(message, repeated, tag = "8")] + pub consumer_destinations: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `Billing`. +pub mod billing { + /// Configuration of a specific billing destination (Currently only support + /// bill against consumer project). + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct BillingDestination { + /// 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, + /// Names of the metrics to report to this billing destination. + /// Each name 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>, + } +} +/// `Authentication` defines the authentication configuration for an API. +/// +/// Example for an API targeted for external use: +/// +/// ```text +/// name: calendar.googleapis.com +/// authentication: +/// providers: +/// - id: google_calendar_auth +/// jwks_uri: +/// issuer: +/// rules: +/// - selector: "*" +/// requirements: +/// provider_id: google_calendar_auth +/// ``` +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Authentication { + /// A list of authentication rules that apply to individual API methods. + /// + /// **NOTE:** All service configuration rules follow "last one wins" order. + #[prost(message, repeated, tag = "3")] + pub rules: ::prost::alloc::vec::Vec, + /// Defines a set of authentication providers that a service supports. + #[prost(message, repeated, tag = "4")] + pub providers: ::prost::alloc::vec::Vec, +} +/// Authentication rules for the service. +/// +/// By default, if a method has any authentication requirements, every request +/// must include a valid credential matching one of the requirements. +/// It's an error to include more than one kind of credential in a single +/// request. +/// +/// If a method doesn't have any auth requirements, request credentials will be +/// ignored. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AuthenticationRule { + /// 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, + /// The requirements for OAuth credentials. + #[prost(message, optional, tag = "2")] + pub oauth: ::core::option::Option, + /// If true, the service accepts API keys without any other credential. + #[prost(bool, tag = "5")] + pub allow_without_credential: bool, + /// Requirements for additional authentication providers. + #[prost(message, repeated, tag = "7")] + pub requirements: ::prost::alloc::vec::Vec, +} +/// Configuration for an anthentication provider, including support for +/// [JSON Web Token (JWT)](). +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AuthProvider { + /// The unique identifier of the auth provider. It will be referred to by + /// `AuthRequirement.provider_id`. + /// + /// Example: "bookstore_auth". + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// Identifies the principal that issued the JWT. See + /// + /// Usually a URL or an email address. + /// + /// Example: + /// Example: 1234567-compute@developer.gserviceaccount.com + #[prost(string, tag = "2")] + pub issuer: ::prost::alloc::string::String, + /// URL of the provider's public key set to validate signature of the JWT. See + /// [OpenID Discovery](). + /// Optional if the key set document: + /// + /// * can be retrieved from + /// \[OpenID Discovery\]( + /// of the issuer. + /// * can be inferred from the email domain of the issuer (e.g. a Google service account). + /// + /// Example: + #[prost(string, tag = "3")] + pub jwks_uri: ::prost::alloc::string::String, + /// The list of JWT + /// [audiences](). + /// that are allowed to access. A JWT containing any of these audiences will + /// be accepted. When this setting is absent, only JWTs with audience + /// " + /// will be accepted. For example, if no audiences are in the setting, + /// LibraryService API will only accept JWTs with the following audience + /// " + /// + /// Example: + /// + /// ```text + /// audiences: bookstore_android.apps.googleusercontent.com, + /// bookstore_web.apps.googleusercontent.com + /// ``` + #[prost(string, tag = "4")] + pub audiences: ::prost::alloc::string::String, + /// Redirect URL if JWT token is required but no present or is expired. + /// Implement authorizationUrl of securityDefinitions in OpenAPI spec. + #[prost(string, tag = "5")] + pub authorization_url: ::prost::alloc::string::String, +} +/// OAuth scopes are a way to define data and permissions on data. For example, +/// there are scopes defined for "Read-only access to Google Calendar" and +/// "Access to Cloud Platform". Users can consent to a scope for an application, +/// giving it permission to access that data on their behalf. +/// +/// OAuth scope specifications should be fairly coarse grained; a user will need +/// to see and understand the text description of what your scope means. +/// +/// In most cases: use one or at most two OAuth scopes for an entire family of +/// products. If your product has multiple APIs, you should probably be sharing +/// the OAuth scope across all of those APIs. +/// +/// When you need finer grained OAuth consent screens: talk with your product +/// management about how developers will use them in practice. +/// +/// Please note that even though each of the canonical scopes is enough for a +/// request to be accepted and passed to the backend, a request can still fail +/// due to the backend requiring additional scopes or permissions. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct OAuthRequirements { + /// The list of publicly documented OAuth scopes that are allowed access. An + /// OAuth token containing any of these scopes will be accepted. + /// + /// Example: + /// + /// ```text + /// canonical_scopes: + /// + /// ``` + #[prost(string, tag = "1")] + pub canonical_scopes: ::prost::alloc::string::String, +} +/// User-defined authentication requirements, including support for +/// [JSON Web Token (JWT)](). +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AuthRequirement { + /// \[id\]\[google.api.AuthProvider.id\] from authentication provider. + /// + /// Example: + /// + /// ```text + /// provider_id: bookstore_auth + /// ``` + #[prost(string, tag = "1")] + pub provider_id: ::prost::alloc::string::String, + /// NOTE: This will be deprecated soon, once AuthProvider.audiences is + /// implemented and accepted in all the runtime components. + /// + /// The list of JWT + /// [audiences](). + /// that are allowed to access. A JWT containing any of these audiences will + /// be accepted. When this setting is absent, only JWTs with audience + /// " + /// will be accepted. For example, if no audiences are in the setting, + /// LibraryService API will only accept JWTs with the following audience + /// " + /// + /// Example: + /// + /// ```text + /// audiences: bookstore_android.apps.googleusercontent.com, + /// bookstore_web.apps.googleusercontent.com + /// ``` + #[prost(string, tag = "2")] + pub audiences: ::prost::alloc::string::String, +} +/// `Backend` defines the backend configuration for a service. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Backend { + /// A list of API backend rules that apply to individual API methods. + /// + /// **NOTE:** All service configuration rules follow "last one wins" order. + #[prost(message, repeated, tag = "1")] + pub rules: ::prost::alloc::vec::Vec, +} +/// A backend rule provides configuration for an individual API element. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BackendRule { + /// 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, + /// The address of the API backend. + #[prost(string, tag = "2")] + pub address: ::prost::alloc::string::String, + /// The number of seconds to wait for a response from a request. The default + /// deadline for gRPC is infinite (no deadline) and HTTP requests is 5 seconds. + #[prost(double, tag = "3")] + pub deadline: f64, + /// Minimum deadline in seconds needed for this method. Calls having deadline + /// value lower than this will be rejected. + #[prost(double, tag = "4")] + pub min_deadline: f64, +} +/// `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, + /// 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, Eq, Hash, ::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". 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, +} +/// 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. +/// +/// ```text +/// 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, Eq, Hash, ::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>, + } +} +/// Quota configuration helps to achieve fairness and budgeting in service +/// usage. +/// +/// The 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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. + /// + /// Used by metric-based quotas only. + #[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. + /// + /// Used by metric-based quotas only. + #[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, billing, and monitoring behaviors to apply to the +/// method call. +/// +/// Used by metric-based quotas only. +#[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 is used to refer to the limit when + /// overriding the default limit on per-consumer basis. + /// + /// For group-based quota limits, the name must be unique within the quota + /// group. If a name is not provided, it will be generated from the limit_by + /// and duration fields. + /// + /// For metric-based quota limits, 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. + /// + /// The name of a limit is used as a unique identifier for this limit. + /// Therefore, once a limit has been put into use, its name should be + /// immutable. You can use the display_name field to provide a user-friendly + /// name for the limit. The display name can be evolved over time without + /// affecting the identity of the limit. + #[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. Example: "100s", "24h", "1d". + /// For duration longer than a day, only multiple of days is supported. We + /// support only "100s" and "1d" for now. Additional support will be added in + /// the future. "0" indicates indefinite duration. + /// + /// 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. + /// + /// Used by metric-based quotas only. + #[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. + /// + /// The [Google Service Control]() + /// supports the following unit components: + /// + /// * One of the time intevals: + /// * "/min" for quota every minute. + /// * "/d" for quota every 24 hours, starting 00:00 US Pacific Time. + /// * Otherwise the quota won't be reset by time, such as storage limit. + /// * One and only one of the granted containers: + /// * "/{organization}" quota for an organization. + /// * "/{project}" quota for a project. + /// * "/{folder}" quota for a folder. + /// * "/{resource}" quota for a universal resource. + /// * Zero or more quota segmentation dimension. Not all combos are valid. + /// * "/{region}" quota for every region. Not to be used with time intervals. + /// * Otherwise the resources granted on the target is not segmented. + /// * "/{zone}" quota for every zone. Not to be used with time intervals. + /// * Otherwise the resources granted on the target is not segmented. + /// * "/{resource}" quota for a resource associated with a project or org. + /// + /// Here are some examples: + /// + /// * "1/min/{project}" for quota per minute per project. + /// * "1/min/{user}" for quota per minute per user. + /// * "1/min/{organization}" for quota per minute per organization. + /// + /// Note: the order of unit components is insignificant. + /// The "1" at the beginning is required to follow the metric unit syntax. + /// + /// Used by metric-based quotas only. + #[prost(string, tag = "9")] + pub unit: ::prost::alloc::string::String, + /// Tiered limit values. Also allows for regional or zone overrides for these + /// values if "/{region}" or "/{zone}" is specified in the unit field. + /// + /// Currently supported tiers from low to high: + /// VERY_LOW, LOW, STANDARD, HIGH, VERY_HIGH + /// + /// To apply different limit values for users according to their tiers, specify + /// the values for the tiers you want to differentiate. For example: + /// {LOW:100, STANDARD:500, HIGH:1000, VERY_HIGH:5000} + /// + /// The limit value for each tier is optional except for the tier STANDARD. + /// The limit value for an unspecified tier falls to the value of its next + /// tier towards tier STANDARD. For the above example, the limit value for tier + /// STANDARD is 500. + /// + /// To apply the same limit value for all users, just specify limit value for + /// tier STANDARD. For example: {STANDARD:500}. + /// + /// To apply a regional overide for a tier, add a map entry with key + /// "/", where is a region name. Similarly, for a zone + /// override, add a map entry with key "/{zone}". + /// Further, a wildcard can be used at the end of a zone name in order to + /// specify zone level overrides. For example: + /// LOW: 10, STANDARD: 50, HIGH: 100, + /// LOW/us-central1: 20, STANDARD/us-central1: 60, HIGH/us-central1: 200, + /// LOW/us-central1-*: 10, STANDARD/us-central1-*: 20, HIGH/us-central1-\*: 80 + /// + /// The regional overrides tier set for each region must be the same as + /// the tier set for default limit values. Same rule applies for zone overrides + /// tier as well. + /// + /// Used by metric-based quotas only. + #[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, +} +/// 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>, +} +/// `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: +/// +/// ```text +/// type: google.api.Service +/// config_version: 3 +/// 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 semantic version of the service configuration. The config version + /// affects the interpretation of the service configuration. For example, + /// certain features are enabled by default for certain config versions. + /// The latest config version is `3`. + #[prost(message, optional, tag = "20")] + pub config_version: ::core::option::Option, + /// The DNS address at which this service is available, + /// e.g. `calendar.googleapis.com`. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// A unique ID for a specific instance of this message, typically assigned + /// by the client for tracking purpose. If empty, the server may choose to + /// generate one instead. + #[prost(string, tag = "33")] + pub id: ::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 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: + /// + /// ```text + /// 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: + /// + /// ```text + /// 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, +} +/// 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: +/// +/// ```text +/// 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: +/// +/// ```text +/// 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 string representing the content type of the body. + #[prost(string, tag = "1")] + pub content_type: ::prost::alloc::string::String, + /// HTTP body binary data. + #[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>, +} diff --git a/prost-googleapis/src/google/cloud/mod.rs b/prost-googleapis/src/google/cloud/mod.rs new file mode 100644 index 000000000..4c04d53a7 --- /dev/null +++ b/prost-googleapis/src/google/cloud/mod.rs @@ -0,0 +1,53 @@ +// This file is @generated by prost-build. +/// An enum to be used to mark the essential (for polling) fields in an +/// API-specific Operation object. A custom Operation object may contain many +/// different fields, but only few of them are essential to conduct a successful +/// polling process. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum OperationResponseMapping { + /// Do not use. + Undefined = 0, + /// A field in an API-specific (custom) Operation object which carries the same + /// meaning as google.longrunning.Operation.name. + Name = 1, + /// A field in an API-specific (custom) Operation object which carries the same + /// meaning as google.longrunning.Operation.done. If the annotated field is of + /// an enum type, `annotated_field_name == EnumType.DONE` semantics should be + /// equivalent to `Operation.done == true`. If the annotated field is of type + /// boolean, then it should follow the same semantics as Operation.done. + /// Otherwise, a non-empty value should be treated as `Operation.done == true`. + Status = 2, + /// A field in an API-specific (custom) Operation object which carries the same + /// meaning as google.longrunning.Operation.error.code. + ErrorCode = 3, + /// A field in an API-specific (custom) Operation object which carries the same + /// meaning as google.longrunning.Operation.error.message. + ErrorMessage = 4, +} +impl OperationResponseMapping { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Undefined => "UNDEFINED", + Self::Name => "NAME", + Self::Status => "STATUS", + Self::ErrorCode => "ERROR_CODE", + Self::ErrorMessage => "ERROR_MESSAGE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "UNDEFINED" => Some(Self::Undefined), + "NAME" => Some(Self::Name), + "STATUS" => Some(Self::Status), + "ERROR_CODE" => Some(Self::ErrorCode), + "ERROR_MESSAGE" => Some(Self::ErrorMessage), + _ => None, + } + } +} diff --git a/prost-googleapis/src/google/iam/admin/mod.rs b/prost-googleapis/src/google/iam/admin/mod.rs new file mode 100644 index 000000000..a3a6d96c3 --- /dev/null +++ b/prost-googleapis/src/google/iam/admin/mod.rs @@ -0,0 +1 @@ +pub mod v1; diff --git a/prost-googleapis/src/google/iam/admin/v1/mod.rs b/prost-googleapis/src/google/iam/admin/v1/mod.rs new file mode 100644 index 000000000..ef41efa5b --- /dev/null +++ b/prost-googleapis/src/google/iam/admin/v1/mod.rs @@ -0,0 +1,971 @@ +// This file is @generated by prost-build. +/// A service account in the Identity and Access Management API. +/// +/// To create a service account, specify the `project_id` and the `account_id` +/// for the account. The `account_id` is unique within the project, and is used +/// to generate the service account email address and a stable +/// `unique_id`. +/// +/// If the account already exists, the account's resource name is returned +/// in the format of projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}. The caller +/// can use the name in other methods to access the account. +/// +/// All other methods can identify the service account using the format +/// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. +/// Using `-` as a wildcard for the `PROJECT_ID` will infer the project from +/// the account. The `ACCOUNT` value can be the `email` address or the +/// `unique_id` of the service account. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ServiceAccount { + /// The resource name of the service account in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. + /// + /// Requests using `-` as a wildcard for the `PROJECT_ID` will infer the + /// project from the `account` and the `ACCOUNT` value can be the `email` + /// address or the `unique_id` of the service account. + /// + /// In responses the resource name will always be in the format + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// @OutputOnly The id of the project that owns the service account. + #[prost(string, tag = "2")] + pub project_id: ::prost::alloc::string::String, + /// @OutputOnly The unique and stable id of the service account. + #[prost(string, tag = "4")] + pub unique_id: ::prost::alloc::string::String, + /// @OutputOnly The email address of the service account. + #[prost(string, tag = "5")] + pub email: ::prost::alloc::string::String, + /// Optional. A user-specified name for the service account. + /// Must be less than or equal to 100 UTF-8 bytes. + #[prost(string, tag = "6")] + pub display_name: ::prost::alloc::string::String, + /// Optional. Note: `etag` is an inoperable legacy field that is only returned + /// for backwards compatibility. + #[prost(bytes = "vec", tag = "7")] + pub etag: ::prost::alloc::vec::Vec, + /// @OutputOnly. The OAuth2 client id for the service account. + /// This is used in conjunction with the OAuth2 clientconfig API to make + /// three legged OAuth2 (3LO) flows to access the data of Google users. + #[prost(string, tag = "9")] + pub oauth2_client_id: ::prost::alloc::string::String, +} +/// The service account create request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CreateServiceAccountRequest { + /// Required. The resource name of the project associated with the service + /// accounts, such as `projects/my-project-123`. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Required. The account id that is used to generate the service account + /// email address and a stable unique id. It is unique within a project, + /// must be 6-30 characters long, and match the regular expression + /// `[a-z](\[-a-z0-9\]*[a-z0-9])` to comply with RFC1035. + #[prost(string, tag = "2")] + pub account_id: ::prost::alloc::string::String, + /// The \[ServiceAccount\]\[google.iam.admin.v1.ServiceAccount\] resource to + /// create. Currently, only the following values are user assignable: + /// `display_name` and `description`. + #[prost(message, optional, tag = "3")] + pub service_account: ::core::option::Option, +} +/// The service account list request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ListServiceAccountsRequest { + /// Required. The resource name of the project associated with the service + /// accounts, such as `projects/my-project-123`. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Optional limit on the number of service accounts to include in the + /// response. Further accounts can subsequently be obtained by including the + /// \[ListServiceAccountsResponse.next_page_token\]\[google.iam.admin.v1.ListServiceAccountsResponse.next_page_token\] + /// in a subsequent request. + #[prost(int32, tag = "2")] + pub page_size: i32, + /// Optional pagination token returned in an earlier + /// \[ListServiceAccountsResponse.next_page_token\]\[google.iam.admin.v1.ListServiceAccountsResponse.next_page_token\]. + #[prost(string, tag = "3")] + pub page_token: ::prost::alloc::string::String, +} +/// The service account list response. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListServiceAccountsResponse { + /// The list of matching service accounts. + #[prost(message, repeated, tag = "1")] + pub accounts: ::prost::alloc::vec::Vec, + /// To retrieve the next page of results, set + /// \[ListServiceAccountsRequest.page_token\]\[google.iam.admin.v1.ListServiceAccountsRequest.page_token\] + /// to this value. + #[prost(string, tag = "2")] + pub next_page_token: ::prost::alloc::string::String, +} +/// The service account get request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetServiceAccountRequest { + /// Required. The resource name of the service account in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. + /// Using `-` as a wildcard for the `PROJECT_ID` will infer the project from + /// the account. The `ACCOUNT` value can be the `email` address or the + /// `unique_id` of the service account. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// The service account delete request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DeleteServiceAccountRequest { + /// Required. The resource name of the service account in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. + /// Using `-` as a wildcard for the `PROJECT_ID` will infer the project from + /// the account. The `ACCOUNT` value can be the `email` address or the + /// `unique_id` of the service account. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// The service account keys list request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ListServiceAccountKeysRequest { + /// Required. The resource name of the service account in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. + /// + /// Using `-` as a wildcard for the `PROJECT_ID`, will infer the project from + /// the account. The `ACCOUNT` value can be the `email` address or the + /// `unique_id` of the service account. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Filters the types of keys the user wants to include in the list + /// response. Duplicate key types are not allowed. If no key type + /// is provided, all keys are returned. + #[prost( + enumeration = "list_service_account_keys_request::KeyType", + repeated, + tag = "2" + )] + pub key_types: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `ListServiceAccountKeysRequest`. +pub mod list_service_account_keys_request { + /// `KeyType` filters to selectively retrieve certain varieties + /// of keys. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum KeyType { + /// Unspecified key type. The presence of this in the + /// message will immediately result in an error. + Unspecified = 0, + /// User-managed keys (managed and rotated by the user). + UserManaged = 1, + /// System-managed keys (managed and rotated by Google). + SystemManaged = 2, + } + impl KeyType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "KEY_TYPE_UNSPECIFIED", + Self::UserManaged => "USER_MANAGED", + Self::SystemManaged => "SYSTEM_MANAGED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "KEY_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "USER_MANAGED" => Some(Self::UserManaged), + "SYSTEM_MANAGED" => Some(Self::SystemManaged), + _ => None, + } + } + } +} +/// The service account keys list response. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListServiceAccountKeysResponse { + /// The public keys for the service account. + #[prost(message, repeated, tag = "1")] + pub keys: ::prost::alloc::vec::Vec, +} +/// The service account key get by id request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetServiceAccountKeyRequest { + /// Required. The resource name of the service account key in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}/keys/{key}`. + /// + /// Using `-` as a wildcard for the `PROJECT_ID` will infer the project from + /// the account. The `ACCOUNT` value can be the `email` address or the + /// `unique_id` of the service account. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The output format of the public key requested. + /// X509_PEM is the default output format. + #[prost(enumeration = "ServiceAccountPublicKeyType", tag = "2")] + pub public_key_type: i32, +} +/// Represents a service account key. +/// +/// A service account has two sets of key-pairs: user-managed, and +/// system-managed. +/// +/// User-managed key-pairs can be created and deleted by users. Users are +/// responsible for rotating these keys periodically to ensure security of +/// their service accounts. Users retain the private key of these key-pairs, +/// and Google retains ONLY the public key. +/// +/// System-managed keys are automatically rotated by Google, and are used for +/// signing for a maximum of two weeks. The rotation process is probabilistic, +/// and usage of the new key will gradually ramp up and down over the key's +/// lifetime. We recommend caching the public key set for a service account for +/// no more than 24 hours to ensure you have access to the latest keys. +/// +/// Public keys for all service accounts are also published at the OAuth2 +/// Service Account API. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ServiceAccountKey { + /// The resource name of the service account key in the following format + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}/keys/{key}`. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The output format for the private key. + /// Only provided in `CreateServiceAccountKey` responses, not + /// in `GetServiceAccountKey` or `ListServiceAccountKey` responses. + /// + /// Google never exposes system-managed private keys, and never retains + /// user-managed private keys. + #[prost(enumeration = "ServiceAccountPrivateKeyType", tag = "2")] + pub private_key_type: i32, + /// Specifies the algorithm (and possibly key size) for the key. + #[prost(enumeration = "ServiceAccountKeyAlgorithm", tag = "8")] + pub key_algorithm: i32, + /// The private key data. Only provided in `CreateServiceAccountKey` + /// responses. Make sure to keep the private key data secure because it + /// allows for the assertion of the service account identity. + /// When base64 decoded, the private key data can be used to authenticate with + /// Google API client libraries and with + /// gcloud + /// auth activate-service-account. + #[prost(bytes = "vec", tag = "3")] + pub private_key_data: ::prost::alloc::vec::Vec, + /// The public key data. Only provided in `GetServiceAccountKey` responses. + #[prost(bytes = "vec", tag = "7")] + pub public_key_data: ::prost::alloc::vec::Vec, + /// The key can be used after this timestamp. + #[prost(message, optional, tag = "4")] + pub valid_after_time: ::core::option::Option<::prost_types::Timestamp>, + /// The key can be used before this timestamp. + /// For system-managed key pairs, this timestamp is the end time for the + /// private key signing operation. The public key could still be used + /// for verification for a few hours after this time. + #[prost(message, optional, tag = "5")] + pub valid_before_time: ::core::option::Option<::prost_types::Timestamp>, +} +/// The service account key create request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CreateServiceAccountKeyRequest { + /// Required. The resource name of the service account in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. + /// Using `-` as a wildcard for the `PROJECT_ID` will infer the project from + /// the account. The `ACCOUNT` value can be the `email` address or the + /// `unique_id` of the service account. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The output format of the private key. The default value is + /// `TYPE_GOOGLE_CREDENTIALS_FILE`, which is the Google Credentials File + /// format. + #[prost(enumeration = "ServiceAccountPrivateKeyType", tag = "2")] + pub private_key_type: i32, + /// Which type of key and algorithm to use for the key. + /// The default is currently a 2K RSA key. However this may change in the + /// future. + #[prost(enumeration = "ServiceAccountKeyAlgorithm", tag = "3")] + pub key_algorithm: i32, +} +/// The service account key delete request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DeleteServiceAccountKeyRequest { + /// Required. The resource name of the service account key in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}/keys/{key}`. + /// Using `-` as a wildcard for the `PROJECT_ID` will infer the project from + /// the account. The `ACCOUNT` value can be the `email` address or the + /// `unique_id` of the service account. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// The service account sign blob request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SignBlobRequest { + /// Required. The resource name of the service account in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. + /// Using `-` as a wildcard for the `PROJECT_ID` will infer the project from + /// the account. The `ACCOUNT` value can be the `email` address or the + /// `unique_id` of the service account. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Required. The bytes to sign. + #[prost(bytes = "vec", tag = "2")] + pub bytes_to_sign: ::prost::alloc::vec::Vec, +} +/// The service account sign blob response. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SignBlobResponse { + /// The id of the key used to sign the blob. + #[prost(string, tag = "1")] + pub key_id: ::prost::alloc::string::String, + /// The signed blob. + #[prost(bytes = "vec", tag = "2")] + pub signature: ::prost::alloc::vec::Vec, +} +/// The service account sign JWT request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SignJwtRequest { + /// Required. The resource name of the service account in the following format: + /// `projects/{PROJECT_ID}/serviceAccounts/{ACCOUNT}`. + /// Using `-` as a wildcard for the `PROJECT_ID` will infer the project from + /// the account. The `ACCOUNT` value can be the `email` address or the + /// `unique_id` of the service account. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Required. The JWT payload to sign, a JSON JWT Claim set. + #[prost(string, tag = "2")] + pub payload: ::prost::alloc::string::String, +} +/// The service account sign JWT response. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct SignJwtResponse { + /// The id of the key used to sign the JWT. + #[prost(string, tag = "1")] + pub key_id: ::prost::alloc::string::String, + /// The signed JWT. + #[prost(string, tag = "2")] + pub signed_jwt: ::prost::alloc::string::String, +} +/// A role in the Identity and Access Management API. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Role { + /// The name of the role. + /// + /// When Role is used in CreateRole, the role name must not be set. + /// + /// When Role is used in output and other input such as UpdateRole, the role + /// name is the complete path, e.g., roles/logging.viewer for predefined roles + /// and organizations/{ORGANIZATION_ID}/roles/logging.viewer for custom roles. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Optional. A human-readable title for the role. Typically this + /// is limited to 100 UTF-8 bytes. + #[prost(string, tag = "2")] + pub title: ::prost::alloc::string::String, + /// Optional. A human-readable description for the role. + #[prost(string, tag = "3")] + pub description: ::prost::alloc::string::String, + /// The names of the permissions this role grants when bound in an IAM policy. + #[prost(string, repeated, tag = "7")] + pub included_permissions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The current launch stage of the role. If the `ALPHA` launch stage has been + /// selected for a role, the `stage` field will not be included in the + /// returned definition for the role. + #[prost(enumeration = "role::RoleLaunchStage", tag = "8")] + pub stage: i32, + /// Used to perform a consistent read-modify-write. + #[prost(bytes = "vec", tag = "9")] + pub etag: ::prost::alloc::vec::Vec, + /// The current deleted state of the role. This field is read only. + /// It will be ignored in calls to CreateRole and UpdateRole. + #[prost(bool, tag = "11")] + pub deleted: bool, +} +/// Nested message and enum types in `Role`. +pub mod role { + /// A stage representing a role's lifecycle phase. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum RoleLaunchStage { + /// The user has indicated this role is currently in an Alpha phase. If this + /// launch stage is selected, the `stage` field will not be included when + /// requesting the definition for a given role. + Alpha = 0, + /// The user has indicated this role is currently in a Beta phase. + Beta = 1, + /// The user has indicated this role is generally available. + Ga = 2, + /// The user has indicated this role is being deprecated. + Deprecated = 4, + /// This role is disabled and will not contribute permissions to any members + /// it is granted to in policies. + Disabled = 5, + /// The user has indicated this role is currently in an EAP phase. + Eap = 6, + } + impl RoleLaunchStage { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Alpha => "ALPHA", + Self::Beta => "BETA", + Self::Ga => "GA", + Self::Deprecated => "DEPRECATED", + Self::Disabled => "DISABLED", + Self::Eap => "EAP", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ALPHA" => Some(Self::Alpha), + "BETA" => Some(Self::Beta), + "GA" => Some(Self::Ga), + "DEPRECATED" => Some(Self::Deprecated), + "DISABLED" => Some(Self::Disabled), + "EAP" => Some(Self::Eap), + _ => None, + } + } + } +} +/// The grantable role query request. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct QueryGrantableRolesRequest { + /// Required. The full resource name to query from the list of grantable roles. + /// + /// The name follows the Google Cloud Platform resource format. + /// For example, a Cloud Platform project with id `my-project` will be named + /// `//cloudresourcemanager.googleapis.com/projects/my-project`. + #[prost(string, tag = "1")] + pub full_resource_name: ::prost::alloc::string::String, + #[prost(enumeration = "RoleView", tag = "2")] + pub view: i32, + /// Optional limit on the number of roles to include in the response. + #[prost(int32, tag = "3")] + pub page_size: i32, + /// Optional pagination token returned in an earlier + /// QueryGrantableRolesResponse. + #[prost(string, tag = "4")] + pub page_token: ::prost::alloc::string::String, +} +/// The grantable role query response. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryGrantableRolesResponse { + /// The list of matching roles. + #[prost(message, repeated, tag = "1")] + pub roles: ::prost::alloc::vec::Vec, + /// To retrieve the next page of results, set + /// `QueryGrantableRolesRequest.page_token` to this value. + #[prost(string, tag = "2")] + pub next_page_token: ::prost::alloc::string::String, +} +/// The request to get all roles defined under a resource. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ListRolesRequest { + /// The `parent` parameter's value depends on the target resource for the + /// request, namely + /// [`roles`](/iam/reference/rest/v1/roles), + /// [`projects`](/iam/reference/rest/v1/projects.roles), or + /// [`organizations`](/iam/reference/rest/v1/organizations.roles). Each + /// resource type's `parent` value format is described below: + /// + /// * [`roles.list()`](/iam/reference/rest/v1/roles/list): An empty string. + /// This method doesn't require a resource; it simply returns all + /// [predefined roles](/iam/docs/understanding-roles#predefined_roles) in + /// Cloud IAM. Example request URL: + /// ` + /// + /// * [`projects.roles.list()`](/iam/reference/rest/v1/projects.roles/list): + /// `projects/{PROJECT_ID}`. This method lists all project-level + /// [custom roles](/iam/docs/understanding-custom-roles). + /// Example request URL: + /// ` + /// + /// * [`organizations.roles.list()`](/iam/reference/rest/v1/organizations.roles/list): + /// `organizations/{ORGANIZATION_ID}`. This method lists all + /// organization-level [custom roles](/iam/docs/understanding-custom-roles). + /// Example request URL: + /// ` + /// + /// Note: Wildcard (\*) values are invalid; you must specify a complete project + /// ID or organization ID. + #[prost(string, tag = "1")] + pub parent: ::prost::alloc::string::String, + /// Optional limit on the number of roles to include in the response. + #[prost(int32, tag = "2")] + pub page_size: i32, + /// Optional pagination token returned in an earlier ListRolesResponse. + #[prost(string, tag = "3")] + pub page_token: ::prost::alloc::string::String, + /// Optional view for the returned Role objects. When `FULL` is specified, + /// the `includedPermissions` field is returned, which includes a list of all + /// permissions in the role. The default value is `BASIC`, which does not + /// return the `includedPermissions` field. + #[prost(enumeration = "RoleView", tag = "4")] + pub view: i32, + /// Include Roles that have been deleted. + #[prost(bool, tag = "6")] + pub show_deleted: bool, +} +/// The response containing the roles defined under a resource. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListRolesResponse { + /// The Roles defined on this resource. + #[prost(message, repeated, tag = "1")] + pub roles: ::prost::alloc::vec::Vec, + /// To retrieve the next page of results, set + /// `ListRolesRequest.page_token` to this value. + #[prost(string, tag = "2")] + pub next_page_token: ::prost::alloc::string::String, +} +/// The request to get the definition of an existing role. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetRoleRequest { + /// The `name` parameter's value depends on the target resource for the + /// request, namely + /// [`roles`](/iam/reference/rest/v1/roles), + /// [`projects`](/iam/reference/rest/v1/projects.roles), or + /// [`organizations`](/iam/reference/rest/v1/organizations.roles). Each + /// resource type's `name` value format is described below: + /// + /// * [`roles.get()`](/iam/reference/rest/v1/roles/get): `roles/{ROLE_NAME}`. + /// This method returns results from all + /// [predefined roles](/iam/docs/understanding-roles#predefined_roles) in + /// Cloud IAM. Example request URL: + /// ` + /// + /// * [`projects.roles.get()`](/iam/reference/rest/v1/projects.roles/get): + /// `projects/{PROJECT_ID}/roles/{CUSTOM_ROLE_ID}`. This method returns only + /// [custom roles](/iam/docs/understanding-custom-roles) that have been + /// created at the project level. Example request URL: + /// ` + /// + /// * [`organizations.roles.get()`](/iam/reference/rest/v1/organizations.roles/get): + /// `organizations/{ORGANIZATION_ID}/roles/{CUSTOM_ROLE_ID}`. This method + /// returns only [custom roles](/iam/docs/understanding-custom-roles) that + /// have been created at the organization level. Example request URL: + /// ` + /// + /// Note: Wildcard (\*) values are invalid; you must specify a complete project + /// ID or organization ID. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// The request to create a new role. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CreateRoleRequest { + /// The `parent` parameter's value depends on the target resource for the + /// request, namely + /// [`projects`](/iam/reference/rest/v1/projects.roles) or + /// [`organizations`](/iam/reference/rest/v1/organizations.roles). Each + /// resource type's `parent` value format is described below: + /// + /// * [`projects.roles.create()`](/iam/reference/rest/v1/projects.roles/create): + /// `projects/{PROJECT_ID}`. This method creates project-level + /// [custom roles](/iam/docs/understanding-custom-roles). + /// Example request URL: + /// ` + /// + /// * [`organizations.roles.create()`](/iam/reference/rest/v1/organizations.roles/create): + /// `organizations/{ORGANIZATION_ID}`. This method creates organization-level + /// [custom roles](/iam/docs/understanding-custom-roles). Example request + /// URL: + /// ` + /// + /// Note: Wildcard (\*) values are invalid; you must specify a complete project + /// ID or organization ID. + #[prost(string, tag = "1")] + pub parent: ::prost::alloc::string::String, + /// The role ID to use for this role. + #[prost(string, tag = "2")] + pub role_id: ::prost::alloc::string::String, + /// The Role resource to create. + #[prost(message, optional, tag = "3")] + pub role: ::core::option::Option, +} +/// The request to update a role. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UpdateRoleRequest { + /// The `name` parameter's value depends on the target resource for the + /// request, namely + /// [`projects`](/iam/reference/rest/v1/projects.roles) or + /// [`organizations`](/iam/reference/rest/v1/organizations.roles). Each + /// resource type's `name` value format is described below: + /// + /// * [`projects.roles.patch()`](/iam/reference/rest/v1/projects.roles/patch): + /// `projects/{PROJECT_ID}/roles/{CUSTOM_ROLE_ID}`. This method updates only + /// [custom roles](/iam/docs/understanding-custom-roles) that have been + /// created at the project level. Example request URL: + /// ` + /// + /// * [`organizations.roles.patch()`](/iam/reference/rest/v1/organizations.roles/patch): + /// `organizations/{ORGANIZATION_ID}/roles/{CUSTOM_ROLE_ID}`. This method + /// updates only [custom roles](/iam/docs/understanding-custom-roles) that + /// have been created at the organization level. Example request URL: + /// ` + /// + /// Note: Wildcard (\*) values are invalid; you must specify a complete project + /// ID or organization ID. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The updated role. + #[prost(message, optional, tag = "2")] + pub role: ::core::option::Option, + /// A mask describing which fields in the Role have changed. + #[prost(message, optional, tag = "3")] + pub update_mask: ::core::option::Option<::prost_types::FieldMask>, +} +/// The request to delete an existing role. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DeleteRoleRequest { + /// The `name` parameter's value depends on the target resource for the + /// request, namely + /// [`projects`](/iam/reference/rest/v1/projects.roles) or + /// [`organizations`](/iam/reference/rest/v1/organizations.roles). Each + /// resource type's `name` value format is described below: + /// + /// * [`projects.roles.delete()`](/iam/reference/rest/v1/projects.roles/delete): + /// `projects/{PROJECT_ID}/roles/{CUSTOM_ROLE_ID}`. This method deletes only + /// [custom roles](/iam/docs/understanding-custom-roles) that have been + /// created at the project level. Example request URL: + /// ` + /// + /// * [`organizations.roles.delete()`](/iam/reference/rest/v1/organizations.roles/delete): + /// `organizations/{ORGANIZATION_ID}/roles/{CUSTOM_ROLE_ID}`. This method + /// deletes only [custom roles](/iam/docs/understanding-custom-roles) that + /// have been created at the organization level. Example request URL: + /// ` + /// + /// Note: Wildcard (\*) values are invalid; you must specify a complete project + /// ID or organization ID. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Used to perform a consistent read-modify-write. + #[prost(bytes = "vec", tag = "2")] + pub etag: ::prost::alloc::vec::Vec, +} +/// The request to undelete an existing role. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct UndeleteRoleRequest { + /// The `name` parameter's value depends on the target resource for the + /// request, namely + /// [`projects`](/iam/reference/rest/v1/projects.roles) or + /// [`organizations`](/iam/reference/rest/v1/organizations.roles). Each + /// resource type's `name` value format is described below: + /// + /// * [`projects.roles.undelete()`](/iam/reference/rest/v1/projects.roles/undelete): + /// `projects/{PROJECT_ID}/roles/{CUSTOM_ROLE_ID}`. This method undeletes + /// only [custom roles](/iam/docs/understanding-custom-roles) that have been + /// created at the project level. Example request URL: + /// ` + /// + /// * [`organizations.roles.undelete()`](/iam/reference/rest/v1/organizations.roles/undelete): + /// `organizations/{ORGANIZATION_ID}/roles/{CUSTOM_ROLE_ID}`. This method + /// undeletes only [custom roles](/iam/docs/understanding-custom-roles) that + /// have been created at the organization level. Example request URL: + /// ` + /// + /// Note: Wildcard (\*) values are invalid; you must specify a complete project + /// ID or organization ID. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Used to perform a consistent read-modify-write. + #[prost(bytes = "vec", tag = "2")] + pub etag: ::prost::alloc::vec::Vec, +} +/// A permission which can be included by a role. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Permission { + /// The name of this Permission. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The title of this Permission. + #[prost(string, tag = "2")] + pub title: ::prost::alloc::string::String, + /// A brief description of what this Permission is used for. + /// This permission can ONLY be used in predefined roles. + #[prost(string, tag = "3")] + pub description: ::prost::alloc::string::String, + /// This permission can ONLY be used in predefined roles. + #[prost(bool, tag = "4")] + pub only_in_predefined_roles: bool, + /// The current launch stage of the permission. + #[prost(enumeration = "permission::PermissionLaunchStage", tag = "5")] + pub stage: i32, + /// The current custom role support level. + #[prost(enumeration = "permission::CustomRolesSupportLevel", tag = "6")] + pub custom_roles_support_level: i32, +} +/// Nested message and enum types in `Permission`. +pub mod permission { + /// A stage representing a permission's lifecycle phase. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum PermissionLaunchStage { + /// The permission is currently in an alpha phase. + Alpha = 0, + /// The permission is currently in a beta phase. + Beta = 1, + /// The permission is generally available. + Ga = 2, + /// The permission is being deprecated. + Deprecated = 3, + } + impl PermissionLaunchStage { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Alpha => "ALPHA", + Self::Beta => "BETA", + Self::Ga => "GA", + Self::Deprecated => "DEPRECATED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ALPHA" => Some(Self::Alpha), + "BETA" => Some(Self::Beta), + "GA" => Some(Self::Ga), + "DEPRECATED" => Some(Self::Deprecated), + _ => None, + } + } + } + /// The state of the permission with regards to custom roles. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum CustomRolesSupportLevel { + /// Permission is fully supported for custom role use. + Supported = 0, + /// Permission is being tested to check custom role compatibility. + Testing = 1, + /// Permission is not supported for custom role use. + NotSupported = 2, + } + impl CustomRolesSupportLevel { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Supported => "SUPPORTED", + Self::Testing => "TESTING", + Self::NotSupported => "NOT_SUPPORTED", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "SUPPORTED" => Some(Self::Supported), + "TESTING" => Some(Self::Testing), + "NOT_SUPPORTED" => Some(Self::NotSupported), + _ => None, + } + } + } +} +/// A request to get permissions which can be tested on a resource. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct QueryTestablePermissionsRequest { + /// Required. The full resource name to query from the list of testable + /// permissions. + /// + /// The name follows the Google Cloud Platform resource format. + /// For example, a Cloud Platform project with id `my-project` will be named + /// `//cloudresourcemanager.googleapis.com/projects/my-project`. + #[prost(string, tag = "1")] + pub full_resource_name: ::prost::alloc::string::String, + /// Optional limit on the number of permissions to include in the response. + #[prost(int32, tag = "2")] + pub page_size: i32, + /// Optional pagination token returned in an earlier + /// QueryTestablePermissionsRequest. + #[prost(string, tag = "3")] + pub page_token: ::prost::alloc::string::String, +} +/// The response containing permissions which can be tested on a resource. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QueryTestablePermissionsResponse { + /// The Permissions testable on the requested resource. + #[prost(message, repeated, tag = "1")] + pub permissions: ::prost::alloc::vec::Vec, + /// To retrieve the next page of results, set + /// `QueryTestableRolesRequest.page_token` to this value. + #[prost(string, tag = "2")] + pub next_page_token: ::prost::alloc::string::String, +} +/// Supported key algorithms. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ServiceAccountKeyAlgorithm { + /// An unspecified key algorithm. + KeyAlgUnspecified = 0, + /// 1k RSA Key. + KeyAlgRsa1024 = 1, + /// 2k RSA Key. + KeyAlgRsa2048 = 2, +} +impl ServiceAccountKeyAlgorithm { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::KeyAlgUnspecified => "KEY_ALG_UNSPECIFIED", + Self::KeyAlgRsa1024 => "KEY_ALG_RSA_1024", + Self::KeyAlgRsa2048 => "KEY_ALG_RSA_2048", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "KEY_ALG_UNSPECIFIED" => Some(Self::KeyAlgUnspecified), + "KEY_ALG_RSA_1024" => Some(Self::KeyAlgRsa1024), + "KEY_ALG_RSA_2048" => Some(Self::KeyAlgRsa2048), + _ => None, + } + } +} +/// Supported private key output formats. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ServiceAccountPrivateKeyType { + /// Unspecified. Equivalent to `TYPE_GOOGLE_CREDENTIALS_FILE`. + TypeUnspecified = 0, + /// PKCS12 format. + /// The password for the PKCS12 file is `notasecret`. + /// For more information, see + TypePkcs12File = 1, + /// Google Credentials File format. + TypeGoogleCredentialsFile = 2, +} +impl ServiceAccountPrivateKeyType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::TypeUnspecified => "TYPE_UNSPECIFIED", + Self::TypePkcs12File => "TYPE_PKCS12_FILE", + Self::TypeGoogleCredentialsFile => "TYPE_GOOGLE_CREDENTIALS_FILE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TYPE_UNSPECIFIED" => Some(Self::TypeUnspecified), + "TYPE_PKCS12_FILE" => Some(Self::TypePkcs12File), + "TYPE_GOOGLE_CREDENTIALS_FILE" => Some(Self::TypeGoogleCredentialsFile), + _ => None, + } + } +} +/// Supported public key output formats. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ServiceAccountPublicKeyType { + /// Unspecified. Returns nothing here. + TypeNone = 0, + /// X509 PEM format. + TypeX509PemFile = 1, + /// Raw public key. + TypeRawPublicKey = 2, +} +impl ServiceAccountPublicKeyType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::TypeNone => "TYPE_NONE", + Self::TypeX509PemFile => "TYPE_X509_PEM_FILE", + Self::TypeRawPublicKey => "TYPE_RAW_PUBLIC_KEY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "TYPE_NONE" => Some(Self::TypeNone), + "TYPE_X509_PEM_FILE" => Some(Self::TypeX509PemFile), + "TYPE_RAW_PUBLIC_KEY" => Some(Self::TypeRawPublicKey), + _ => None, + } + } +} +/// A view for Role objects. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum RoleView { + /// Omits the `included_permissions` field. + /// This is the default value. + Basic = 0, + /// Returns all fields. + Full = 1, +} +impl RoleView { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Basic => "BASIC", + Self::Full => "FULL", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "BASIC" => Some(Self::Basic), + "FULL" => Some(Self::Full), + _ => None, + } + } +} diff --git a/prost-googleapis/src/google/iam/mod.rs b/prost-googleapis/src/google/iam/mod.rs new file mode 100644 index 000000000..fa0c4fbdd --- /dev/null +++ b/prost-googleapis/src/google/iam/mod.rs @@ -0,0 +1,2 @@ +pub mod admin; +pub mod v1; diff --git a/prost-googleapis/src/google/iam/v1/logging/mod.rs b/prost-googleapis/src/google/iam/v1/logging/mod.rs new file mode 100644 index 000000000..713d090de --- /dev/null +++ b/prost-googleapis/src/google/iam/v1/logging/mod.rs @@ -0,0 +1,10 @@ +// This file is @generated by prost-build. +/// Audit log information specific to Cloud IAM. This message is serialized +/// as an `Any` type in the `ServiceData` message of an +/// `AuditLog` message. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AuditData { + /// Policy delta between the original policy and the newly set policy. + #[prost(message, optional, tag = "2")] + pub policy_delta: ::core::option::Option, +} diff --git a/prost-googleapis/src/google/iam/v1/mod.rs b/prost-googleapis/src/google/iam/v1/mod.rs new file mode 100644 index 000000000..25eef4273 --- /dev/null +++ b/prost-googleapis/src/google/iam/v1/mod.rs @@ -0,0 +1,348 @@ +pub mod logging; + +// This file is @generated by prost-build. +/// Encapsulates settings provided to GetIamPolicy. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetPolicyOptions { + /// Optional. The policy format version to be returned. + /// + /// Valid values are 0, 1, and 3. Requests specifying an invalid value will be + /// rejected. + /// + /// Requests for policies with any conditional bindings must specify version 3. + /// Policies without any conditional bindings may specify any valid value or + /// leave the field unset. + #[prost(int32, tag = "1")] + pub requested_policy_version: i32, +} +/// Defines an Identity and Access Management (IAM) policy. It is used to +/// specify access control policies for Cloud Platform resources. +/// +/// A `Policy` is a collection of `bindings`. A `binding` binds one or more +/// `members` to a single `role`. Members can be user accounts, service accounts, +/// Google groups, and domains (such as G Suite). A `role` is a named list of +/// permissions (defined by IAM or configured by users). A `binding` can +/// optionally specify a `condition`, which is a logic expression that further +/// constrains the role binding based on attributes about the request and/or +/// target resource. +/// +/// **JSON Example** +/// +/// ```text +/// { +/// "bindings": [ +/// { +/// "role": "roles/resourcemanager.organizationAdmin", +/// "members": [ +/// "user:mike@example.com", +/// "group:admins@example.com", +/// "domain:google.com", +/// "serviceAccount:my-project-id@appspot.gserviceaccount.com" +/// ] +/// }, +/// { +/// "role": "roles/resourcemanager.organizationViewer", +/// "members": \["user:eve@example.com"\], +/// "condition": { +/// "title": "expirable access", +/// "description": "Does not grant access after Sep 2020", +/// "expression": "request.time < +/// timestamp('2020-10-01T00:00:00.000Z')", +/// } +/// } +/// ] +/// } +/// ``` +/// +/// **YAML Example** +/// +/// ```text +/// bindings: +/// - members: +/// - user:mike@example.com +/// - group:admins@example.com +/// - domain:google.com +/// - serviceAccount:my-project-id@appspot.gserviceaccount.com +/// role: roles/resourcemanager.organizationAdmin +/// - members: +/// - user:eve@example.com +/// role: roles/resourcemanager.organizationViewer +/// condition: +/// title: expirable access +/// description: Does not grant access after Sep 2020 +/// expression: request.time < timestamp('2020-10-01T00:00:00.000Z') +/// ``` +/// +/// For a description of IAM and its features, see the +/// [IAM developer's guide](). +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Policy { + /// Specifies the format of the policy. + /// + /// Valid values are 0, 1, and 3. Requests specifying an invalid value will be + /// rejected. + /// + /// Operations affecting conditional bindings must specify version 3. This can + /// be either setting a conditional policy, modifying a conditional binding, + /// or removing a binding (conditional or unconditional) from the stored + /// conditional policy. + /// Operations on non-conditional policies may specify any valid value or + /// leave the field unset. + /// + /// If no etag is provided in the call to `setIamPolicy`, version compliance + /// checks against the stored policy is skipped. + #[prost(int32, tag = "1")] + pub version: i32, + /// Associates a list of `members` to a `role`. Optionally may specify a + /// `condition` that determines when binding is in effect. + /// `bindings` with no members will result in an error. + #[prost(message, repeated, tag = "4")] + pub bindings: ::prost::alloc::vec::Vec, + /// `etag` is used for optimistic concurrency control as a way to help + /// prevent simultaneous updates of a policy from overwriting each other. + /// It is strongly suggested that systems make use of the `etag` in the + /// read-modify-write cycle to perform policy updates in order to avoid race + /// conditions: An `etag` is returned in the response to `getIamPolicy`, and + /// systems are expected to put that etag in the request to `setIamPolicy` to + /// ensure that their change will be applied to the same version of the policy. + /// + /// If no `etag` is provided in the call to `setIamPolicy`, then the existing + /// policy is overwritten. Due to blind-set semantics of an etag-less policy, + /// 'setIamPolicy' will not fail even if the incoming policy version does not + /// meet the requirements for modifying the stored policy. + #[prost(bytes = "vec", tag = "3")] + pub etag: ::prost::alloc::vec::Vec, +} +/// Associates `members` with a `role`. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Binding { + /// Role that is assigned to `members`. + /// For example, `roles/viewer`, `roles/editor`, or `roles/owner`. + #[prost(string, tag = "1")] + pub role: ::prost::alloc::string::String, + /// Specifies the identities requesting access for a Cloud Platform resource. + /// `members` can have the following values: + /// + /// * `allUsers`: A special identifier that represents anyone who is + /// on the internet; with or without a Google account. + /// + /// * `allAuthenticatedUsers`: A special identifier that represents anyone + /// who is authenticated with a Google account or a service account. + /// + /// * `user:{emailid}`: An email address that represents a specific Google + /// account. For example, `alice@example.com` . + /// + /// * `serviceAccount:{emailid}`: An email address that represents a service + /// account. For example, `my-other-app@appspot.gserviceaccount.com`. + /// + /// * `group:{emailid}`: An email address that represents a Google group. + /// For example, `admins@example.com`. + /// + /// * `domain:{domain}`: The G Suite domain (primary) that represents all the + /// users of that domain. For example, `google.com` or `example.com`. + #[prost(string, repeated, tag = "2")] + pub members: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The condition that is associated with this binding. + /// NOTE: An unsatisfied condition will not allow user access via current + /// binding. Different bindings, including their conditions, are examined + /// independently. + #[prost(message, optional, tag = "3")] + pub condition: ::core::option::Option, +} +/// The difference delta between two policies. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PolicyDelta { + /// The delta for Bindings between two policies. + #[prost(message, repeated, tag = "1")] + pub binding_deltas: ::prost::alloc::vec::Vec, + /// The delta for AuditConfigs between two policies. + #[prost(message, repeated, tag = "2")] + pub audit_config_deltas: ::prost::alloc::vec::Vec, +} +/// One delta entry for Binding. Each individual change (only one member in each +/// entry) to a binding will be a separate entry. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct BindingDelta { + /// The action that was performed on a Binding. + /// Required + #[prost(enumeration = "binding_delta::Action", tag = "1")] + pub action: i32, + /// Role that is assigned to `members`. + /// For example, `roles/viewer`, `roles/editor`, or `roles/owner`. + /// Required + #[prost(string, tag = "2")] + pub role: ::prost::alloc::string::String, + /// A single identity requesting access for a Cloud Platform resource. + /// Follows the same format of Binding.members. + /// Required + #[prost(string, tag = "3")] + pub member: ::prost::alloc::string::String, + /// The condition that is associated with this binding. + #[prost(message, optional, tag = "4")] + pub condition: ::core::option::Option, +} +/// Nested message and enum types in `BindingDelta`. +pub mod binding_delta { + /// The type of action performed on a Binding in a policy. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Action { + /// Unspecified. + Unspecified = 0, + /// Addition of a Binding. + Add = 1, + /// Removal of a Binding. + Remove = 2, + } + impl Action { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "ACTION_UNSPECIFIED", + Self::Add => "ADD", + Self::Remove => "REMOVE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ACTION_UNSPECIFIED" => Some(Self::Unspecified), + "ADD" => Some(Self::Add), + "REMOVE" => Some(Self::Remove), + _ => None, + } + } + } +} +/// One delta entry for AuditConfig. Each individual change (only one +/// exempted_member in each entry) to a AuditConfig will be a separate entry. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct AuditConfigDelta { + /// The action that was performed on an audit configuration in a policy. + /// Required + #[prost(enumeration = "audit_config_delta::Action", tag = "1")] + pub action: i32, + /// Specifies a service that was configured for Cloud Audit Logging. + /// For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. + /// `allServices` is a special value that covers all services. + /// Required + #[prost(string, tag = "2")] + pub service: ::prost::alloc::string::String, + /// A single identity that is exempted from "data access" audit + /// logging for the `service` specified above. + /// Follows the same format of Binding.members. + #[prost(string, tag = "3")] + pub exempted_member: ::prost::alloc::string::String, + /// Specifies the log_type that was be enabled. ADMIN_ACTIVITY is always + /// enabled, and cannot be configured. + /// Required + #[prost(string, tag = "4")] + pub log_type: ::prost::alloc::string::String, +} +/// Nested message and enum types in `AuditConfigDelta`. +pub mod audit_config_delta { + /// The type of action performed on an audit configuration in a policy. + #[derive( + Clone, + Copy, + Debug, + PartialEq, + Eq, + Hash, + PartialOrd, + Ord, + ::prost::Enumeration + )] + #[repr(i32)] + pub enum Action { + /// Unspecified. + Unspecified = 0, + /// Addition of an audit configuration. + Add = 1, + /// Removal of an audit configuration. + Remove = 2, + } + impl Action { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "ACTION_UNSPECIFIED", + Self::Add => "ADD", + Self::Remove => "REMOVE", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "ACTION_UNSPECIFIED" => Some(Self::Unspecified), + "ADD" => Some(Self::Add), + "REMOVE" => Some(Self::Remove), + _ => None, + } + } + } +} +/// Request message for `SetIamPolicy` method. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct SetIamPolicyRequest { + /// REQUIRED: The resource for which the policy is being specified. + /// See the operation documentation for the appropriate value for this field. + #[prost(string, tag = "1")] + pub resource: ::prost::alloc::string::String, + /// REQUIRED: The complete policy to be applied to the `resource`. The size of + /// the policy is limited to a few 10s of KB. An empty policy is a + /// valid policy but certain Cloud Platform services (such as Projects) + /// might reject them. + #[prost(message, optional, tag = "2")] + pub policy: ::core::option::Option, +} +/// Request message for `GetIamPolicy` method. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetIamPolicyRequest { + /// REQUIRED: The resource for which the policy is being requested. + /// See the operation documentation for the appropriate value for this field. + #[prost(string, tag = "1")] + pub resource: ::prost::alloc::string::String, + /// OPTIONAL: A `GetPolicyOptions` object for specifying options to + /// `GetIamPolicy`. This field is only used by Cloud IAM. + #[prost(message, optional, tag = "2")] + pub options: ::core::option::Option, +} +/// Request message for `TestIamPermissions` method. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct TestIamPermissionsRequest { + /// REQUIRED: The resource for which the policy detail is being requested. + /// See the operation documentation for the appropriate value for this field. + #[prost(string, tag = "1")] + pub resource: ::prost::alloc::string::String, + /// The set of permissions to check for the `resource`. Permissions with + /// wildcards (such as '*' or 'storage.*') are not allowed. For more + /// information see + /// [IAM Overview](). + #[prost(string, repeated, tag = "2")] + pub permissions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +/// Response message for `TestIamPermissions` method. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct TestIamPermissionsResponse { + /// A subset of `TestPermissionsRequest.permissions` that the caller is + /// allowed. + #[prost(string, repeated, tag = "1")] + pub permissions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} diff --git a/prost-googleapis/src/google/logging/mod.rs b/prost-googleapis/src/google/logging/mod.rs new file mode 100644 index 000000000..6e146babe --- /dev/null +++ b/prost-googleapis/src/google/logging/mod.rs @@ -0,0 +1 @@ +pub mod r#type; diff --git a/prost-googleapis/src/google/logging/type/mod.rs b/prost-googleapis/src/google/logging/type/mod.rs new file mode 100644 index 000000000..049e0cbca --- /dev/null +++ b/prost-googleapis/src/google/logging/type/mod.rs @@ -0,0 +1,140 @@ +// This file is @generated by prost-build. +/// The severity of the event described in a log entry, expressed as one of the +/// standard severity levels listed below. For your reference, the levels are +/// assigned the listed numeric values. The effect of using numeric values other +/// than those listed is undefined. +/// +/// You can filter for log entries by severity. For example, the following +/// filter expression will match log entries with severities `INFO`, `NOTICE`, +/// and `WARNING`: +/// +/// ```text +/// severity > DEBUG AND severity <= WARNING +/// ``` +/// +/// If you are writing log entries, you should map other severity encodings to +/// one of these standard levels. For example, you might map all of Java's FINE, +/// FINER, and FINEST levels to `LogSeverity.DEBUG`. You can preserve the +/// original severity level in the log entry payload if you wish. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum LogSeverity { + /// (0) The log entry has no assigned severity level. + Default = 0, + /// (100) Debug or trace information. + Debug = 100, + /// (200) Routine information, such as ongoing status or performance. + Info = 200, + /// (300) Normal but significant events, such as start up, shut down, or + /// a configuration change. + Notice = 300, + /// (400) Warning events might cause problems. + Warning = 400, + /// (500) Error events are likely to cause problems. + Error = 500, + /// (600) Critical events cause more severe problems or outages. + Critical = 600, + /// (700) A person must take an action immediately. + Alert = 700, + /// (800) One or more systems are unusable. + Emergency = 800, +} +impl LogSeverity { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Default => "DEFAULT", + Self::Debug => "DEBUG", + Self::Info => "INFO", + Self::Notice => "NOTICE", + Self::Warning => "WARNING", + Self::Error => "ERROR", + Self::Critical => "CRITICAL", + Self::Alert => "ALERT", + Self::Emergency => "EMERGENCY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DEFAULT" => Some(Self::Default), + "DEBUG" => Some(Self::Debug), + "INFO" => Some(Self::Info), + "NOTICE" => Some(Self::Notice), + "WARNING" => Some(Self::Warning), + "ERROR" => Some(Self::Error), + "CRITICAL" => Some(Self::Critical), + "ALERT" => Some(Self::Alert), + "EMERGENCY" => Some(Self::Emergency), + _ => None, + } + } +} +/// A common proto for logging HTTP requests. Only contains semantics +/// defined by the HTTP specification. Product-specific logging +/// information MUST be defined in a separate message. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct HttpRequest { + /// The request method. Examples: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`. + #[prost(string, tag = "1")] + pub request_method: ::prost::alloc::string::String, + /// The scheme (http, https), the host name, the path and the query + /// portion of the URL that was requested. + /// Example: `" + #[prost(string, tag = "2")] + pub request_url: ::prost::alloc::string::String, + /// The size of the HTTP request message in bytes, including the request + /// headers and the request body. + #[prost(int64, tag = "3")] + pub request_size: i64, + /// The response code indicating the status of response. + /// Examples: 200, 404. + #[prost(int32, tag = "4")] + pub status: i32, + /// The size of the HTTP response message sent back to the client, in bytes, + /// including the response headers and the response body. + #[prost(int64, tag = "5")] + pub response_size: i64, + /// The user agent sent by the client. Example: + /// `"Mozilla/4.0 (compatible; MSIE 6.0; Windows 98; Q312461; .NET CLR 1.0.3705)"`. + #[prost(string, tag = "6")] + pub user_agent: ::prost::alloc::string::String, + /// The IP address (IPv4 or IPv6) of the client that issued the HTTP + /// request. Examples: `"192.168.1.1"`, `"FE80::0202:B3FF:FE1E:8329"`. + #[prost(string, tag = "7")] + pub remote_ip: ::prost::alloc::string::String, + /// The IP address (IPv4 or IPv6) of the origin server that the request was + /// sent to. + #[prost(string, tag = "13")] + pub server_ip: ::prost::alloc::string::String, + /// The referer URL of the request, as defined in + /// [HTTP/1.1 Header Field Definitions](). + #[prost(string, tag = "8")] + pub referer: ::prost::alloc::string::String, + /// The request processing latency on the server, from the time the request was + /// received until the response was sent. + #[prost(message, optional, tag = "14")] + pub latency: ::core::option::Option<::prost_types::Duration>, + /// Whether or not a cache lookup was attempted. + #[prost(bool, tag = "11")] + pub cache_lookup: bool, + /// Whether or not an entity was served from cache + /// (with or without validation). + #[prost(bool, tag = "9")] + pub cache_hit: bool, + /// Whether or not the response was validated with the origin server before + /// being served from cache. This field is only meaningful if `cache_hit` is + /// True. + #[prost(bool, tag = "10")] + pub cache_validated_with_origin_server: bool, + /// The number of HTTP response bytes inserted into cache. Set only when a + /// cache fill was attempted. + #[prost(int64, tag = "12")] + pub cache_fill_bytes: i64, + /// Protocol used for the request. Examples: "HTTP/1.1", "HTTP/2", "websocket" + #[prost(string, tag = "15")] + pub protocol: ::prost::alloc::string::String, +} diff --git a/prost-googleapis/src/google/longrunning/mod.rs b/prost-googleapis/src/google/longrunning/mod.rs new file mode 100644 index 000000000..7c245343b --- /dev/null +++ b/prost-googleapis/src/google/longrunning/mod.rs @@ -0,0 +1,141 @@ +// This file is @generated by prost-build. +/// This resource represents a long-running operation that is the result of a +/// network API call. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Operation { + /// The server-assigned name, which is only unique within the same service that + /// originally returns it. If you use the default HTTP mapping, the + /// `name` should be a resource name ending with `operations/{unique_id}`. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// Service-specific metadata associated with the operation. It typically + /// contains progress information and common metadata such as create time. + /// Some services might not provide such metadata. Any method that returns a + /// long-running operation should document the metadata type, if any. + #[prost(message, optional, tag = "2")] + pub metadata: ::core::option::Option<::prost_types::Any>, + /// If the value is `false`, it means the operation is still in progress. + /// If `true`, the operation is completed, and either `error` or `response` is + /// available. + #[prost(bool, tag = "3")] + pub done: bool, + /// The operation result, which can be either an `error` or a valid `response`. + /// If `done` == `false`, neither `error` nor `response` is set. + /// If `done` == `true`, exactly one of `error` or `response` is set. + #[prost(oneof = "operation::Result", tags = "4, 5")] + pub result: ::core::option::Option, +} +/// Nested message and enum types in `Operation`. +pub mod operation { + /// The operation result, which can be either an `error` or a valid `response`. + /// If `done` == `false`, neither `error` nor `response` is set. + /// If `done` == `true`, exactly one of `error` or `response` is set. + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Result { + /// The error result of the operation in case of failure or cancellation. + #[prost(message, tag = "4")] + Error(super::super::rpc::Status), + /// The normal response of the operation in case of success. If the original + /// method returns no data on success, such as `Delete`, the response is + /// `google.protobuf.Empty`. If the original method is standard + /// `Get`/`Create`/`Update`, the response should be the resource. For other + /// methods, the response should have the type `XxxResponse`, where `Xxx` + /// is the original method name. For example, if the original method name + /// is `TakeSnapshot()`, the inferred response type is + /// `TakeSnapshotResponse`. + #[prost(message, tag = "5")] + Response(::prost_types::Any), + } +} +/// The request message for \[Operations.GetOperation\]\[google.longrunning.Operations.GetOperation\]. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct GetOperationRequest { + /// The name of the operation resource. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// The request message for \[Operations.ListOperations\]\[google.longrunning.Operations.ListOperations\]. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ListOperationsRequest { + /// The name of the operation's parent resource. + #[prost(string, tag = "4")] + pub name: ::prost::alloc::string::String, + /// The standard list filter. + #[prost(string, tag = "1")] + pub filter: ::prost::alloc::string::String, + /// The standard list page size. + #[prost(int32, tag = "2")] + pub page_size: i32, + /// The standard list page token. + #[prost(string, tag = "3")] + pub page_token: ::prost::alloc::string::String, +} +/// The response message for \[Operations.ListOperations\]\[google.longrunning.Operations.ListOperations\]. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ListOperationsResponse { + /// A list of operations that matches the specified filter in the request. + #[prost(message, repeated, tag = "1")] + pub operations: ::prost::alloc::vec::Vec, + /// The standard List next-page token. + #[prost(string, tag = "2")] + pub next_page_token: ::prost::alloc::string::String, +} +/// The request message for \[Operations.CancelOperation\]\[google.longrunning.Operations.CancelOperation\]. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct CancelOperationRequest { + /// The name of the operation resource to be cancelled. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// The request message for \[Operations.DeleteOperation\]\[google.longrunning.Operations.DeleteOperation\]. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DeleteOperationRequest { + /// The name of the operation resource to be deleted. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, +} +/// The request message for \[Operations.WaitOperation\]\[google.longrunning.Operations.WaitOperation\]. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct WaitOperationRequest { + /// The name of the operation resource to wait on. + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + /// The maximum duration to wait before timing out. If left blank, the wait + /// will be at most the time permitted by the underlying HTTP/RPC protocol. + /// If RPC context deadline is also specified, the shorter one will be used. + #[prost(message, optional, tag = "2")] + pub timeout: ::core::option::Option<::prost_types::Duration>, +} +/// A message representing the message types used by a long-running operation. +/// +/// Example: +/// +/// rpc LongRunningRecognize(LongRunningRecognizeRequest) +/// returns (google.longrunning.Operation) { +/// option (google.longrunning.operation_info) = { +/// response_type: "LongRunningRecognizeResponse" +/// metadata_type: "LongRunningRecognizeMetadata" +/// }; +/// } +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct OperationInfo { + /// Required. The message name of the primary return type for this + /// long-running operation. + /// This type will be used to deserialize the LRO's response. + /// + /// If the response is in a different package from the rpc, a fully-qualified + /// message name must be used (e.g. `google.protobuf.Struct`). + /// + /// Note: Altering this value constitutes a breaking change. + #[prost(string, tag = "1")] + pub response_type: ::prost::alloc::string::String, + /// Required. The message name of the metadata type for this long-running + /// operation. + /// + /// If the response is in a different package from the rpc, a fully-qualified + /// message name must be used (e.g. `google.protobuf.Struct`). + /// + /// Note: Altering this value constitutes a breaking change. + #[prost(string, tag = "2")] + pub metadata_type: ::prost::alloc::string::String, +} diff --git a/prost-googleapis/src/google/mod.rs b/prost-googleapis/src/google/mod.rs new file mode 100644 index 000000000..fa416aecf --- /dev/null +++ b/prost-googleapis/src/google/mod.rs @@ -0,0 +1,7 @@ +pub mod api; +pub mod cloud; +pub mod iam; +pub mod logging; +pub mod longrunning; +pub mod r#type; +pub mod rpc; diff --git a/prost-googleapis/src/google/rpc/context/mod.rs b/prost-googleapis/src/google/rpc/context/mod.rs new file mode 100644 index 000000000..4fe534655 --- /dev/null +++ b/prost-googleapis/src/google/rpc/context/mod.rs @@ -0,0 +1,286 @@ +// This file is @generated by prost-build. +/// This message defines the standard attribute vocabulary for Google APIs. +/// +/// An attribute is a piece of metadata that describes an activity on a network +/// service. For example, the size of an HTTP request, or the status code of +/// an HTTP response. +/// +/// Each attribute has a type and a name, which is logically defined as +/// a proto message field in `AttributeContext`. The field type becomes the +/// attribute type, and the field path becomes the attribute name. For example, +/// the attribute `source.ip` maps to field `AttributeContext.source.ip`. +/// +/// This message definition is guaranteed not to have any wire breaking change. +/// So you can use it directly for passing attributes across different systems. +/// +/// NOTE: Different system may generate different subset of attributes. Please +/// verify the system specification before relying on an attribute generated +/// a system. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AttributeContext { + /// The origin of a network activity. In a multi hop network activity, + /// the origin represents the sender of the first hop. For the first hop, + /// the `source` and the `origin` must have the same content. + #[prost(message, optional, tag = "7")] + pub origin: ::core::option::Option, + /// The source of a network activity, such as starting a TCP connection. + /// In a multi hop network activity, the source represents the sender of the + /// last hop. + #[prost(message, optional, tag = "1")] + pub source: ::core::option::Option, + /// The destination of a network activity, such as accepting a TCP connection. + /// In a multi hop network activity, the destination represents the receiver of + /// the last hop. + #[prost(message, optional, tag = "2")] + pub destination: ::core::option::Option, + /// Represents a network request, such as an HTTP request. + #[prost(message, optional, tag = "3")] + pub request: ::core::option::Option, + /// Represents a network response, such as an HTTP response. + #[prost(message, optional, tag = "4")] + pub response: ::core::option::Option, + /// Represents a target resource that is involved with a network activity. + /// If multiple resources are involved with an activity, this must be the + /// primary one. + #[prost(message, optional, tag = "5")] + pub resource: ::core::option::Option, + /// Represents an API operation that is involved to a network activity. + #[prost(message, optional, tag = "6")] + pub api: ::core::option::Option, +} +/// Nested message and enum types in `AttributeContext`. +pub mod attribute_context { + /// This message defines attributes for a node that handles a network request. + /// The node can be either a service or an application that sends, forwards, + /// or receives the request. Service peers should fill in + /// `principal` and `labels` as appropriate. + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Peer { + /// The IP address of the peer. + #[prost(string, tag = "1")] + pub ip: ::prost::alloc::string::String, + /// The network port of the peer. + #[prost(int64, tag = "2")] + pub port: i64, + /// The labels associated with the peer. + #[prost(map = "string, string", tag = "6")] + pub labels: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// The identity of this peer. Similar to `Request.auth.principal`, but + /// relative to the peer instead of the request. For example, the + /// idenity associated with a load balancer that forwared the request. + #[prost(string, tag = "7")] + pub principal: ::prost::alloc::string::String, + /// The CLDR country/region code associated with the above IP address. + /// If the IP address is private, the `region_code` should reflect the + /// physical location where this peer is running. + #[prost(string, tag = "8")] + pub region_code: ::prost::alloc::string::String, + } + /// This message defines attributes associated with API operations, such as + /// a network API request. The terminology is based on the conventions used + /// by Google APIs, Istio, and OpenAPI. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct Api { + /// The API service name. It is a logical identifier for a networked API, + /// such as "pubsub.googleapis.com". The naming syntax depends on the + /// API management system being used for handling the request. + #[prost(string, tag = "1")] + pub service: ::prost::alloc::string::String, + /// The API operation name. For gRPC requests, it is the fully qualified API + /// method name, such as "google.pubsub.v1.Publisher.Publish". For OpenAPI + /// requests, it is the `operationId`, such as "getPet". + #[prost(string, tag = "2")] + pub operation: ::prost::alloc::string::String, + /// The API protocol used for sending the request, such as "http", "https", + /// "grpc", or "internal". + #[prost(string, tag = "3")] + pub protocol: ::prost::alloc::string::String, + /// The API version associated with the API operation above, such as "v1" or + /// "v1alpha1". + #[prost(string, tag = "4")] + pub version: ::prost::alloc::string::String, + } + /// This message defines request authentication attributes. Terminology is + /// based on the JSON Web Token (JWT) standard, but the terms also + /// correlate to concepts in other standards. + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Auth { + /// The authenticated principal. Reflects the issuer (`iss`) and subject + /// (`sub`) claims within a JWT. The issuer and subject should be `/` + /// delimited, with `/` percent-encoded within the subject fragment. For + /// Google accounts, the principal format is: + /// " + #[prost(string, tag = "1")] + pub principal: ::prost::alloc::string::String, + /// The intended audience(s) for this authentication information. Reflects + /// the audience (`aud`) claim within a JWT. The audience + /// value(s) depends on the `issuer`, but typically include one or more of + /// the following pieces of information: + /// + /// * The services intended to receive the credential such as + /// \["pubsub.googleapis.com", "storage.googleapis.com"\] + /// * A set of service-based scopes. For example, + /// \[" + /// * The client id of an app, such as the Firebase project id for JWTs + /// from Firebase Auth. + /// + /// Consult the documentation for the credential issuer to determine the + /// information provided. + #[prost(string, repeated, tag = "2")] + pub audiences: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// The authorized presenter of the credential. Reflects the optional + /// Authorized Presenter (`azp`) claim within a JWT or the + /// OAuth client id. For example, a Google Cloud Platform client id looks + /// as follows: "123456789012.apps.googleusercontent.com". + #[prost(string, tag = "3")] + pub presenter: ::prost::alloc::string::String, + /// Structured claims presented with the credential. JWTs include + /// `{key: value}` pairs for standard and private claims. The following + /// is a subset of the standard required and optional claims that would + /// typically be presented for a Google-based JWT: + /// + /// ```text + /// {'iss': 'accounts.google.com', + /// 'sub': '113289723416554971153', + /// 'aud': \['123456789012', 'pubsub.googleapis.com'\], + /// 'azp': '123456789012.apps.googleusercontent.com', + /// 'email': 'jsmith@example.com', + /// 'iat': 1353601026, + /// 'exp': 1353604926} + /// ``` + /// + /// SAML assertions are similarly specified, but with an identity provider + /// dependent structure. + #[prost(message, optional, tag = "4")] + pub claims: ::core::option::Option<::prost_types::Struct>, + /// A list of access level resource names that allow resources to be + /// accessed by authenticated requester. It is part of Secure GCP processing + /// for the incoming request. An access level string has the format: + /// "//{api_service_name}/accessPolicies/{policy_id}/accessLevels/{short_name}" + /// + /// Example: + /// "//accesscontextmanager.googleapis.com/accessPolicies/MY_POLICY_ID/accessLevels/MY_LEVEL" + #[prost(string, repeated, tag = "5")] + pub access_levels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + } + /// This message defines attributes for an HTTP request. If the actual + /// request is not an HTTP request, the runtime system should try to map + /// the actual request to an equivalent HTTP request. + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Request { + /// The unique ID for a request, which can be propagated to downstream + /// systems. The ID should have low probability of collision + /// within a single day for a specific service. + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// The HTTP request method, such as `GET`, `POST`. + #[prost(string, tag = "2")] + pub method: ::prost::alloc::string::String, + /// The HTTP request headers. If multiple headers share the same key, they + /// must be merged according to the HTTP spec. All header keys must be + /// lowercased, because HTTP header keys are case-insensitive. + #[prost(map = "string, string", tag = "3")] + pub headers: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// The HTTP URL path. + #[prost(string, tag = "4")] + pub path: ::prost::alloc::string::String, + /// The HTTP request `Host` header value. + #[prost(string, tag = "5")] + pub host: ::prost::alloc::string::String, + /// The HTTP URL scheme, such as `http` and `https`. + #[prost(string, tag = "6")] + pub scheme: ::prost::alloc::string::String, + /// The HTTP URL query in the format of `name1=value1&name2=value2`, as it + /// appears in the first line of the HTTP request. No decoding is performed. + #[prost(string, tag = "7")] + pub query: ::prost::alloc::string::String, + /// The timestamp when the `destination` service receives the first byte of + /// the request. + #[prost(message, optional, tag = "9")] + pub time: ::core::option::Option<::prost_types::Timestamp>, + /// The HTTP request size in bytes. If unknown, it must be -1. + #[prost(int64, tag = "10")] + pub size: i64, + /// The network protocol used with the request, such as "http/1.1", + /// "spdy/3", "h2", "h2c", "webrtc", "tcp", "udp", "quic". See + /// + /// for details. + #[prost(string, tag = "11")] + pub protocol: ::prost::alloc::string::String, + /// A special parameter for request reason. It is used by security systems + /// to associate auditing information with a request. + #[prost(string, tag = "12")] + pub reason: ::prost::alloc::string::String, + /// The request authentication. May be absent for unauthenticated requests. + /// Derived from the HTTP request `Authorization` header or equivalent. + #[prost(message, optional, tag = "13")] + pub auth: ::core::option::Option, + } + /// This message defines attributes for a typical network response. It + /// generally models semantics of an HTTP response. + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Response { + /// The HTTP response status code, such as `200` and `404`. + #[prost(int64, tag = "1")] + pub code: i64, + /// The HTTP response size in bytes. If unknown, it must be -1. + #[prost(int64, tag = "2")] + pub size: i64, + /// The HTTP response headers. If multiple headers share the same key, they + /// must be merged according to HTTP spec. All header keys must be + /// lowercased, because HTTP header keys are case-insensitive. + #[prost(map = "string, string", tag = "3")] + pub headers: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + /// The timestamp when the `destination` service generates the first byte of + /// the response. + #[prost(message, optional, tag = "4")] + pub time: ::core::option::Option<::prost_types::Timestamp>, + } + /// This message defines core attributes for a resource. A resource is an + /// addressable (named) entity provided by the destination service. For + /// example, a file stored on a network storage service. + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Resource { + /// The name of the service that this resource belongs to, such as + /// `pubsub.googleapis.com`. The service may be different from the DNS + /// hostname that actually serves the request. + #[prost(string, tag = "1")] + pub service: ::prost::alloc::string::String, + /// The stable identifier (name) of a resource on the `service`. A resource + /// can be logically identified as "//{resource.service}/{resource.name}". + /// The differences between a resource name and a URI are: + /// + /// * Resource name is a logical identifier, independent of network + /// protocol and API version. For example, + /// `//pubsub.googleapis.com/projects/123/topics/news-feed`. + /// * URI often includes protocol and version information, so it can + /// be used directly by applications. For example, + /// ` + /// + /// See for details. + #[prost(string, tag = "2")] + pub name: ::prost::alloc::string::String, + /// The type of the resource. The syntax is platform-specific because + /// different platforms define their resources differently. + /// + /// For Google APIs, the type format must be "{service}/{kind}". + #[prost(string, tag = "3")] + pub r#type: ::prost::alloc::string::String, + /// The labels or tags on the resource, such as AWS resource tags and + /// Kubernetes resource labels. + #[prost(map = "string, string", tag = "4")] + pub labels: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, + } +} diff --git a/prost-googleapis/src/google/rpc/mod.rs b/prost-googleapis/src/google/rpc/mod.rs new file mode 100644 index 000000000..58d78d28c --- /dev/null +++ b/prost-googleapis/src/google/rpc/mod.rs @@ -0,0 +1,471 @@ +pub mod context; + +// This file is @generated by prost-build. +/// The `Status` type defines a logical error model that is suitable for +/// different programming environments, including REST APIs and RPC APIs. It is +/// used by [gRPC](). Each `Status` message contains +/// three pieces of data: error code, error message, and error details. +/// +/// You can find out more about this error model and how to work with it in the +/// [API Design Guide](). +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Status { + /// The status code, which should be an enum value of \[google.rpc.Code\]\[google.rpc.Code\]. + #[prost(int32, tag = "1")] + pub code: i32, + /// A developer-facing error message, which should be in English. Any + /// user-facing error message should be localized and sent in the + /// \[google.rpc.Status.details\]\[google.rpc.Status.details\] field, or localized by the client. + #[prost(string, tag = "2")] + pub message: ::prost::alloc::string::String, + /// A list of messages that carry the error details. There is a common set of + /// message types for APIs to use. + #[prost(message, repeated, tag = "3")] + pub details: ::prost::alloc::vec::Vec<::prost_types::Any>, +} +/// The canonical error codes for gRPC APIs. +/// +/// Sometimes multiple error codes may apply. Services should return +/// the most specific error code that applies. For example, prefer +/// `OUT_OF_RANGE` over `FAILED_PRECONDITION` if both codes apply. +/// Similarly prefer `NOT_FOUND` or `ALREADY_EXISTS` over `FAILED_PRECONDITION`. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Code { + /// Not an error; returned on success + /// + /// HTTP Mapping: 200 OK + Ok = 0, + /// The operation was cancelled, typically by the caller. + /// + /// HTTP Mapping: 499 Client Closed Request + Cancelled = 1, + /// Unknown error. For example, this error may be returned when + /// a `Status` value received from another address space belongs to + /// an error space that is not known in this address space. Also + /// errors raised by APIs that do not return enough error information + /// may be converted to this error. + /// + /// HTTP Mapping: 500 Internal Server Error + Unknown = 2, + /// The client specified an invalid argument. Note that this differs + /// from `FAILED_PRECONDITION`. `INVALID_ARGUMENT` indicates arguments + /// that are problematic regardless of the state of the system + /// (e.g., a malformed file name). + /// + /// HTTP Mapping: 400 Bad Request + InvalidArgument = 3, + /// The deadline expired before the operation could complete. For operations + /// that change the state of the system, this error may be returned + /// even if the operation has completed successfully. For example, a + /// successful response from a server could have been delayed long + /// enough for the deadline to expire. + /// + /// HTTP Mapping: 504 Gateway Timeout + DeadlineExceeded = 4, + /// Some requested entity (e.g., file or directory) was not found. + /// + /// Note to server developers: if a request is denied for an entire class + /// of users, such as gradual feature rollout or undocumented whitelist, + /// `NOT_FOUND` may be used. If a request is denied for some users within + /// a class of users, such as user-based access control, `PERMISSION_DENIED` + /// must be used. + /// + /// HTTP Mapping: 404 Not Found + NotFound = 5, + /// The entity that a client attempted to create (e.g., file or directory) + /// already exists. + /// + /// HTTP Mapping: 409 Conflict + AlreadyExists = 6, + /// The caller does not have permission to execute the specified + /// operation. `PERMISSION_DENIED` must not be used for rejections + /// caused by exhausting some resource (use `RESOURCE_EXHAUSTED` + /// instead for those errors). `PERMISSION_DENIED` must not be + /// used if the caller can not be identified (use `UNAUTHENTICATED` + /// instead for those errors). This error code does not imply the + /// request is valid or the requested entity exists or satisfies + /// other pre-conditions. + /// + /// HTTP Mapping: 403 Forbidden + PermissionDenied = 7, + /// The request does not have valid authentication credentials for the + /// operation. + /// + /// HTTP Mapping: 401 Unauthorized + Unauthenticated = 16, + /// Some resource has been exhausted, perhaps a per-user quota, or + /// perhaps the entire file system is out of space. + /// + /// HTTP Mapping: 429 Too Many Requests + ResourceExhausted = 8, + /// The operation was rejected because the system is not in a state + /// required for the operation's execution. For example, the directory + /// to be deleted is non-empty, an rmdir operation is applied to + /// a non-directory, etc. + /// + /// Service implementors can use the following guidelines to decide + /// between `FAILED_PRECONDITION`, `ABORTED`, and `UNAVAILABLE`: + /// (a) Use `UNAVAILABLE` if the client can retry just the failing call. + /// (b) Use `ABORTED` if the client should retry at a higher level + /// (e.g., when a client-specified test-and-set fails, indicating the + /// client should restart a read-modify-write sequence). + /// (c) Use `FAILED_PRECONDITION` if the client should not retry until + /// the system state has been explicitly fixed. E.g., if an "rmdir" + /// fails because the directory is non-empty, `FAILED_PRECONDITION` + /// should be returned since the client should not retry unless + /// the files are deleted from the directory. + /// + /// HTTP Mapping: 400 Bad Request + FailedPrecondition = 9, + /// The operation was aborted, typically due to a concurrency issue such as + /// a sequencer check failure or transaction abort. + /// + /// See the guidelines above for deciding between `FAILED_PRECONDITION`, + /// `ABORTED`, and `UNAVAILABLE`. + /// + /// HTTP Mapping: 409 Conflict + Aborted = 10, + /// The operation was attempted past the valid range. E.g., seeking or + /// reading past end-of-file. + /// + /// Unlike `INVALID_ARGUMENT`, this error indicates a problem that may + /// be fixed if the system state changes. For example, a 32-bit file + /// system will generate `INVALID_ARGUMENT` if asked to read at an + /// offset that is not in the range \[0,2^32-1\], but it will generate + /// `OUT_OF_RANGE` if asked to read from an offset past the current + /// file size. + /// + /// There is a fair bit of overlap between `FAILED_PRECONDITION` and + /// `OUT_OF_RANGE`. We recommend using `OUT_OF_RANGE` (the more specific + /// error) when it applies so that callers who are iterating through + /// a space can easily look for an `OUT_OF_RANGE` error to detect when + /// they are done. + /// + /// HTTP Mapping: 400 Bad Request + OutOfRange = 11, + /// The operation is not implemented or is not supported/enabled in this + /// service. + /// + /// HTTP Mapping: 501 Not Implemented + Unimplemented = 12, + /// Internal errors. This means that some invariants expected by the + /// underlying system have been broken. This error code is reserved + /// for serious errors. + /// + /// HTTP Mapping: 500 Internal Server Error + Internal = 13, + /// The service is currently unavailable. This is most likely a + /// transient condition, which can be corrected by retrying with + /// a backoff. Note that it is not always safe to retry + /// non-idempotent operations. + /// + /// See the guidelines above for deciding between `FAILED_PRECONDITION`, + /// `ABORTED`, and `UNAVAILABLE`. + /// + /// HTTP Mapping: 503 Service Unavailable + Unavailable = 14, + /// Unrecoverable data loss or corruption. + /// + /// HTTP Mapping: 500 Internal Server Error + DataLoss = 15, +} +impl Code { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Ok => "OK", + Self::Cancelled => "CANCELLED", + Self::Unknown => "UNKNOWN", + Self::InvalidArgument => "INVALID_ARGUMENT", + Self::DeadlineExceeded => "DEADLINE_EXCEEDED", + Self::NotFound => "NOT_FOUND", + Self::AlreadyExists => "ALREADY_EXISTS", + Self::PermissionDenied => "PERMISSION_DENIED", + Self::Unauthenticated => "UNAUTHENTICATED", + Self::ResourceExhausted => "RESOURCE_EXHAUSTED", + Self::FailedPrecondition => "FAILED_PRECONDITION", + Self::Aborted => "ABORTED", + Self::OutOfRange => "OUT_OF_RANGE", + Self::Unimplemented => "UNIMPLEMENTED", + Self::Internal => "INTERNAL", + Self::Unavailable => "UNAVAILABLE", + Self::DataLoss => "DATA_LOSS", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "OK" => Some(Self::Ok), + "CANCELLED" => Some(Self::Cancelled), + "UNKNOWN" => Some(Self::Unknown), + "INVALID_ARGUMENT" => Some(Self::InvalidArgument), + "DEADLINE_EXCEEDED" => Some(Self::DeadlineExceeded), + "NOT_FOUND" => Some(Self::NotFound), + "ALREADY_EXISTS" => Some(Self::AlreadyExists), + "PERMISSION_DENIED" => Some(Self::PermissionDenied), + "UNAUTHENTICATED" => Some(Self::Unauthenticated), + "RESOURCE_EXHAUSTED" => Some(Self::ResourceExhausted), + "FAILED_PRECONDITION" => Some(Self::FailedPrecondition), + "ABORTED" => Some(Self::Aborted), + "OUT_OF_RANGE" => Some(Self::OutOfRange), + "UNIMPLEMENTED" => Some(Self::Unimplemented), + "INTERNAL" => Some(Self::Internal), + "UNAVAILABLE" => Some(Self::Unavailable), + "DATA_LOSS" => Some(Self::DataLoss), + _ => None, + } + } +} +/// Describes when the clients can retry a failed request. Clients could ignore +/// the recommendation here or retry when this information is missing from error +/// responses. +/// +/// It's always recommended that clients should use exponential backoff when +/// retrying. +/// +/// Clients should wait until `retry_delay` amount of time has passed since +/// receiving the error response before retrying. If retrying requests also +/// fail, clients should use an exponential backoff scheme to gradually increase +/// the delay between retries based on `retry_delay`, until either a maximum +/// number of retries have been reached or a maximum retry delay cap has been +/// reached. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct RetryInfo { + /// Clients should wait at least this long between retrying the same request. + #[prost(message, optional, tag = "1")] + pub retry_delay: ::core::option::Option<::prost_types::Duration>, +} +/// Describes additional debugging info. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DebugInfo { + /// The stack trace entries indicating where the error occurred. + #[prost(string, repeated, tag = "1")] + pub stack_entries: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Additional debugging information provided by the server. + #[prost(string, tag = "2")] + pub detail: ::prost::alloc::string::String, +} +/// Describes how a quota check failed. +/// +/// For example if a daily limit was exceeded for the calling project, +/// a service could respond with a QuotaFailure detail containing the project +/// id and the description of the quota limit that was exceeded. If the +/// calling project hasn't enabled the service in the developer console, then +/// a service could respond with the project id and set `service_disabled` +/// to true. +/// +/// Also see RetryInfo and Help types for other details about handling a +/// quota failure. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct QuotaFailure { + /// Describes all quota violations. + #[prost(message, repeated, tag = "1")] + pub violations: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `QuotaFailure`. +pub mod quota_failure { + /// A message type used to describe a single quota violation. For example, a + /// daily quota or a custom quota that was exceeded. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct Violation { + /// The subject on which the quota check failed. + /// For example, "clientip:" or "project:". + #[prost(string, tag = "1")] + pub subject: ::prost::alloc::string::String, + /// A description of how the quota check failed. Clients can use this + /// description to find more about the quota configuration in the service's + /// public documentation, or find the relevant quota limit to adjust through + /// developer console. + /// + /// For example: "Service disabled" or "Daily Limit for read operations + /// exceeded". + #[prost(string, tag = "2")] + pub description: ::prost::alloc::string::String, + } +} +/// Describes the cause of the error with structured details. +/// +/// Example of an error when contacting the "pubsub.googleapis.com" API when it +/// is not enabled: +/// { "reason": "API_DISABLED" +/// "domain": "googleapis.com" +/// "metadata": { +/// "resource": "projects/123", +/// "service": "pubsub.googleapis.com" +/// } +/// } +/// This response indicates that the pubsub.googleapis.com API is not enabled. +/// +/// Example of an error that is returned when attempting to create a Spanner +/// instance in a region that is out of stock: +/// { "reason": "STOCKOUT" +/// "domain": "spanner.googleapis.com", +/// "metadata": { +/// "availableRegions": "us-central1,us-east2" +/// } +/// } +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ErrorInfo { + /// The reason of the error. This is a constant value that identifies the + /// proximate cause of the error. Error reasons are unique within a particular + /// domain of errors. This should be at most 63 characters and match + /// /\[A-Z0-9\_\]+/. + #[prost(string, tag = "1")] + pub reason: ::prost::alloc::string::String, + /// The logical grouping to which the "reason" belongs. Often "domain" will + /// contain the registered service name of the tool or product that is the + /// source of the error. Example: "pubsub.googleapis.com". If the error is + /// common across many APIs, the first segment of the example above will be + /// omitted. The value will be, "googleapis.com". + #[prost(string, tag = "2")] + pub domain: ::prost::alloc::string::String, + /// Additional structured details about this error. + /// + /// Keys should match /\[a-zA-Z0-9-\_\]/ and be limited to 64 characters in + /// length. When identifying the current value of an exceeded limit, the units + /// should be contained in the key, not the value. For example, rather than + /// {"instanceLimit": "100/request"}, should be returned as, + /// {"instanceLimitPerRequest": "100"}, if the client exceeds the number of + /// instances that can be created in a single (batch) request. + #[prost(map = "string, string", tag = "3")] + pub metadata: ::std::collections::HashMap< + ::prost::alloc::string::String, + ::prost::alloc::string::String, + >, +} +/// Describes what preconditions have failed. +/// +/// For example, if an RPC failed because it required the Terms of Service to be +/// acknowledged, it could list the terms of service violation in the +/// PreconditionFailure message. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PreconditionFailure { + /// Describes all precondition violations. + #[prost(message, repeated, tag = "1")] + pub violations: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `PreconditionFailure`. +pub mod precondition_failure { + /// A message type used to describe a single precondition failure. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct Violation { + /// The type of PreconditionFailure. We recommend using a service-specific + /// enum type to define the supported precondition violation subjects. For + /// example, "TOS" for "Terms of Service violation". + #[prost(string, tag = "1")] + pub r#type: ::prost::alloc::string::String, + /// The subject, relative to the type, that failed. + /// For example, "google.com/cloud" relative to the "TOS" type would indicate + /// which terms of service is being referenced. + #[prost(string, tag = "2")] + pub subject: ::prost::alloc::string::String, + /// A description of how the precondition failed. Developers can use this + /// description to understand how to fix the failure. + /// + /// For example: "Terms of service not accepted". + #[prost(string, tag = "3")] + pub description: ::prost::alloc::string::String, + } +} +/// Describes violations in a client request. This error type focuses on the +/// syntactic aspects of the request. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct BadRequest { + /// Describes all violations in a client request. + #[prost(message, repeated, tag = "1")] + pub field_violations: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `BadRequest`. +pub mod bad_request { + /// A message type used to describe a single bad request field. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct FieldViolation { + /// A path leading to a field in the request body. The value will be a + /// sequence of dot-separated identifiers that identify a protocol buffer + /// field. E.g., "field_violations.field" would identify this field. + #[prost(string, tag = "1")] + pub field: ::prost::alloc::string::String, + /// A description of why the request element is bad. + #[prost(string, tag = "2")] + pub description: ::prost::alloc::string::String, + } +} +/// Contains metadata about the request that clients can attach when filing a bug +/// or providing other forms of feedback. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct RequestInfo { + /// An opaque string that should only be interpreted by the service generating + /// it. For example, it can be used to identify requests in the service's logs. + #[prost(string, tag = "1")] + pub request_id: ::prost::alloc::string::String, + /// Any data that was used to serve this request. For example, an encrypted + /// stack trace that can be sent back to the service provider for debugging. + #[prost(string, tag = "2")] + pub serving_data: ::prost::alloc::string::String, +} +/// Describes the resource that is being accessed. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct ResourceInfo { + /// A name for the type of resource being accessed, e.g. "sql table", + /// "cloud storage bucket", "file", "Google calendar"; or the type URL + /// of the resource: e.g. "type.googleapis.com/google.pubsub.v1.Topic". + #[prost(string, tag = "1")] + pub resource_type: ::prost::alloc::string::String, + /// The name of the resource being accessed. For example, a shared calendar + /// name: "example.com_4fghdhgsrgh@group.calendar.google.com", if the current + /// error is \[google.rpc.Code.PERMISSION_DENIED\]\[google.rpc.Code.PERMISSION_DENIED\]. + #[prost(string, tag = "2")] + pub resource_name: ::prost::alloc::string::String, + /// The owner of the resource (optional). + /// For example, "user:" or "project:". + #[prost(string, tag = "3")] + pub owner: ::prost::alloc::string::String, + /// Describes what error is encountered when accessing this resource. + /// For example, updating a cloud project may require the `writer` permission + /// on the developer console project. + #[prost(string, tag = "4")] + pub description: ::prost::alloc::string::String, +} +/// Provides links to documentation or for performing an out of band action. +/// +/// For example, if a quota check failed with an error indicating the calling +/// project hasn't enabled the accessed service, this can contain a URL pointing +/// directly to the right place in the developer console to flip the bit. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct Help { + /// URL(s) pointing to additional information on handling the current error. + #[prost(message, repeated, tag = "1")] + pub links: ::prost::alloc::vec::Vec, +} +/// Nested message and enum types in `Help`. +pub mod help { + /// Describes a URL link. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] + pub struct Link { + /// Describes what the link offers. + #[prost(string, tag = "1")] + pub description: ::prost::alloc::string::String, + /// The URL of the link. + #[prost(string, tag = "2")] + pub url: ::prost::alloc::string::String, + } +} +/// Provides a localized error message that is safe to return to the user +/// which can be attached to an RPC error. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct LocalizedMessage { + /// The locale used following the specification defined at + /// + /// Examples are: "en-US", "fr-CH", "es-MX" + #[prost(string, tag = "1")] + pub locale: ::prost::alloc::string::String, + /// The localized error message in the above locale. + #[prost(string, tag = "2")] + pub message: ::prost::alloc::string::String, +} diff --git a/prost-googleapis/src/google/type/mod.rs b/prost-googleapis/src/google/type/mod.rs new file mode 100644 index 000000000..666e96109 --- /dev/null +++ b/prost-googleapis/src/google/type/mod.rs @@ -0,0 +1,725 @@ +// This file is @generated by prost-build. +/// Represents an expression text. Example: +/// +/// ```text +/// title: "User account presence" +/// description: "Determines whether the request has a user account" +/// expression: "size(request.user) > 0" +/// ``` +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Expr { + /// Textual representation of an expression in + /// Common Expression Language syntax. + /// + /// The application context of the containing message determines which + /// well-known feature set of CEL is supported. + #[prost(string, tag = "1")] + pub expression: ::prost::alloc::string::String, + /// An optional title for the expression, i.e. a short string describing + /// its purpose. This can be used e.g. in UIs which allow to enter the + /// expression. + #[prost(string, tag = "2")] + pub title: ::prost::alloc::string::String, + /// An optional description of the expression. This is a longer text which + /// describes the expression, e.g. when hovered over it in a UI. + #[prost(string, tag = "3")] + pub description: ::prost::alloc::string::String, + /// An optional string indicating the location of the expression for error + /// reporting, e.g. a file name and a position in the file. + #[prost(string, tag = "4")] + pub location: ::prost::alloc::string::String, +} +/// Represents an amount of money with its currency type. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Money { + /// The 3-letter currency code defined in ISO 4217. + #[prost(string, tag = "1")] + pub currency_code: ::prost::alloc::string::String, + /// The whole units of the amount. + /// For example if `currencyCode` is `"USD"`, then 1 unit is one US dollar. + #[prost(int64, tag = "2")] + pub units: i64, + /// Number of nano (10^-9) units of the amount. + /// The value must be between -999,999,999 and +999,999,999 inclusive. + /// If `units` is positive, `nanos` must be positive or zero. + /// If `units` is zero, `nanos` can be positive, zero, or negative. + /// If `units` is negative, `nanos` must be negative or zero. + /// For example $-1.75 is represented as `units`=-1 and `nanos`=-750,000,000. + #[prost(int32, tag = "3")] + pub nanos: i32, +} +/// A `CalendarPeriod` represents the abstract concept of a time period that has +/// a canonical start. Grammatically, "the start of the current +/// `CalendarPeriod`." All calendar times begin at midnight UTC. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum CalendarPeriod { + /// Undefined period, raises an error. + Unspecified = 0, + /// A day. + Day = 1, + /// A week. Weeks begin on Monday, following + /// [ISO 8601](). + Week = 2, + /// A fortnight. The first calendar fortnight of the year begins at the start + /// of week 1 according to + /// [ISO 8601](). + Fortnight = 3, + /// A month. + Month = 4, + /// A quarter. Quarters start on dates 1-Jan, 1-Apr, 1-Jul, and 1-Oct of each + /// year. + Quarter = 5, + /// A half-year. Half-years start on dates 1-Jan and 1-Jul. + Half = 6, + /// A year. + Year = 7, +} +impl CalendarPeriod { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "CALENDAR_PERIOD_UNSPECIFIED", + Self::Day => "DAY", + Self::Week => "WEEK", + Self::Fortnight => "FORTNIGHT", + Self::Month => "MONTH", + Self::Quarter => "QUARTER", + Self::Half => "HALF", + Self::Year => "YEAR", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "CALENDAR_PERIOD_UNSPECIFIED" => Some(Self::Unspecified), + "DAY" => Some(Self::Day), + "WEEK" => Some(Self::Week), + "FORTNIGHT" => Some(Self::Fortnight), + "MONTH" => Some(Self::Month), + "QUARTER" => Some(Self::Quarter), + "HALF" => Some(Self::Half), + "YEAR" => Some(Self::Year), + _ => None, + } + } +} +/// An object that represents a latitude/longitude pair. This is expressed as a +/// pair of doubles to represent degrees latitude and degrees longitude. Unless +/// specified otherwise, this must conform to the +/// WGS84> +/// standard. Values must be within normalized ranges. +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct LatLng { + /// The latitude in degrees. It must be in the range \[-90.0, +90.0\]. + #[prost(double, tag = "1")] + pub latitude: f64, + /// The longitude in degrees. It must be in the range \[-180.0, +180.0\]. + #[prost(double, tag = "2")] + pub longitude: f64, +} +/// A quaternion is defined as the quotient of two directed lines in a +/// three-dimensional space or equivalently as the quotient of two Euclidean +/// vectors (). +/// +/// Quaternions are often used in calculations involving three-dimensional +/// rotations (), +/// as they provide greater mathematical robustness by avoiding the gimbal lock +/// problems that can be encountered when using Euler angles +/// (). +/// +/// Quaternions are generally represented in this form: +/// +/// ```text +/// w + xi + yj + zk +/// ``` +/// +/// where x, y, z, and w are real numbers, and i, j, and k are three imaginary +/// numbers. +/// +/// Our naming choice `(x, y, z, w)` comes from the desire to avoid confusion for +/// those interested in the geometric properties of the quaternion in the 3D +/// Cartesian space. Other texts often use alternative names or subscripts, such +/// as `(a, b, c, d)`, `(1, i, j, k)`, or `(0, 1, 2, 3)`, which are perhaps +/// better suited for mathematical interpretations. +/// +/// To avoid any confusion, as well as to maintain compatibility with a large +/// number of software libraries, the quaternions represented using the protocol +/// buffer below *must* follow the Hamilton convention, which defines `ij = k` +/// (i.e. a right-handed algebra), and therefore: +/// +/// ```text +/// i^2 = j^2 = k^2 = ijk = −1 +/// ij = −ji = k +/// jk = −kj = i +/// ki = −ik = j +/// ``` +/// +/// Please DO NOT use this to represent quaternions that follow the JPL +/// convention, or any of the other quaternion flavors out there. +/// +/// Definitions: +/// +/// * Quaternion norm (or magnitude): `sqrt(x^2 + y^2 + z^2 + w^2)`. +/// * Unit (or normalized) quaternion: a quaternion whose norm is 1. +/// * Pure quaternion: a quaternion whose scalar component (`w`) is 0. +/// * Rotation quaternion: a unit quaternion used to represent rotation. +/// * Orientation quaternion: a unit quaternion used to represent orientation. +/// +/// A quaternion can be normalized by dividing it by its norm. The resulting +/// quaternion maintains the same direction, but has a norm of 1, i.e. it moves +/// on the unit sphere. This is generally necessary for rotation and orientation +/// quaternions, to avoid rounding errors: +/// +/// +/// Note that `(x, y, z, w)` and `(-x, -y, -z, -w)` represent the same rotation, +/// but normalization would be even more useful, e.g. for comparison purposes, if +/// it would produce a unique representation. It is thus recommended that `w` be +/// kept positive, which can be achieved by changing all the signs when `w` is +/// negative. +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Quaternion { + /// The x component. + #[prost(double, tag = "1")] + pub x: f64, + /// The y component. + #[prost(double, tag = "2")] + pub y: f64, + /// The z component. + #[prost(double, tag = "3")] + pub z: f64, + /// The scalar component. + #[prost(double, tag = "4")] + pub w: f64, +} +/// Represents a month in the Gregorian calendar. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Month { + /// The unspecifed month. + Unspecified = 0, + /// The month of January. + January = 1, + /// The month of February. + February = 2, + /// The month of March. + March = 3, + /// The month of April. + April = 4, + /// The month of May. + May = 5, + /// The month of June. + June = 6, + /// The month of July. + July = 7, + /// The month of August. + August = 8, + /// The month of September. + September = 9, + /// The month of October. + October = 10, + /// The month of November. + November = 11, + /// The month of December. + December = 12, +} +impl Month { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "MONTH_UNSPECIFIED", + Self::January => "JANUARY", + Self::February => "FEBRUARY", + Self::March => "MARCH", + Self::April => "APRIL", + Self::May => "MAY", + Self::June => "JUNE", + Self::July => "JULY", + Self::August => "AUGUST", + Self::September => "SEPTEMBER", + Self::October => "OCTOBER", + Self::November => "NOVEMBER", + Self::December => "DECEMBER", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "MONTH_UNSPECIFIED" => Some(Self::Unspecified), + "JANUARY" => Some(Self::January), + "FEBRUARY" => Some(Self::February), + "MARCH" => Some(Self::March), + "APRIL" => Some(Self::April), + "MAY" => Some(Self::May), + "JUNE" => Some(Self::June), + "JULY" => Some(Self::July), + "AUGUST" => Some(Self::August), + "SEPTEMBER" => Some(Self::September), + "OCTOBER" => Some(Self::October), + "NOVEMBER" => Some(Self::November), + "DECEMBER" => Some(Self::December), + _ => None, + } + } +} +/// Represents civil time in one of a few possible ways: +/// +/// * When utc_offset is set and time_zone is unset: a civil time on a calendar +/// day with a particular offset from UTC. +/// * When time_zone is set and utc_offset is unset: a civil time on a calendar +/// day in a particular time zone. +/// * When neither time_zone nor utc_offset is set: a civil time on a calendar +/// day in local time. +/// +/// The date is relative to the Proleptic Gregorian Calendar. +/// +/// If year is 0, the DateTime is considered not to have a specific year. month +/// and day must have valid, non-zero values. +/// +/// This type is more flexible than some applications may want. Make sure to +/// document and validate your application's limitations. +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct DateTime { + /// Optional. Year of date. Must be from 1 to 9999, or 0 if specifying a + /// datetime without a year. + #[prost(int32, tag = "1")] + pub year: i32, + /// Required. Month of year. Must be from 1 to 12. + #[prost(int32, tag = "2")] + pub month: i32, + /// Required. Day of month. Must be from 1 to 31 and valid for the year and + /// month. + #[prost(int32, tag = "3")] + pub day: i32, + /// Required. Hours of day in 24 hour format. Should be from 0 to 23. An API + /// may choose to allow the value "24:00:00" for scenarios like business + /// closing time. + #[prost(int32, tag = "4")] + pub hours: i32, + /// Required. Minutes of hour of day. Must be from 0 to 59. + #[prost(int32, tag = "5")] + pub minutes: i32, + /// Required. Seconds of minutes of the time. Must normally be from 0 to 59. An + /// API may allow the value 60 if it allows leap-seconds. + #[prost(int32, tag = "6")] + pub seconds: i32, + /// Required. Fractions of seconds in nanoseconds. Must be from 0 to + /// 999,999,999. + #[prost(int32, tag = "7")] + pub nanos: i32, + /// Optional. Specifies either the UTC offset or the time zone of the DateTime. + /// Choose carefully between them, considering that time zone data may change + /// in the future (for example, a country modifies their DST start/end dates, + /// and future DateTimes in the affected range had already been stored). + /// If omitted, the DateTime is considered to be in local time. + #[prost(oneof = "date_time::TimeOffset", tags = "8, 9")] + pub time_offset: ::core::option::Option, +} +/// Nested message and enum types in `DateTime`. +pub mod date_time { + /// Optional. Specifies either the UTC offset or the time zone of the DateTime. + /// Choose carefully between them, considering that time zone data may change + /// in the future (for example, a country modifies their DST start/end dates, + /// and future DateTimes in the affected range had already been stored). + /// If omitted, the DateTime is considered to be in local time. + #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] + pub enum TimeOffset { + /// UTC offset. Must be whole seconds, between -18 hours and +18 hours. + /// For example, a UTC offset of -4:00 would be represented as + /// { seconds: -14400 }. + #[prost(message, tag = "8")] + UtcOffset(::prost_types::Duration), + /// Time zone. + #[prost(message, tag = "9")] + TimeZone(super::TimeZone), + } +} +/// Represents a time zone from the +/// [IANA Time Zone Database](). +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct TimeZone { + /// IANA Time Zone Database time zone, e.g. "America/New_York". + #[prost(string, tag = "1")] + pub id: ::prost::alloc::string::String, + /// Optional. IANA Time Zone Database version number, e.g. "2019a". + #[prost(string, tag = "2")] + pub version: ::prost::alloc::string::String, +} +/// Represents a color in the RGBA color space. This representation is designed +/// for simplicity of conversion to/from color representations in various +/// languages over compactness; for example, the fields of this representation +/// can be trivially provided to the constructor of "java.awt.Color" in Java; it +/// can also be trivially provided to UIColor's "+colorWithRed:green:blue:alpha" +/// method in iOS; and, with just a little work, it can be easily formatted into +/// a CSS "rgba()" string in JavaScript, as well. +/// +/// Note: this proto does not carry information about the absolute color space +/// that should be used to interpret the RGB value (e.g. sRGB, Adobe RGB, +/// DCI-P3, BT.2020, etc.). By default, applications SHOULD assume the sRGB color +/// space. +/// +/// Example (Java): +/// +/// ```text +/// import com.google.type.Color; +/// +/// // ... +/// public static java.awt.Color fromProto(Color protocolor) { +/// float alpha = protocolor.hasAlpha() +/// ? protocolor.getAlpha().getValue() +/// : 1.0; +/// +/// return new java.awt.Color( +/// protocolor.getRed(), +/// protocolor.getGreen(), +/// protocolor.getBlue(), +/// alpha); +/// } +/// +/// public static Color toProto(java.awt.Color color) { +/// float red = (float) color.getRed(); +/// float green = (float) color.getGreen(); +/// float blue = (float) color.getBlue(); +/// float denominator = 255.0; +/// Color.Builder resultBuilder = +/// Color +/// .newBuilder() +/// .setRed(red / denominator) +/// .setGreen(green / denominator) +/// .setBlue(blue / denominator); +/// int alpha = color.getAlpha(); +/// if (alpha != 255) { +/// result.setAlpha( +/// FloatValue +/// .newBuilder() +/// .setValue(((float) alpha) / denominator) +/// .build()); +/// } +/// return resultBuilder.build(); +/// } +/// // ... +/// ``` +/// +/// Example (iOS / Obj-C): +/// +/// ```text +/// // ... +/// static UIColor* fromProto(Color* protocolor) { +/// float red = \[protocolor red\]; +/// float green = \[protocolor green\]; +/// float blue = \[protocolor blue\]; +/// FloatValue* alpha_wrapper = \[protocolor alpha\]; +/// float alpha = 1.0; +/// if (alpha_wrapper != nil) { +/// alpha = \[alpha_wrapper value\]; +/// } +/// return \[UIColor colorWithRed:red green:green blue:blue alpha:alpha\]; +/// } +/// +/// static Color* toProto(UIColor* color) { +/// CGFloat red, green, blue, alpha; +/// if (!\[color getRed:&red green:&green blue:&blue alpha:&alpha\]) { +/// return nil; +/// } +/// Color* result = \[[Color alloc\] init]; +/// \[result setRed:red\]; +/// \[result setGreen:green\]; +/// \[result setBlue:blue\]; +/// if (alpha <= 0.9999) { +/// \[result setAlpha:floatWrapperWithValue(alpha)\]; +/// } +/// \[result autorelease\]; +/// return result; +/// } +/// // ... +/// ``` +/// +/// Example (JavaScript): +/// +/// ```text +/// // ... +/// +/// var protoToCssColor = function(rgb_color) { +/// var redFrac = rgb_color.red || 0.0; +/// var greenFrac = rgb_color.green || 0.0; +/// var blueFrac = rgb_color.blue || 0.0; +/// var red = Math.floor(redFrac * 255); +/// var green = Math.floor(greenFrac * 255); +/// var blue = Math.floor(blueFrac * 255); +/// +/// if (!('alpha' in rgb_color)) { +/// return rgbToCssColor_(red, green, blue); +/// } +/// +/// var alphaFrac = rgb_color.alpha.value || 0.0; +/// var rgbParams = \[red, green, blue\].join(','); +/// return \['rgba(', rgbParams, ',', alphaFrac, ')'\].join(''); +/// }; +/// +/// var rgbToCssColor_ = function(red, green, blue) { +/// var rgbNumber = new Number((red << 16) | (green << 8) | blue); +/// var hexString = rgbNumber.toString(16); +/// var missingZeros = 6 - hexString.length; +/// var resultBuilder = \['#'\]; +/// for (var i = 0; i < missingZeros; i++) { +/// resultBuilder.push('0'); +/// } +/// resultBuilder.push(hexString); +/// return resultBuilder.join(''); +/// }; +/// +/// // ... +/// ``` +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Color { + /// The amount of red in the color as a value in the interval \[0, 1\]. + #[prost(float, tag = "1")] + pub red: f32, + /// The amount of green in the color as a value in the interval \[0, 1\]. + #[prost(float, tag = "2")] + pub green: f32, + /// The amount of blue in the color as a value in the interval \[0, 1\]. + #[prost(float, tag = "3")] + pub blue: f32, + /// The fraction of this color that should be applied to the pixel. That is, + /// the final pixel color is defined by the equation: + /// + /// pixel color = alpha * (this color) + (1.0 - alpha) * (background color) + /// + /// This means that a value of 1.0 corresponds to a solid color, whereas + /// a value of 0.0 corresponds to a completely transparent color. This + /// uses a wrapper message rather than a simple float scalar so that it is + /// possible to distinguish between a default value and the value being unset. + /// If omitted, this color object is to be rendered as a solid color + /// (as if the alpha value had been explicitly given with a value of 1.0). + #[prost(message, optional, tag = "4")] + pub alpha: ::core::option::Option, +} +/// Represents a time of day. The date and time zone are either not significant +/// or are specified elsewhere. An API may choose to allow leap seconds. Related +/// types are \[google.type.Date\]\[google.type.Date\] and `google.protobuf.Timestamp`. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct TimeOfDay { + /// Hours of day in 24 hour format. Should be from 0 to 23. An API may choose + /// to allow the value "24:00:00" for scenarios like business closing time. + #[prost(int32, tag = "1")] + pub hours: i32, + /// Minutes of hour of day. Must be from 0 to 59. + #[prost(int32, tag = "2")] + pub minutes: i32, + /// Seconds of minutes of the time. Must normally be from 0 to 59. An API may + /// allow the value 60 if it allows leap-seconds. + #[prost(int32, tag = "3")] + pub seconds: i32, + /// Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999. + #[prost(int32, tag = "4")] + pub nanos: i32, +} +/// Represents a whole or partial calendar date, e.g. a birthday. The time of day +/// and time zone are either specified elsewhere or are not significant. The date +/// is relative to the Proleptic Gregorian Calendar. This can represent: +/// +/// * A full date, with non-zero year, month and day values +/// * A month and day value, with a zero year, e.g. an anniversary +/// * A year on its own, with zero month and day values +/// * A year and month value, with a zero day, e.g. a credit card expiration date +/// +/// Related types are \[google.type.TimeOfDay\]\[google.type.TimeOfDay\] and `google.protobuf.Timestamp`. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Date { + /// Year of date. Must be from 1 to 9999, or 0 if specifying a date without + /// a year. + #[prost(int32, tag = "1")] + pub year: i32, + /// Month of year. Must be from 1 to 12, or 0 if specifying a year without a + /// month and day. + #[prost(int32, tag = "2")] + pub month: i32, + /// Day of month. Must be from 1 to 31 and valid for the year and month, or 0 + /// if specifying a year by itself or a year and month where the day is not + /// significant. + #[prost(int32, tag = "3")] + pub day: i32, +} +/// Represents a day of week. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum DayOfWeek { + /// The unspecified day-of-week. + Unspecified = 0, + /// The day-of-week of Monday. + Monday = 1, + /// The day-of-week of Tuesday. + Tuesday = 2, + /// The day-of-week of Wednesday. + Wednesday = 3, + /// The day-of-week of Thursday. + Thursday = 4, + /// The day-of-week of Friday. + Friday = 5, + /// The day-of-week of Saturday. + Saturday = 6, + /// The day-of-week of Sunday. + Sunday = 7, +} +impl DayOfWeek { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Self::Unspecified => "DAY_OF_WEEK_UNSPECIFIED", + Self::Monday => "MONDAY", + Self::Tuesday => "TUESDAY", + Self::Wednesday => "WEDNESDAY", + Self::Thursday => "THURSDAY", + Self::Friday => "FRIDAY", + Self::Saturday => "SATURDAY", + Self::Sunday => "SUNDAY", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "DAY_OF_WEEK_UNSPECIFIED" => Some(Self::Unspecified), + "MONDAY" => Some(Self::Monday), + "TUESDAY" => Some(Self::Tuesday), + "WEDNESDAY" => Some(Self::Wednesday), + "THURSDAY" => Some(Self::Thursday), + "FRIDAY" => Some(Self::Friday), + "SATURDAY" => Some(Self::Saturday), + "SUNDAY" => Some(Self::Sunday), + _ => None, + } + } +} +/// Represents a postal address, e.g. for postal delivery or payments addresses. +/// Given a postal address, a postal service can deliver items to a premise, P.O. +/// Box or similar. +/// It is not intended to model geographical locations (roads, towns, +/// mountains). +/// +/// In typical usage an address would be created via user input or from importing +/// existing data, depending on the type of process. +/// +/// Advice on address input / editing: +/// +/// * Use an i18n-ready address widget such as +/// ) +/// * Users should not be presented with UI elements for input or editing of +/// fields outside countries where that field is used. +/// +/// For more guidance on how to use this schema, please see: +/// +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct PostalAddress { + /// The schema revision of the `PostalAddress`. This must be set to 0, which is + /// the latest revision. + /// + /// All new revisions **must** be backward compatible with old revisions. + #[prost(int32, tag = "1")] + pub revision: i32, + /// Required. CLDR region code of the country/region of the address. This + /// is never inferred and it is up to the user to ensure the value is + /// correct. See and + /// + /// for details. Example: "CH" for Switzerland. + #[prost(string, tag = "2")] + pub region_code: ::prost::alloc::string::String, + /// Optional. BCP-47 language code of the contents of this address (if + /// known). This is often the UI language of the input form or is expected + /// to match one of the languages used in the address' country/region, or their + /// transliterated equivalents. + /// This can affect formatting in certain countries, but is not critical + /// to the correctness of the data and will never affect any validation or + /// other non-formatting related operations. + /// + /// If this value is not known, it should be omitted (rather than specifying a + /// possibly incorrect default). + /// + /// Examples: "zh-Hant", "ja", "ja-Latn", "en". + #[prost(string, tag = "3")] + pub language_code: ::prost::alloc::string::String, + /// Optional. Postal code of the address. Not all countries use or require + /// postal codes to be present, but where they are used, they may trigger + /// additional validation with other parts of the address (e.g. state/zip + /// validation in the U.S.A.). + #[prost(string, tag = "4")] + pub postal_code: ::prost::alloc::string::String, + /// Optional. Additional, country-specific, sorting code. This is not used + /// in most regions. Where it is used, the value is either a string like + /// "CEDEX", optionally followed by a number (e.g. "CEDEX 7"), or just a number + /// alone, representing the "sector code" (Jamaica), "delivery area indicator" + /// (Malawi) or "post office indicator" (e.g. Côte d'Ivoire). + #[prost(string, tag = "5")] + pub sorting_code: ::prost::alloc::string::String, + /// Optional. Highest administrative subdivision which is used for postal + /// addresses of a country or region. + /// For example, this can be a state, a province, an oblast, or a prefecture. + /// Specifically, for Spain this is the province and not the autonomous + /// community (e.g. "Barcelona" and not "Catalonia"). + /// Many countries don't use an administrative area in postal addresses. E.g. + /// in Switzerland this should be left unpopulated. + #[prost(string, tag = "6")] + pub administrative_area: ::prost::alloc::string::String, + /// Optional. Generally refers to the city/town portion of the address. + /// Examples: US city, IT comune, UK post town. + /// In regions of the world where localities are not well defined or do not fit + /// into this structure well, leave locality empty and use address_lines. + #[prost(string, tag = "7")] + pub locality: ::prost::alloc::string::String, + /// Optional. Sublocality of the address. + /// For example, this can be neighborhoods, boroughs, districts. + #[prost(string, tag = "8")] + pub sublocality: ::prost::alloc::string::String, + /// Unstructured address lines describing the lower levels of an address. + /// + /// Because values in address_lines do not have type information and may + /// sometimes contain multiple values in a single field (e.g. + /// "Austin, TX"), it is important that the line order is clear. The order of + /// address lines should be "envelope order" for the country/region of the + /// address. In places where this can vary (e.g. Japan), address_language is + /// used to make it explicit (e.g. "ja" for large-to-small ordering and + /// "ja-Latn" or "en" for small-to-large). This way, the most specific line of + /// an address can be selected based on the language. + /// + /// The minimum permitted structural representation of an address consists + /// of a region_code with all remaining information placed in the + /// address_lines. It would be possible to format such an address very + /// approximately without geocoding, but no semantic reasoning could be + /// made about any of the address components until it was at least + /// partially resolved. + /// + /// Creating an address only containing a region_code and address_lines, and + /// then geocoding is the recommended way to handle completely unstructured + /// addresses (as opposed to guessing which parts of the address should be + /// localities or administrative areas). + #[prost(string, repeated, tag = "9")] + pub address_lines: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Optional. The recipient at the address. + /// This field may, under certain circumstances, contain multiline information. + /// For example, it might contain "care of" information. + #[prost(string, repeated, tag = "10")] + pub recipients: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, + /// Optional. The name of the organization at the address. + #[prost(string, tag = "11")] + pub organization: ::prost::alloc::string::String, +} +/// Represents a fraction in terms of a numerator divided by a denominator. +#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] +pub struct Fraction { + /// The portion of the denominator in the faction, e.g. 2 in 2/3. + #[prost(int64, tag = "1")] + pub numerator: i64, + /// The value by which the numerator is divided, e.g. 3 in 2/3. Must be + /// positive. + #[prost(int64, tag = "2")] + pub denominator: i64, +} diff --git a/prost-googleapis/src/lib.rs b/prost-googleapis/src/lib.rs new file mode 100644 index 000000000..e333d5747 --- /dev/null +++ b/prost-googleapis/src/lib.rs @@ -0,0 +1 @@ +pub mod google; From 02e2c23742dd2120df9e7d695a6bf6c62f214766 Mon Sep 17 00:00:00 2001 From: Garry Filakhtov Date: Mon, 13 Oct 2025 10:51:57 +0000 Subject: [PATCH 2/3] Run cargo fmt on the generated code --- prost-googleapis/src/google/api/mod.rs | 98 +++---------------- .../src/google/iam/admin/v1/mod.rs | 48 +-------- prost-googleapis/src/google/iam/v1/mod.rs | 24 +---- prost-googleapis/src/google/mod.rs | 2 +- prost-googleapis/src/google/rpc/mod.rs | 6 +- 5 files changed, 23 insertions(+), 155 deletions(-) diff --git a/prost-googleapis/src/google/api/mod.rs b/prost-googleapis/src/google/api/mod.rs index 5fcd2a3cf..210e72fa8 100644 --- a/prost-googleapis/src/google/api/mod.rs +++ b/prost-googleapis/src/google/api/mod.rs @@ -586,17 +586,7 @@ pub struct ResourceDescriptor { pub mod resource_descriptor { /// A description of the historical or future-looking state of the /// resource pattern. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum History { /// The "unset" value. @@ -632,17 +622,7 @@ pub mod resource_descriptor { } } /// A flag representing a specific style that a resource claims to conform to. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Style { /// The unspecified value. Do not use. @@ -977,17 +957,13 @@ pub struct Monitoring { /// different monitored resource type. A metric can be used in at most /// one producer destination. #[prost(message, repeated, tag = "1")] - pub producer_destinations: ::prost::alloc::vec::Vec< - monitoring::MonitoringDestination, - >, + pub producer_destinations: ::prost::alloc::vec::Vec, /// Monitoring configurations for sending metrics to the consumer project. /// There can be multiple consumer destinations, each one must have a /// different monitored resource type. A metric can be used in at most /// one consumer destination. #[prost(message, repeated, tag = "2")] - pub consumer_destinations: ::prost::alloc::vec::Vec< - monitoring::MonitoringDestination, - >, + pub consumer_destinations: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `Monitoring`. pub mod monitoring { @@ -1910,17 +1886,7 @@ pub struct LabelDescriptor { /// Nested message and enum types in `LabelDescriptor`. pub mod label_descriptor { /// Value types that can be used as label values. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ValueType { /// A variable-length string. This is the default. @@ -2019,10 +1985,8 @@ pub struct MonitoredResource { /// 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, - >, + 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 @@ -2049,10 +2013,8 @@ pub struct MonitoredResourceMetadata { 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, - >, + pub user_labels: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// Selects and configures the service controller used by the service. The /// service controller handles features like abuse, quota, billing, logging, @@ -2181,17 +2143,7 @@ pub struct MetricDescriptor { /// Nested message and enum types in `MetricDescriptor`. pub mod metric_descriptor { /// The kind of measurement. It describes how the data is reported. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum MetricKind { /// Do not use this default value. @@ -2232,17 +2184,7 @@ pub mod metric_descriptor { } } /// The value type of a metric. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ValueType { /// Do not use this default value. @@ -2304,10 +2246,8 @@ pub struct Metric { /// The set of label values that uniquely identify this metric. All /// labels listed in the `MetricDescriptor` must be assigned values. #[prost(map = "string, string", tag = "2")] - pub labels: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, + pub labels: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// A descriptor for defining project properties for a service. One service may /// have many consumer projects, and the service may want to behave differently @@ -2358,17 +2298,7 @@ pub struct Property { /// Nested message and enum types in `Property`. pub mod property { /// Supported data type of the property values - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PropertyType { /// The type is unspecified, and will result in an error. diff --git a/prost-googleapis/src/google/iam/admin/v1/mod.rs b/prost-googleapis/src/google/iam/admin/v1/mod.rs index ef41efa5b..95e8377a6 100644 --- a/prost-googleapis/src/google/iam/admin/v1/mod.rs +++ b/prost-googleapis/src/google/iam/admin/v1/mod.rs @@ -147,17 +147,7 @@ pub struct ListServiceAccountKeysRequest { pub mod list_service_account_keys_request { /// `KeyType` filters to selectively retrieve certain varieties /// of keys. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum KeyType { /// Unspecified key type. The presence of this in the @@ -389,17 +379,7 @@ pub struct Role { /// Nested message and enum types in `Role`. pub mod role { /// A stage representing a role's lifecycle phase. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum RoleLaunchStage { /// The user has indicated this role is currently in an Alpha phase. If this @@ -718,17 +698,7 @@ pub struct Permission { /// Nested message and enum types in `Permission`. pub mod permission { /// A stage representing a permission's lifecycle phase. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PermissionLaunchStage { /// The permission is currently in an alpha phase. @@ -765,17 +735,7 @@ pub mod permission { } } /// The state of the permission with regards to custom roles. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum CustomRolesSupportLevel { /// Permission is fully supported for custom role use. diff --git a/prost-googleapis/src/google/iam/v1/mod.rs b/prost-googleapis/src/google/iam/v1/mod.rs index 25eef4273..8a863b63b 100644 --- a/prost-googleapis/src/google/iam/v1/mod.rs +++ b/prost-googleapis/src/google/iam/v1/mod.rs @@ -184,17 +184,7 @@ pub struct BindingDelta { /// Nested message and enum types in `BindingDelta`. pub mod binding_delta { /// The type of action performed on a Binding in a policy. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Action { /// Unspecified. @@ -255,17 +245,7 @@ pub struct AuditConfigDelta { /// Nested message and enum types in `AuditConfigDelta`. pub mod audit_config_delta { /// The type of action performed on an audit configuration in a policy. - #[derive( - Clone, - Copy, - Debug, - PartialEq, - Eq, - Hash, - PartialOrd, - Ord, - ::prost::Enumeration - )] + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Action { /// Unspecified. diff --git a/prost-googleapis/src/google/mod.rs b/prost-googleapis/src/google/mod.rs index fa416aecf..46591f256 100644 --- a/prost-googleapis/src/google/mod.rs +++ b/prost-googleapis/src/google/mod.rs @@ -3,5 +3,5 @@ pub mod cloud; pub mod iam; pub mod logging; pub mod longrunning; -pub mod r#type; pub mod rpc; +pub mod r#type; diff --git a/prost-googleapis/src/google/rpc/mod.rs b/prost-googleapis/src/google/rpc/mod.rs index 58d78d28c..0ca6aabdf 100644 --- a/prost-googleapis/src/google/rpc/mod.rs +++ b/prost-googleapis/src/google/rpc/mod.rs @@ -333,10 +333,8 @@ pub struct ErrorInfo { /// {"instanceLimitPerRequest": "100"}, if the client exceeds the number of /// instances that can be created in a single (batch) request. #[prost(map = "string, string", tag = "3")] - pub metadata: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, + pub metadata: + ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// Describes what preconditions have failed. /// From 4844074d71c14e32ac7d7c70989c108bb1ca52ca Mon Sep 17 00:00:00 2001 From: Garry Filakhtov Date: Mon, 13 Oct 2025 22:09:12 +0000 Subject: [PATCH 3/3] Fix unclosed HTML delimiters in rustdoc --- prost-googleapis/src/google/api/mod.rs | 6 +++--- prost-googleapis/src/google/rpc/mod.rs | 4 ++-- prost-googleapis/src/google/type/mod.rs | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/prost-googleapis/src/google/api/mod.rs b/prost-googleapis/src/google/api/mod.rs index 210e72fa8..0435f87ec 100644 --- a/prost-googleapis/src/google/api/mod.rs +++ b/prost-googleapis/src/google/api/mod.rs @@ -1803,7 +1803,7 @@ pub struct Endpoint { #[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 \/; + /// service. Each requirement is of the form \/\; /// for example 'serviceusage.googleapis.com/billing-enabled'. #[prost(string, repeated, tag = "1")] pub requirements: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, @@ -3056,8 +3056,8 @@ pub struct QuotaLimit { /// tier STANDARD. For example: {STANDARD:500}. /// /// To apply a regional overide for a tier, add a map entry with key - /// "/", where is a region name. Similarly, for a zone - /// override, add a map entry with key "/{zone}". + /// "\/\", where \ is a region name. Similarly, for a zone + /// override, add a map entry with key "\/{zone}". /// Further, a wildcard can be used at the end of a zone name in order to /// specify zone level overrides. For example: /// LOW: 10, STANDARD: 50, HIGH: 100, diff --git a/prost-googleapis/src/google/rpc/mod.rs b/prost-googleapis/src/google/rpc/mod.rs index 0ca6aabdf..ea06bb87a 100644 --- a/prost-googleapis/src/google/rpc/mod.rs +++ b/prost-googleapis/src/google/rpc/mod.rs @@ -273,7 +273,7 @@ pub mod quota_failure { #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct Violation { /// The subject on which the quota check failed. - /// For example, "clientip:" or "project:" or "project:\". #[prost(string, tag = "1")] pub subject: ::prost::alloc::string::String, @@ -420,7 +420,7 @@ pub struct ResourceInfo { #[prost(string, tag = "2")] pub resource_name: ::prost::alloc::string::String, /// The owner of the resource (optional). - /// For example, "user:" or "project:" or "project:\". #[prost(string, tag = "3")] pub owner: ::prost::alloc::string::String, diff --git a/prost-googleapis/src/google/type/mod.rs b/prost-googleapis/src/google/type/mod.rs index 666e96109..1260eb9da 100644 --- a/prost-googleapis/src/google/type/mod.rs +++ b/prost-googleapis/src/google/type/mod.rs @@ -110,7 +110,7 @@ impl CalendarPeriod { /// An object that represents a latitude/longitude pair. This is expressed as a /// pair of doubles to represent degrees latitude and degrees longitude. Unless /// specified otherwise, this must conform to the -/// WGS84> +/// WGS84 /// standard. Values must be within normalized ranges. #[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct LatLng {