chore: add generated rpc code

1 files changed, 337 insertions, 0 deletions

diff --git a/src/rpc/google.rpc.context.rs b/src/rpc/google.rpc.context.rs
new file mode 100644
index 00000000..3206f15d
--- /dev/null
+++ b/src/rpc/google.rpc.context.rs
@@ -0,0 +1,337 @@
+// @generated
+// 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.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[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<attribute_context::Peer>,
+    /// 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<attribute_context::Peer>,
+    /// 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<attribute_context::Peer>,
+    /// Represents a network request, such as an HTTP request.
+    #[prost(message, optional, tag="3")]
+    pub request: ::core::option::Option<attribute_context::Request>,
+    /// Represents a network response, such as an HTTP response.
+    #[prost(message, optional, tag="4")]
+    pub response: ::core::option::Option<attribute_context::Response>,
+    /// 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<attribute_context::Resource>,
+    /// Represents an API operation that is involved to a network activity.
+    #[prost(message, optional, tag="6")]
+    pub api: ::core::option::Option<attribute_context::Api>,
+    /// Supports extensions for advanced use cases, such as logs and metrics.
+    #[prost(message, repeated, tag="8")]
+    pub extensions: ::prost::alloc::vec::Vec<super::super::protobuf::Any>,
+}
+/// 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.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[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
+        /// identity associated with a load balancer that forwarded 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.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::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.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[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:
+        /// "<https://accounts.google.com/{id}">
+        #[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. For example,
+        ///     \["<https://pubsub.googleapis.com/",> "<https://storage.googleapis.com/"\].>
+        /// *  A set of service-based scopes. For example,
+        ///     \["<https://www.googleapis.com/auth/cloud-platform"\].>
+        /// *  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:
+        ///
+        ///     {'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<super::super::super::protobuf::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.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[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, excluding the query parameters.
+        #[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 last byte of
+        /// the request.
+        #[prost(message, optional, tag="9")]
+        pub time: ::core::option::Option<super::super::super::protobuf::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
+        /// <https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids>
+        /// 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<Auth>,
+    }
+    /// This message defines attributes for a typical network response. It
+    /// generally models semantics of an HTTP response.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[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 sends the last byte of
+        /// the response.
+        #[prost(message, optional, tag="4")]
+        pub time: ::core::option::Option<super::super::super::protobuf::Timestamp>,
+        /// The amount of time it takes the backend service to fully respond to a
+        /// request. Measured from when the destination service starts to send the
+        /// request to the backend until when the destination service receives the
+        /// complete response from the backend.
+        #[prost(message, optional, tag="5")]
+        pub backend_latency: ::core::option::Option<super::super::super::protobuf::Duration>,
+    }
+    /// 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.
+    #[allow(clippy::derive_partial_eq_without_eq)]
+#[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,
+        ///      `<https://pubsub.googleapis.com/v1/projects/123/topics/news-feed`.>
+        ///
+        /// See <https://cloud.google.com/apis/design/resource_names> 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}", such as
+        /// "pubsub.googleapis.com/Topic".
+        #[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>,
+        /// The unique identifier of the resource. UID is unique in the time
+        /// and space for this resource within the scope of the service. It is
+        /// typically generated by the server on successful creation of a resource
+        /// and must not be changed. UID is used to uniquely identify resources
+        /// with resource name reuses. This should be a UUID4.
+        #[prost(string, tag="5")]
+        pub uid: ::prost::alloc::string::String,
+        /// Annotations is an unstructured key-value map stored with a resource that
+        /// may be set by external tools to store and retrieve arbitrary metadata.
+        /// They are not queryable and should be preserved when modifying objects.
+        ///
+        /// More info:
+        /// <https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations/>
+        #[prost(map="string, string", tag="6")]
+        pub annotations: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
+        /// Mutable. The display name set by clients. Must be <= 63 characters.
+        #[prost(string, tag="7")]
+        pub display_name: ::prost::alloc::string::String,
+        /// Output only. The timestamp when the resource was created. This may
+        /// be either the time creation was initiated or when it was completed.
+        #[prost(message, optional, tag="8")]
+        pub create_time: ::core::option::Option<super::super::super::protobuf::Timestamp>,
+        /// Output only. The timestamp when the resource was last updated. Any
+        /// change to the resource made by users must refresh this value.
+        /// Changes to a resource made by the service should refresh this value.
+        #[prost(message, optional, tag="9")]
+        pub update_time: ::core::option::Option<super::super::super::protobuf::Timestamp>,
+        /// Output only. The timestamp when the resource was deleted.
+        /// If the resource is not deleted, this must be empty.
+        #[prost(message, optional, tag="10")]
+        pub delete_time: ::core::option::Option<super::super::super::protobuf::Timestamp>,
+        /// Output only. An opaque value that uniquely identifies a version or
+        /// generation of a resource. It can be used to confirm that the client
+        /// and server agree on the ordering of a resource being written.
+        #[prost(string, tag="11")]
+        pub etag: ::prost::alloc::string::String,
+        /// Immutable. The location of the resource. The location encoding is
+        /// specific to the service provider, and new encoding may be introduced
+        /// as the service evolves.
+        ///
+        /// For Google Cloud products, the encoding is what is used by Google Cloud
+        /// APIs, such as `us-east1`, `aws-us-east-1`, and `azure-eastus2`. The
+        /// semantics of `location` is identical to the
+        /// `cloud.googleapis.com/location` label used by some Google Cloud APIs.
+        #[prost(string, tag="12")]
+        pub location: ::prost::alloc::string::String,
+    }
+}
+// @@protoc_insertion_point(module)