/// 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<::prost_types::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<::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.
    #[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<::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
        /// <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<::prost_types::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<::prost_types::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/user-guide/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<::prost_types::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<::prost_types::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<::prost_types::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,
    }
}
/// `AuditContext` provides information that is needed for audit logging.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AuditContext {
    /// Serialized audit log.
    #[prost(bytes = "vec", tag = "1")]
    pub audit_log: ::prost::alloc::vec::Vec<u8>,
    /// An API request message that is scrubbed based on the method annotation.
    /// This field should only be filled if audit_log field is present.
    /// Service Control will use this to assemble a complete log for Cloud Audit
    /// Logs and Google internal audit logs.
    #[prost(message, optional, tag = "2")]
    pub scrubbed_request: ::core::option::Option<::prost_types::Struct>,
    /// An API response message that is scrubbed based on the method annotation.
    /// This field should only be filled if audit_log field is present.
    /// Service Control will use this to assemble a complete log for Cloud Audit
    /// Logs and Google internal audit logs.
    #[prost(message, optional, tag = "3")]
    pub scrubbed_response: ::core::option::Option<::prost_types::Struct>,
    /// Number of scrubbed response items.
    #[prost(int32, tag = "4")]
    pub scrubbed_response_item_count: i32,
    /// Audit resource name which is scrubbed.
    #[prost(string, tag = "5")]
    pub target_resource: ::prost::alloc::string::String,
}
