google-cloudevents 0.2.0

// This file is @generated by prost-build.
/// Specification of a port-based selector.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TrafficPortSelector {
    /// Optional. A list of ports. Can be port numbers or port range
    /// (example, \[80-90\] specifies all ports from 80 to 90, including
    /// 80 and 90) or named ports or * to specify all ports. If the
    /// list is empty, all ports are selected.
    #[prost(string, repeated, tag = "1")]
    pub ports: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// A definition of a matcher that selects endpoints to which the policies
/// should be applied.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndpointMatcher {
    /// Specifies type of the matcher used for this endpoint matcher.
    #[prost(oneof = "endpoint_matcher::MatcherType", tags = "1")]
    pub matcher_type: ::core::option::Option<endpoint_matcher::MatcherType>,
}
/// Nested message and enum types in `EndpointMatcher`.
pub mod endpoint_matcher {
    /// The matcher that is based on node metadata presented by xDS clients.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MetadataLabelMatcher {
        /// Specifies how matching should be done.
        ///
        /// Supported values are:
        /// MATCH_ANY: At least one of the Labels specified in the
        ///    matcher should match the metadata presented by xDS client.
        /// MATCH_ALL: The metadata presented by the xDS client should
        ///    contain all of the labels specified here.
        ///
        /// The selection is determined based on the best match. For
        /// example, suppose there are three EndpointPolicy
        /// resources P1, P2 and P3 and if P1 has a the matcher as
        /// MATCH_ANY <A:1, B:1>, P2 has MATCH_ALL <A:1,B:1>, and P3 has
        /// MATCH_ALL <A:1,B:1,C:1>.
        ///
        /// If a client with label <A:1> connects, the config from P1
        /// will be selected.
        ///
        /// If a client with label <A:1,B:1> connects, the config from P2
        /// will be selected.
        ///
        /// If a client with label <A:1,B:1,C:1> connects, the config
        /// from P3 will be selected.
        ///
        /// If there is more than one best match, (for example, if a
        /// config P4 with selector <A:1,D:1> exists and if a client with
        /// label <A:1,B:1,D:1> connects), an error will be thrown.
        #[prost(
            enumeration = "metadata_label_matcher::MetadataLabelMatchCriteria",
            tag = "1"
        )]
        pub metadata_label_match_criteria: i32,
        /// The list of label value pairs that must match labels in the
        /// provided metadata based on filterMatchCriteria This list can
        /// have at most 64 entries. The list can be empty if the match
        /// criteria is MATCH_ANY, to specify a wildcard match (i.e this
        /// matches any client).
        #[prost(message, repeated, tag = "2")]
        pub metadata_labels: ::prost::alloc::vec::Vec<
            metadata_label_matcher::MetadataLabels,
        >,
    }
    /// Nested message and enum types in `MetadataLabelMatcher`.
    pub mod metadata_label_matcher {
        /// Defines a name-pair value for a single label.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct MetadataLabels {
            /// Required. Label name presented as key in xDS Node Metadata.
            #[prost(string, tag = "1")]
            pub label_name: ::prost::alloc::string::String,
            /// Required. Label value presented as value corresponding to the above
            /// key, in xDS Node Metadata.
            #[prost(string, tag = "2")]
            pub label_value: ::prost::alloc::string::String,
        }
        /// Possible criteria values that define logic of how matching is made.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum MetadataLabelMatchCriteria {
            /// Default value. Should not be used.
            Unspecified = 0,
            /// At least one of the Labels specified in the matcher should match the
            /// metadata presented by xDS client.
            MatchAny = 1,
            /// The metadata presented by the xDS client should contain all of the
            /// labels specified here.
            MatchAll = 2,
        }
        impl MetadataLabelMatchCriteria {
            /// 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 => "METADATA_LABEL_MATCH_CRITERIA_UNSPECIFIED",
                    Self::MatchAny => "MATCH_ANY",
                    Self::MatchAll => "MATCH_ALL",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "METADATA_LABEL_MATCH_CRITERIA_UNSPECIFIED" => {
                        Some(Self::Unspecified)
                    }
                    "MATCH_ANY" => Some(Self::MatchAny),
                    "MATCH_ALL" => Some(Self::MatchAll),
                    _ => None,
                }
            }
        }
    }
    /// Specifies type of the matcher used for this endpoint matcher.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum MatcherType {
        /// The matcher is based on node metadata presented by xDS clients.
        #[prost(message, tag = "1")]
        MetadataLabelMatcher(MetadataLabelMatcher),
    }
}
/// EndpointPolicy is a resource that helps apply desired configuration
/// on the endpoints that match specific criteria.
/// For example, this resource can be used to apply "authentication config"
/// an all endpoints that serve on port 8080.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndpointPolicy {
    /// Required. Name of the EndpointPolicy resource. It matches pattern
    /// `projects/{project}/locations/global/endpointPolicies/{endpoint_policy}`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Output only. The timestamp when the resource was updated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Optional. Set of label tags associated with the EndpointPolicy resource.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Required. The type of endpoint policy. This is primarily used to validate
    /// the configuration.
    #[prost(enumeration = "endpoint_policy::EndpointPolicyType", tag = "5")]
    pub r#type: i32,
    /// Optional. This field specifies the URL of AuthorizationPolicy resource that
    /// applies authorization policies to the inbound traffic at the
    /// matched endpoints. Refer to Authorization. If this field is not
    /// specified, authorization is disabled(no authz checks) for this
    /// endpoint.
    #[prost(string, tag = "7")]
    pub authorization_policy: ::prost::alloc::string::String,
    /// Required. A matcher that selects endpoints to which the policies should be
    /// applied.
    #[prost(message, optional, tag = "9")]
    pub endpoint_matcher: ::core::option::Option<EndpointMatcher>,
    /// Optional. Port selector for the (matched) endpoints. If no port selector is
    /// provided, the matched config is applied to all ports.
    #[prost(message, optional, tag = "10")]
    pub traffic_port_selector: ::core::option::Option<TrafficPortSelector>,
    /// Optional. A free-text description of the resource. Max length 1024
    /// characters.
    #[prost(string, tag = "11")]
    pub description: ::prost::alloc::string::String,
    /// Optional. A URL referring to ServerTlsPolicy resource. ServerTlsPolicy is
    /// used to determine the authentication policy to be applied to terminate the
    /// inbound traffic at the identified backends. If this field is not set,
    /// authentication is disabled(open) for this endpoint.
    #[prost(string, tag = "12")]
    pub server_tls_policy: ::prost::alloc::string::String,
    /// Optional. A URL referring to a ClientTlsPolicy resource. ClientTlsPolicy
    /// can be set to specify the authentication for traffic from the proxy to the
    /// actual endpoints. More specifically, it is applied to the outgoing traffic
    /// from the proxy to the endpoint. This is typically used for sidecar model
    /// where the proxy identifies itself as endpoint to the control plane, with
    /// the connection between sidecar and endpoint requiring authentication. If
    /// this field is not set, authentication is disabled(open). Applicable only
    /// when EndpointPolicyType is SIDECAR_PROXY.
    #[prost(string, tag = "13")]
    pub client_tls_policy: ::prost::alloc::string::String,
}
/// Nested message and enum types in `EndpointPolicy`.
pub mod endpoint_policy {
    /// The type of endpoint policy.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum EndpointPolicyType {
        /// Default value. Must not be used.
        Unspecified = 0,
        /// Represents a proxy deployed as a sidecar.
        SidecarProxy = 1,
        /// Represents a proxyless gRPC backend.
        GrpcServer = 2,
    }
    impl EndpointPolicyType {
        /// 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 => "ENDPOINT_POLICY_TYPE_UNSPECIFIED",
                Self::SidecarProxy => "SIDECAR_PROXY",
                Self::GrpcServer => "GRPC_SERVER",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ENDPOINT_POLICY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "SIDECAR_PROXY" => Some(Self::SidecarProxy),
                "GRPC_SERVER" => Some(Self::GrpcServer),
                _ => None,
            }
        }
    }
}
/// Gateway represents the configuration for a proxy, typically a load balancer.
/// It captures the ip:port over which the services are exposed by the proxy,
/// along with any policy configurations. Routes have reference to to Gateways to
/// dictate how requests should be routed by this Gateway.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Gateway {
    /// Required. Name of the Gateway resource. It matches pattern
    /// `projects/*/locations/*/gateways/<gateway_name>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server-defined URL of this resource
    #[prost(string, tag = "13")]
    pub self_link: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Output only. The timestamp when the resource was updated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Optional. Set of label tags associated with the Gateway resource.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. A free-text description of the resource. Max length 1024
    /// characters.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Immutable. The type of the customer managed gateway.
    /// This field is required. If unspecified, an error is returned.
    #[prost(enumeration = "gateway::Type", tag = "6")]
    pub r#type: i32,
    /// Optional. Zero or one IPv4 or IPv6 address on which the Gateway will
    /// receive the traffic. When no address is provided, an IP from the subnetwork
    /// is allocated
    ///
    /// This field only applies to gateways of type 'SECURE_WEB_GATEWAY'.
    /// Gateways of type 'OPEN_MESH' listen on 0.0.0.0 for IPv4 and :: for IPv6.
    #[prost(string, repeated, tag = "7")]
    pub addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Required. One or more port numbers (1-65535), on which the Gateway will
    /// receive traffic. The proxy binds to the specified ports.
    /// Gateways of type 'SECURE_WEB_GATEWAY' are limited to 1 port.
    /// Gateways of type 'OPEN_MESH' listen on 0.0.0.0 for IPv4 and :: for IPv6 and
    /// support multiple ports.
    #[prost(int32, repeated, tag = "11")]
    pub ports: ::prost::alloc::vec::Vec<i32>,
    /// Optional. Scope determines how configuration across multiple Gateway
    /// instances are merged. The configuration for multiple Gateway instances with
    /// the same scope will be merged as presented as a single coniguration to the
    /// proxy/load balancer.
    ///
    /// Max length 64 characters.
    /// Scope should start with a letter and can only have letters, numbers,
    /// hyphens.
    #[prost(string, tag = "8")]
    pub scope: ::prost::alloc::string::String,
    /// Optional. A fully-qualified ServerTLSPolicy URL reference. Specifies how
    /// TLS traffic is terminated. If empty, TLS termination is disabled.
    #[prost(string, tag = "9")]
    pub server_tls_policy: ::prost::alloc::string::String,
    /// Optional. A fully-qualified Certificates URL reference. The proxy presents
    /// a Certificate (selected based on SNI) when establishing a TLS connection.
    /// This feature only applies to gateways of type 'SECURE_WEB_GATEWAY'.
    #[prost(string, repeated, tag = "14")]
    pub certificate_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. A fully-qualified GatewaySecurityPolicy URL reference.
    /// Defines how a server should apply security policy to inbound
    /// (VM to Proxy) initiated connections.
    ///
    /// For example:
    /// `projects/*/locations/*/gatewaySecurityPolicies/swg-policy`.
    ///
    /// This policy is specific to gateways of type 'SECURE_WEB_GATEWAY'.
    #[prost(string, tag = "18")]
    pub gateway_security_policy: ::prost::alloc::string::String,
    /// Optional. The relative resource name identifying the VPC network that is
    /// using this configuration. For example:
    /// `projects/*/global/networks/network-1`.
    ///
    /// Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY'.
    #[prost(string, tag = "16")]
    pub network: ::prost::alloc::string::String,
    /// Optional. The relative resource name identifying  the subnetwork in which
    /// this SWG is allocated. For example:
    /// `projects/*/regions/us-central1/subnetworks/network-1`
    ///
    /// Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY".
    #[prost(string, tag = "17")]
    pub subnetwork: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Gateway`.
pub mod gateway {
    /// The type of the customer-managed gateway.
    /// Possible values are:
    /// * OPEN_MESH
    /// * SECURE_WEB_GATEWAY
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// The type of the customer managed gateway is unspecified.
        Unspecified = 0,
        /// The type of the customer managed gateway is TrafficDirector Open
        /// Mesh.
        OpenMesh = 1,
        /// The type of the customer managed gateway is SecureWebGateway (SWG).
        SecureWebGateway = 2,
    }
    impl Type {
        /// 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 => "TYPE_UNSPECIFIED",
                Self::OpenMesh => "OPEN_MESH",
                Self::SecureWebGateway => "SECURE_WEB_GATEWAY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "OPEN_MESH" => Some(Self::OpenMesh),
                "SECURE_WEB_GATEWAY" => Some(Self::SecureWebGateway),
                _ => None,
            }
        }
    }
}
/// GrpcRoute is the resource defining how gRPC traffic routed by a Mesh
/// or Gateway resource is routed.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GrpcRoute {
    /// Required. Name of the GrpcRoute resource. It matches pattern
    /// `projects/*/locations/global/grpcRoutes/<grpc_route_name>`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server-defined URL of this resource
    #[prost(string, tag = "12")]
    pub self_link: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Output only. The timestamp when the resource was updated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Optional. Set of label tags associated with the GrpcRoute resource.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. A free-text description of the resource. Max length 1024
    /// characters.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Required. Service hostnames with an optional port for which this route
    /// describes traffic.
    ///
    /// Format: <hostname>\[:<port>\]
    ///
    /// Hostname is the fully qualified domain name of a network host. This matches
    /// the RFC 1123 definition of a hostname with 2 notable exceptions:
    ///   - IPs are not allowed.
    ///   - A hostname may be prefixed with a wildcard label (`*.`). The wildcard
    ///     label must appear by itself as the first label.
    ///
    /// Hostname can be "precise" which is a domain name without the terminating
    /// dot of a network host (e.g. `foo.example.com`) or "wildcard", which is a
    /// domain name prefixed with a single wildcard label (e.g. `*.example.com`).
    ///
    /// Note that as per RFC1035 and RFC1123, a label must consist of lower case
    /// alphanumeric characters or '-', and must start and end with an alphanumeric
    /// character. No other punctuation is allowed.
    ///
    /// The routes associated with a Mesh or Gateway must have unique hostnames. If
    /// you attempt to attach multiple routes with conflicting hostnames, the
    /// configuration will be rejected.
    ///
    /// For example, while it is acceptable for routes for the hostnames
    /// `*.foo.bar.com` and `*.bar.com` to be associated with the same route, it is
    /// not possible to associate two routes both with `*.bar.com` or both with
    /// `bar.com`.
    ///
    /// If a port is specified, then gRPC clients must use the channel URI with the
    /// port to match this rule (i.e. "xds:///service:123"), otherwise they must
    /// supply the URI without a port (i.e. "xds:///service").
    #[prost(string, repeated, tag = "6")]
    pub hostnames: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Meshes defines a list of meshes this GrpcRoute is attached to, as
    /// one of the routing rules to route the requests served by the mesh.
    ///
    /// Each mesh reference should match the pattern:
    /// `projects/*/locations/global/meshes/<mesh_name>`
    #[prost(string, repeated, tag = "9")]
    pub meshes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Gateways defines a list of gateways this GrpcRoute is attached
    /// to, as one of the routing rules to route the requests served by the
    /// gateway.
    ///
    /// Each gateway reference should match the pattern:
    /// `projects/*/locations/global/gateways/<gateway_name>`
    #[prost(string, repeated, tag = "10")]
    pub gateways: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Required. A list of detailed rules defining how to route traffic.
    ///
    /// Within a single GrpcRoute, the GrpcRoute.RouteAction associated with the
    /// first matching GrpcRoute.RouteRule will be executed. At least one rule
    /// must be supplied.
    #[prost(message, repeated, tag = "7")]
    pub rules: ::prost::alloc::vec::Vec<grpc_route::RouteRule>,
}
/// Nested message and enum types in `GrpcRoute`.
pub mod grpc_route {
    /// Specifies a match against a method.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct MethodMatch {
        /// Optional. Specifies how to match against the name. If not specified, a
        /// default value of "EXACT" is used.
        #[prost(enumeration = "method_match::Type", tag = "1")]
        pub r#type: i32,
        /// Required. Name of the service to match against. If unspecified, will
        /// match all services.
        #[prost(string, tag = "2")]
        pub grpc_service: ::prost::alloc::string::String,
        /// Required. Name of the method to match against. If unspecified, will match
        /// all methods.
        #[prost(string, tag = "3")]
        pub grpc_method: ::prost::alloc::string::String,
        /// Optional. Specifies that matches are case sensitive.  The default value
        /// is true. case_sensitive must not be used with a type of
        /// REGULAR_EXPRESSION.
        #[prost(bool, optional, tag = "4")]
        pub case_sensitive: ::core::option::Option<bool>,
    }
    /// Nested message and enum types in `MethodMatch`.
    pub mod method_match {
        /// The type of the match.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Type {
            /// Unspecified.
            Unspecified = 0,
            /// Will only match the exact name provided.
            Exact = 1,
            /// Will interpret grpc_method and grpc_service as regexes. RE2 syntax is
            /// supported.
            RegularExpression = 2,
        }
        impl Type {
            /// 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 => "TYPE_UNSPECIFIED",
                    Self::Exact => "EXACT",
                    Self::RegularExpression => "REGULAR_EXPRESSION",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "EXACT" => Some(Self::Exact),
                    "REGULAR_EXPRESSION" => Some(Self::RegularExpression),
                    _ => None,
                }
            }
        }
    }
    /// A match against a collection of headers.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct HeaderMatch {
        /// Optional. Specifies how to match against the value of the header. If not
        /// specified, a default value of EXACT is used.
        #[prost(enumeration = "header_match::Type", tag = "1")]
        pub r#type: i32,
        /// Required. The key of the header.
        #[prost(string, tag = "2")]
        pub key: ::prost::alloc::string::String,
        /// Required. The value of the header.
        #[prost(string, tag = "3")]
        pub value: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `HeaderMatch`.
    pub mod header_match {
        /// The type of match.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Type {
            /// Unspecified.
            Unspecified = 0,
            /// Will only match the exact value provided.
            Exact = 1,
            /// Will match paths conforming to the prefix specified by value. RE2
            /// syntax is supported.
            RegularExpression = 2,
        }
        impl Type {
            /// 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 => "TYPE_UNSPECIFIED",
                    Self::Exact => "EXACT",
                    Self::RegularExpression => "REGULAR_EXPRESSION",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "EXACT" => Some(Self::Exact),
                    "REGULAR_EXPRESSION" => Some(Self::RegularExpression),
                    _ => None,
                }
            }
        }
    }
    /// Criteria for matching traffic. A RouteMatch will be considered to match
    /// when all supplied fields match.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteMatch {
        /// Optional. A gRPC method to match against. If this field is empty or
        /// omitted, will match all methods.
        #[prost(message, optional, tag = "1")]
        pub method: ::core::option::Option<MethodMatch>,
        /// Optional. Specifies a collection of headers to match.
        #[prost(message, repeated, tag = "2")]
        pub headers: ::prost::alloc::vec::Vec<HeaderMatch>,
    }
    /// The destination to which traffic will be routed.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Destination {
        /// Optional. Specifies the proportion of requests forwarded to the backend
        /// referenced by the serviceName field. This is computed as:
        ///          weight/Sum(weights in this destination list).
        /// For non-zero values, there may be some epsilon from the exact proportion
        /// defined here depending on the precision an implementation supports.
        ///
        /// If only one serviceName is specified and it has a weight greater than 0,
        /// 100% of the traffic is forwarded to that backend.
        ///
        /// If weights are specified for any one service name, they need to be
        /// specified for all of them.
        ///
        /// If weights are unspecified for all services, then, traffic is distributed
        /// in equal proportions to all of them.
        #[prost(int32, optional, tag = "2")]
        pub weight: ::core::option::Option<i32>,
        /// Specifies the kind of destination to which traffic will be routed.
        #[prost(oneof = "destination::DestinationType", tags = "1")]
        pub destination_type: ::core::option::Option<destination::DestinationType>,
    }
    /// Nested message and enum types in `Destination`.
    pub mod destination {
        /// Specifies the kind of destination to which traffic will be routed.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum DestinationType {
            /// Required. The URL of a destination service to which to route traffic.
            /// Must refer to either a BackendService or ServiceDirectoryService.
            #[prost(string, tag = "1")]
            ServiceName(::prost::alloc::string::String),
        }
    }
    /// The specification for fault injection introduced into traffic to test the
    /// resiliency of clients to destination service failure. As part of fault
    /// injection, when clients send requests to a destination, delays can be
    /// introduced on a percentage of requests before sending those requests to the
    /// destination service. Similarly requests from clients can be aborted by for
    /// a percentage of requests.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct FaultInjectionPolicy {
        /// The specification for injecting delay to client requests.
        #[prost(message, optional, tag = "1")]
        pub delay: ::core::option::Option<fault_injection_policy::Delay>,
        /// The specification for aborting to client requests.
        #[prost(message, optional, tag = "2")]
        pub abort: ::core::option::Option<fault_injection_policy::Abort>,
    }
    /// Nested message and enum types in `FaultInjectionPolicy`.
    pub mod fault_injection_policy {
        /// Specification of how client requests are delayed as part of fault
        /// injection before being sent to a destination.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Delay {
            /// Specify a fixed delay before forwarding the request.
            #[prost(message, optional, tag = "1")]
            pub fixed_delay: ::core::option::Option<::pbjson_types::Duration>,
            /// The percentage of traffic on which delay will be injected.
            ///
            /// The value must be between \[0, 100\]
            #[prost(int32, optional, tag = "2")]
            pub percentage: ::core::option::Option<i32>,
        }
        /// Specification of how client requests are aborted as part of fault
        /// injection before being sent to a destination.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Abort {
            /// The HTTP status code used to abort the request.
            ///
            /// The value must be between 200 and 599 inclusive.
            #[prost(int32, optional, tag = "1")]
            pub http_status: ::core::option::Option<i32>,
            /// The percentage of traffic which will be aborted.
            ///
            /// The value must be between \[0, 100\]
            #[prost(int32, optional, tag = "2")]
            pub percentage: ::core::option::Option<i32>,
        }
    }
    /// The specifications for retries.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RetryPolicy {
        /// - connect-failure: Router will retry on failures connecting to Backend
        ///     Services, for example due to connection timeouts.
        /// - refused-stream: Router will retry if the backend service resets the
        /// stream
        ///     with a REFUSED_STREAM error code. This reset type indicates that it is
        ///     safe to retry.
        /// - cancelled: Router will retry if the gRPC status code in the response
        /// header
        ///     is set to cancelled
        /// - deadline-exceeded: Router will retry if the gRPC status code in the
        /// response
        ///     header is set to deadline-exceeded
        /// - resource-exhausted: Router will retry if the gRPC status code in the
        ///     response header is set to resource-exhausted
        /// - unavailable: Router will retry if the gRPC status code in the response
        ///     header is set to unavailable
        #[prost(string, repeated, tag = "1")]
        pub retry_conditions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Specifies the allowed number of retries. This number must be > 0. If not
        /// specified, default to 1.
        #[prost(uint32, tag = "2")]
        pub num_retries: u32,
    }
    /// Specifies how to route matched traffic.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteAction {
        /// Optional. The destination services to which traffic should be forwarded.
        /// If multiple destinations are specified, traffic will be split between
        /// Backend Service(s) according to the weight field of these destinations.
        #[prost(message, repeated, tag = "1")]
        pub destinations: ::prost::alloc::vec::Vec<Destination>,
        /// Optional. The specification for fault injection introduced into traffic
        /// to test the resiliency of clients to destination service failure. As part
        /// of fault injection, when clients send requests to a destination, delays
        /// can be introduced on a percentage of requests before sending those
        /// requests to the destination service. Similarly requests from clients can
        /// be aborted by for a percentage of requests.
        ///
        /// timeout and retry_policy will be ignored by clients that are configured
        /// with a fault_injection_policy
        #[prost(message, optional, tag = "3")]
        pub fault_injection_policy: ::core::option::Option<FaultInjectionPolicy>,
        /// Optional. Specifies the timeout for selected route. Timeout is computed
        /// from the time the request has been fully processed (i.e. end of stream)
        /// up until the response has been completely processed. Timeout includes all
        /// retries.
        #[prost(message, optional, tag = "7")]
        pub timeout: ::core::option::Option<::pbjson_types::Duration>,
        /// Optional. Specifies the retry policy associated with this route.
        #[prost(message, optional, tag = "8")]
        pub retry_policy: ::core::option::Option<RetryPolicy>,
    }
    /// Describes how to route traffic.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteRule {
        /// Optional. Matches define conditions used for matching the rule against
        /// incoming gRPC requests. Each match is independent, i.e. this rule will be
        /// matched if ANY one of the matches is satisfied.  If no matches field is
        /// specified, this rule will unconditionally match traffic.
        #[prost(message, repeated, tag = "1")]
        pub matches: ::prost::alloc::vec::Vec<RouteMatch>,
        /// Required. A detailed rule defining how to route traffic. This field is
        /// required.
        #[prost(message, optional, tag = "2")]
        pub action: ::core::option::Option<RouteAction>,
    }
}
/// HttpRoute is the resource defining how HTTP traffic should be routed by a
/// Mesh or Gateway resource.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpRoute {
    /// Required. Name of the HttpRoute resource. It matches pattern
    /// `projects/*/locations/global/httpRoutes/http_route_name>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server-defined URL of this resource
    #[prost(string, tag = "11")]
    pub self_link: ::prost::alloc::string::String,
    /// Optional. A free-text description of the resource. Max length 1024
    /// characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Output only. The timestamp when the resource was updated.
    #[prost(message, optional, tag = "4")]
    pub update_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Required. Hostnames define a set of hosts that should match against the
    /// HTTP host header to select a HttpRoute to process the request. Hostname is
    /// the fully qualified domain name of a network host, as defined by RFC 1123
    /// with the exception that:
    ///   - IPs are not allowed.
    ///   - A hostname may be prefixed with a wildcard label (`*.`). The wildcard
    ///     label must appear by itself as the first label.
    ///
    /// Hostname can be "precise" which is a domain name without the terminating
    /// dot of a network host (e.g. `foo.example.com`) or "wildcard", which is a
    /// domain name prefixed with a single wildcard label (e.g. `*.example.com`).
    ///
    /// Note that as per RFC1035 and RFC1123, a label must consist of lower case
    /// alphanumeric characters or '-', and must start and end with an alphanumeric
    /// character. No other punctuation is allowed.
    ///
    /// The routes associated with a Mesh or Gateways  must have unique hostnames.
    /// If you attempt to attach multiple routes with conflicting hostnames,
    /// the configuration will be rejected.
    ///
    /// For example, while it is acceptable for routes for the hostnames
    /// `*.foo.bar.com` and `*.bar.com` to be associated with the same Mesh (or
    /// Gateways under the same scope), it is not possible to associate two routes
    /// both with `*.bar.com` or both with `bar.com`.
    #[prost(string, repeated, tag = "5")]
    pub hostnames: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Meshes defines a list of meshes this HttpRoute is attached to, as
    /// one of the routing rules to route the requests served by the mesh.
    ///
    /// Each mesh reference should match the pattern:
    /// `projects/*/locations/global/meshes/<mesh_name>`
    ///
    /// The attached Mesh should be of a type SIDECAR
    #[prost(string, repeated, tag = "8")]
    pub meshes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Gateways defines a list of gateways this HttpRoute is attached
    /// to, as one of the routing rules to route the requests served by the
    /// gateway.
    ///
    /// Each gateway reference should match the pattern:
    /// `projects/*/locations/global/gateways/<gateway_name>`
    #[prost(string, repeated, tag = "9")]
    pub gateways: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Set of label tags associated with the HttpRoute resource.
    #[prost(map = "string, string", tag = "10")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Required. Rules that define how traffic is routed and handled.
    /// Rules will be matched sequentially based on the RouteMatch specified for
    /// the rule.
    #[prost(message, repeated, tag = "6")]
    pub rules: ::prost::alloc::vec::Vec<http_route::RouteRule>,
}
/// Nested message and enum types in `HttpRoute`.
pub mod http_route {
    /// Specifies how to select a route rule based on HTTP request headers.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct HeaderMatch {
        /// The name of the HTTP header to match against.
        #[prost(string, tag = "1")]
        pub header: ::prost::alloc::string::String,
        /// If specified, the match result will be inverted before checking. Default
        /// value is set to false.
        #[prost(bool, tag = "8")]
        pub invert_match: bool,
        #[prost(oneof = "header_match::MatchType", tags = "2, 3, 4, 5, 6, 7")]
        pub match_type: ::core::option::Option<header_match::MatchType>,
    }
    /// Nested message and enum types in `HeaderMatch`.
    pub mod header_match {
        /// Represents an integer value range.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct IntegerRange {
            /// Start of the range (inclusive)
            #[prost(int32, tag = "1")]
            pub start: i32,
            /// End of the range (exclusive)
            #[prost(int32, tag = "2")]
            pub end: i32,
        }
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum MatchType {
            /// The value of the header should match exactly the content of
            /// exact_match.
            #[prost(string, tag = "2")]
            ExactMatch(::prost::alloc::string::String),
            /// The value of the header must match the regular expression specified in
            /// regex_match. For regular expression grammar, please see:
            /// <https://github.com/google/re2/wiki/Syntax>
            #[prost(string, tag = "3")]
            RegexMatch(::prost::alloc::string::String),
            /// The value of the header must start with the contents of prefix_match.
            #[prost(string, tag = "4")]
            PrefixMatch(::prost::alloc::string::String),
            /// A header with header_name must exist. The match takes place whether or
            /// not the header has a value.
            #[prost(bool, tag = "5")]
            PresentMatch(bool),
            /// The value of the header must end with the contents of suffix_match.
            #[prost(string, tag = "6")]
            SuffixMatch(::prost::alloc::string::String),
            /// If specified, the rule will match if the request header value is within
            /// the range.
            #[prost(message, tag = "7")]
            RangeMatch(IntegerRange),
        }
    }
    /// Specifications to match a query parameter in the request.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct QueryParameterMatch {
        /// The name of the query parameter to match.
        #[prost(string, tag = "1")]
        pub query_parameter: ::prost::alloc::string::String,
        #[prost(oneof = "query_parameter_match::MatchType", tags = "2, 3, 4")]
        pub match_type: ::core::option::Option<query_parameter_match::MatchType>,
    }
    /// Nested message and enum types in `QueryParameterMatch`.
    pub mod query_parameter_match {
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum MatchType {
            /// The value of the query parameter must exactly match the contents of
            /// exact_match.
            ///
            /// Only one of exact_match, regex_match, or present_match must be set.
            #[prost(string, tag = "2")]
            ExactMatch(::prost::alloc::string::String),
            /// The value of the query parameter must match the regular expression
            /// specified by regex_match. For regular expression grammar, please see
            /// <https://github.com/google/re2/wiki/Syntax>
            ///
            /// Only one of exact_match, regex_match, or present_match must be set.
            #[prost(string, tag = "3")]
            RegexMatch(::prost::alloc::string::String),
            /// Specifies that the QueryParameterMatcher matches if request contains
            /// query parameter, irrespective of whether the parameter has a value or
            /// not.
            ///
            /// Only one of exact_match, regex_match, or present_match must be set.
            #[prost(bool, tag = "4")]
            PresentMatch(bool),
        }
    }
    /// RouteMatch defines specifications used to match requests. If multiple match
    /// types are set, this RouteMatch will match if ALL type of matches are
    /// matched.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteMatch {
        /// Specifies if prefix_match and full_path_match matches are case sensitive.
        /// The default value is false.
        #[prost(bool, tag = "4")]
        pub ignore_case: bool,
        /// Specifies a list of HTTP request headers to match against. ALL of the
        /// supplied headers must be matched.
        #[prost(message, repeated, tag = "5")]
        pub headers: ::prost::alloc::vec::Vec<HeaderMatch>,
        /// Specifies a list of query parameters to match against. ALL of the query
        /// parameters must be matched.
        #[prost(message, repeated, tag = "6")]
        pub query_parameters: ::prost::alloc::vec::Vec<QueryParameterMatch>,
        #[prost(oneof = "route_match::PathMatch", tags = "1, 2, 3")]
        pub path_match: ::core::option::Option<route_match::PathMatch>,
    }
    /// Nested message and enum types in `RouteMatch`.
    pub mod route_match {
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, PartialEq, ::prost::Oneof)]
        pub enum PathMatch {
            /// The HTTP request path value should exactly match this value.
            ///
            /// Only one of full_path_match, prefix_match, or regex_match should be
            /// used.
            #[prost(string, tag = "1")]
            FullPathMatch(::prost::alloc::string::String),
            /// The HTTP request path value must begin with specified prefix_match.
            /// prefix_match must begin with a /.
            ///
            /// Only one of full_path_match, prefix_match, or regex_match should be
            /// used.
            #[prost(string, tag = "2")]
            PrefixMatch(::prost::alloc::string::String),
            /// The HTTP request path value must satisfy the regular expression
            /// specified by regex_match after removing any query parameters and anchor
            /// supplied with the original URL. For regular expression grammar, please
            /// see <https://github.com/google/re2/wiki/Syntax>
            ///
            /// Only one of full_path_match, prefix_match, or regex_match should be
            /// used.
            #[prost(string, tag = "3")]
            RegexMatch(::prost::alloc::string::String),
        }
    }
    /// Specifications of a destination to which the request should be routed to.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Destination {
        /// The URL of a BackendService to route traffic to.
        #[prost(string, tag = "1")]
        pub service_name: ::prost::alloc::string::String,
        /// Specifies the proportion of requests forwarded to the backend referenced
        /// by the serviceName field. This is computed as:
        ///          weight/Sum(weights in this destination list).
        /// For non-zero values, there may be some epsilon from the exact proportion
        /// defined here depending on the precision an implementation supports.
        ///
        /// If only one serviceName is specified and it has a weight greater than 0,
        /// 100% of the traffic is forwarded to that backend.
        ///
        /// If weights are specified for any one service name, they need to be
        /// specified for all of them.
        ///
        /// If weights are unspecified for all services, then, traffic is distributed
        /// in equal proportions to all of them.
        #[prost(int32, tag = "2")]
        pub weight: i32,
    }
    /// The specification for redirecting traffic.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct Redirect {
        /// The host that will be used in the redirect response instead of the one
        /// that was supplied in the request.
        #[prost(string, tag = "1")]
        pub host_redirect: ::prost::alloc::string::String,
        /// The path that will be used in the redirect response instead of the one
        /// that was supplied in the request.
        /// path_redirect can not be supplied together with prefix_redirect. Supply
        /// one alone or neither. If neither is supplied, the path of the original
        /// request will be used for the redirect.
        #[prost(string, tag = "2")]
        pub path_redirect: ::prost::alloc::string::String,
        /// Indicates that during redirection, the matched prefix (or path) should be
        /// swapped with this value. This option allows URLs be dynamically created
        /// based on the request.
        #[prost(string, tag = "3")]
        pub prefix_rewrite: ::prost::alloc::string::String,
        /// The HTTP Status code to use for the redirect.
        #[prost(enumeration = "redirect::ResponseCode", tag = "4")]
        pub response_code: i32,
        /// If set to true, the URL scheme in the redirected request is set to https.
        /// If set to false, the URL scheme of the redirected request will remain the
        /// same as that of the request.
        ///
        /// The default is set to false.
        #[prost(bool, tag = "5")]
        pub https_redirect: bool,
        /// if set to true, any accompanying query portion of the original URL is
        /// removed prior to redirecting the request. If set to false, the query
        /// portion of the original URL is retained.
        ///
        /// The default is set to false.
        #[prost(bool, tag = "6")]
        pub strip_query: bool,
        /// The port that will be used in the redirected request instead of the one
        /// that was supplied in the request.
        #[prost(int32, tag = "7")]
        pub port_redirect: i32,
    }
    /// Nested message and enum types in `Redirect`.
    pub mod redirect {
        /// Supported HTTP response code.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ResponseCode {
            /// Default value
            Unspecified = 0,
            /// Corresponds to 301.
            MovedPermanentlyDefault = 1,
            /// Corresponds to 302.
            Found = 2,
            /// Corresponds to 303.
            SeeOther = 3,
            /// Corresponds to 307. In this case, the request method will be retained.
            TemporaryRedirect = 4,
            /// Corresponds to 308. In this case, the request method will be retained.
            PermanentRedirect = 5,
        }
        impl ResponseCode {
            /// 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 => "RESPONSE_CODE_UNSPECIFIED",
                    Self::MovedPermanentlyDefault => "MOVED_PERMANENTLY_DEFAULT",
                    Self::Found => "FOUND",
                    Self::SeeOther => "SEE_OTHER",
                    Self::TemporaryRedirect => "TEMPORARY_REDIRECT",
                    Self::PermanentRedirect => "PERMANENT_REDIRECT",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "RESPONSE_CODE_UNSPECIFIED" => Some(Self::Unspecified),
                    "MOVED_PERMANENTLY_DEFAULT" => Some(Self::MovedPermanentlyDefault),
                    "FOUND" => Some(Self::Found),
                    "SEE_OTHER" => Some(Self::SeeOther),
                    "TEMPORARY_REDIRECT" => Some(Self::TemporaryRedirect),
                    "PERMANENT_REDIRECT" => Some(Self::PermanentRedirect),
                    _ => None,
                }
            }
        }
    }
    /// The specification for fault injection introduced into traffic to test the
    /// resiliency of clients to destination service failure. As part of fault
    /// injection, when clients send requests to a destination, delays can be
    /// introduced by client proxy on a percentage of requests before sending those
    /// requests to the destination service. Similarly requests can be aborted by
    /// client proxy for a percentage of requests.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, Copy, PartialEq, ::prost::Message)]
    pub struct FaultInjectionPolicy {
        /// The specification for injecting delay to client requests.
        #[prost(message, optional, tag = "1")]
        pub delay: ::core::option::Option<fault_injection_policy::Delay>,
        /// The specification for aborting to client requests.
        #[prost(message, optional, tag = "2")]
        pub abort: ::core::option::Option<fault_injection_policy::Abort>,
    }
    /// Nested message and enum types in `FaultInjectionPolicy`.
    pub mod fault_injection_policy {
        /// Specification of how client requests are delayed as part of fault
        /// injection before being sent to a destination.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Delay {
            /// Specify a fixed delay before forwarding the request.
            #[prost(message, optional, tag = "1")]
            pub fixed_delay: ::core::option::Option<::pbjson_types::Duration>,
            /// The percentage of traffic on which delay will be injected.
            ///
            /// The value must be between \[0, 100\]
            #[prost(int32, tag = "2")]
            pub percentage: i32,
        }
        /// Specification of how client requests are aborted as part of fault
        /// injection before being sent to a destination.
        #[derive(serde::Serialize, serde::Deserialize)]
        #[serde(default)]
        #[serde(rename_all = "snake_case")]
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct Abort {
            /// The HTTP status code used to abort the request.
            ///
            /// The value must be between 200 and 599 inclusive.
            #[prost(int32, tag = "1")]
            pub http_status: i32,
            /// The percentage of traffic which will be aborted.
            ///
            /// The value must be between \[0, 100\]
            #[prost(int32, tag = "2")]
            pub percentage: i32,
        }
    }
    /// The specification for modifying HTTP header in HTTP request and HTTP
    /// response.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct HeaderModifier {
        /// Completely overwrite/replace the headers with given map where key is the
        /// name of the header, value is the value of the header.
        #[prost(map = "string, string", tag = "1")]
        pub set: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Add the headers with given map where key is the name of the header, value
        /// is the value of the header.
        #[prost(map = "string, string", tag = "2")]
        pub add: ::std::collections::HashMap<
            ::prost::alloc::string::String,
            ::prost::alloc::string::String,
        >,
        /// Remove headers (matching by header names) specified in the list.
        #[prost(string, repeated, tag = "3")]
        pub remove: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// The specification for modifying the URL of the request, prior to forwarding
    /// the request to the destination.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct UrlRewrite {
        /// Prior to forwarding the request to the selected destination, the matching
        /// portion of the requests path is replaced by this value.
        #[prost(string, tag = "1")]
        pub path_prefix_rewrite: ::prost::alloc::string::String,
        /// Prior to forwarding the request to the selected destination, the requests
        /// host header is replaced by this value.
        #[prost(string, tag = "2")]
        pub host_rewrite: ::prost::alloc::string::String,
    }
    /// The specifications for retries.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RetryPolicy {
        /// Specifies one or more conditions when this retry policy applies. Valid
        /// values are:
        ///    5xx: Proxy will attempt a retry if the destination service responds
        ///      with any 5xx response code, of if the destination service does not
        ///      respond at all, example: disconnect, reset, read timeout, connection
        ///      failure and refused streams.
        ///
        ///    gateway-error: Similar to 5xx, but only applies to response codes 502,
        ///      503, 504.
        ///
        ///    reset: Proxy will attempt a retry if the destination service does not
        ///      respond at all (disconnect/reset/read timeout)
        ///
        ///    connect-failure: Proxy will retry on failures connecting to destination
        ///      for example due to connection timeouts.
        ///
        ///    retriable-4xx: Proxy will retry fro retriable 4xx response codes.
        ///      Currently the only retriable error supported is 409.
        ///
        ///    refused-stream: Proxy will retry if the destination resets the stream
        ///      with a REFUSED_STREAM error code. This reset type indicates that it
        ///      is safe to retry.
        #[prost(string, repeated, tag = "1")]
        pub retry_conditions: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Specifies the allowed number of retries. This number must be > 0. If not
        /// specified, default to 1.
        #[prost(int32, tag = "2")]
        pub num_retries: i32,
        /// Specifies a non-zero timeout per retry attempt.
        #[prost(message, optional, tag = "3")]
        pub per_try_timeout: ::core::option::Option<::pbjson_types::Duration>,
    }
    /// Specifies the policy on how requests are shadowed to a separate mirrored
    /// destination service. The proxy does not wait for responses from the
    /// shadow service. Prior to sending traffic to the shadow service, the
    /// host/authority header is suffixed with -shadow.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RequestMirrorPolicy {
        /// The destination the requests will be mirrored to. The weight of the
        /// destination will be ignored.
        #[prost(message, optional, tag = "1")]
        pub destination: ::core::option::Option<Destination>,
    }
    /// The Specification for allowing client side cross-origin requests.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct CorsPolicy {
        /// Specifies the list of origins that will be allowed to do CORS requests.
        /// An origin is allowed if it matches either an item in allow_origins or
        /// an item in allow_origin_regexes.
        #[prost(string, repeated, tag = "1")]
        pub allow_origins: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Specifies the regular expression patterns that match allowed origins. For
        /// regular expression grammar, please see
        /// <https://github.com/google/re2/wiki/Syntax.>
        #[prost(string, repeated, tag = "2")]
        pub allow_origin_regexes: ::prost::alloc::vec::Vec<
            ::prost::alloc::string::String,
        >,
        /// Specifies the content for Access-Control-Allow-Methods header.
        #[prost(string, repeated, tag = "3")]
        pub allow_methods: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Specifies the content for Access-Control-Allow-Headers header.
        #[prost(string, repeated, tag = "4")]
        pub allow_headers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Specifies the content for Access-Control-Expose-Headers header.
        #[prost(string, repeated, tag = "5")]
        pub expose_headers: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Specifies how long result of a preflight request can be cached in
        /// seconds. This translates to the Access-Control-Max-Age header.
        #[prost(string, tag = "6")]
        pub max_age: ::prost::alloc::string::String,
        /// In response to a preflight request, setting this to true indicates that
        /// the actual request can include user credentials. This translates to the
        /// Access-Control-Allow-Credentials header.
        ///
        /// Default value is false.
        #[prost(bool, tag = "7")]
        pub allow_credentials: bool,
        /// If true, the CORS policy is disabled. The default value is false, which
        /// indicates that the CORS policy is in effect.
        #[prost(bool, tag = "8")]
        pub disabled: bool,
    }
    /// The specifications for routing traffic and applying associated policies.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteAction {
        /// The destination to which traffic should be forwarded.
        #[prost(message, repeated, tag = "1")]
        pub destinations: ::prost::alloc::vec::Vec<Destination>,
        /// If set, the request is directed as configured by this field.
        #[prost(message, optional, tag = "2")]
        pub redirect: ::core::option::Option<Redirect>,
        /// The specification for fault injection introduced into traffic to test the
        /// resiliency of clients to backend service failure. As part of fault
        /// injection, when clients send requests to a backend service, delays can be
        /// introduced  on a percentage of requests before sending those requests to
        /// the backend service. Similarly requests from clients can be aborted for a
        /// percentage of requests.
        ///
        /// timeout and retry_policy will be ignored by clients that are configured
        /// with a fault_injection_policy
        #[prost(message, optional, tag = "4")]
        pub fault_injection_policy: ::core::option::Option<FaultInjectionPolicy>,
        /// The specification for modifying the headers of a matching request prior
        /// to delivery of the request to the destination.
        #[prost(message, optional, tag = "5")]
        pub request_header_modifier: ::core::option::Option<HeaderModifier>,
        /// The specification for modifying the headers of a response prior to
        /// sending the response back to the client.
        #[prost(message, optional, tag = "6")]
        pub response_header_modifier: ::core::option::Option<HeaderModifier>,
        /// The specification for rewrite URL before forwarding requests to the
        /// destination.
        #[prost(message, optional, tag = "7")]
        pub url_rewrite: ::core::option::Option<UrlRewrite>,
        /// Specifies the timeout for selected route. Timeout is computed from the
        /// time the request has been fully processed (i.e. end of stream) up until
        /// the response has been completely processed. Timeout includes all retries.
        #[prost(message, optional, tag = "8")]
        pub timeout: ::core::option::Option<::pbjson_types::Duration>,
        /// Specifies the retry policy associated with this route.
        #[prost(message, optional, tag = "9")]
        pub retry_policy: ::core::option::Option<RetryPolicy>,
        /// Specifies the policy on how requests intended for the routes destination
        /// are shadowed to a separate mirrored destination. Proxy will not wait for
        /// the shadow destination to respond before returning the response. Prior to
        /// sending traffic to the shadow service, the host/authority header is
        /// suffixed with -shadow.
        #[prost(message, optional, tag = "10")]
        pub request_mirror_policy: ::core::option::Option<RequestMirrorPolicy>,
        /// The specification for allowing client side cross-origin requests.
        #[prost(message, optional, tag = "11")]
        pub cors_policy: ::core::option::Option<CorsPolicy>,
    }
    /// Specifies how to match traffic and how to route traffic when traffic is
    /// matched.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteRule {
        /// A list of matches define conditions used for matching the rule against
        /// incoming HTTP requests. Each match is independent, i.e. this rule will be
        /// matched if ANY one of the matches is satisfied.
        ///
        /// If no matches field is specified, this rule will unconditionally match
        /// traffic.
        ///
        /// If a default rule is desired to be configured, add a rule with no matches
        /// specified to the end of the rules list.
        #[prost(message, repeated, tag = "1")]
        pub matches: ::prost::alloc::vec::Vec<RouteMatch>,
        /// The detailed rule defining how to route matched traffic.
        #[prost(message, optional, tag = "2")]
        pub action: ::core::option::Option<RouteAction>,
    }
}
/// Mesh represents a logical configuration grouping for workload to workload
/// communication within a service mesh. Routes that point to mesh dictate how
/// requests are routed within this logical mesh boundary.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mesh {
    /// Required. Name of the Mesh resource. It matches pattern
    /// `projects/*/locations/global/meshes/<mesh_name>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server-defined URL of this resource
    #[prost(string, tag = "9")]
    pub self_link: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Output only. The timestamp when the resource was updated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Optional. Set of label tags associated with the Mesh resource.
    #[prost(map = "string, string", tag = "4")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Optional. A free-text description of the resource. Max length 1024
    /// characters.
    #[prost(string, tag = "5")]
    pub description: ::prost::alloc::string::String,
    /// Optional. If set to a valid TCP port (1-65535), instructs the SIDECAR proxy
    /// to listen on the specified port of localhost (127.0.0.1) address. The
    /// SIDECAR proxy will expect all traffic to be redirected to this port
    /// regardless of its actual ip:port destination. If unset, a port '15001' is
    /// used as the interception port. This is applicable only for sidecar proxy
    /// deployments.
    #[prost(int32, tag = "8")]
    pub interception_port: i32,
}
/// ServiceBinding is the resource that defines a Service Directory Service to
/// be used in a BackendService resource.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceBinding {
    /// Required. Name of the ServiceBinding resource. It matches pattern
    /// `projects/*/locations/global/serviceBindings/service_binding_name`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. A free-text description of the resource. Max length 1024
    /// characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    #[prost(message, optional, tag = "3")]
    pub create_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Output only. The timestamp when the resource was updated.
    #[prost(message, optional, tag = "4")]
    pub update_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Required. The full Service Directory Service name of the format
    /// projects/*/locations/*/namespaces/*/services/*
    #[prost(string, tag = "5")]
    pub service: ::prost::alloc::string::String,
    /// Output only. The unique identifier of the Service Directory Service against
    /// which the Service Binding resource is validated. This is populated when the
    /// Service Binding resource is used in another resource (like Backend
    /// Service). This is of the UUID4 format.
    #[prost(string, tag = "8")]
    pub service_id: ::prost::alloc::string::String,
    /// Optional. Set of label tags associated with the ServiceBinding resource.
    #[prost(map = "string, string", tag = "7")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// TcpRoute is the resource defining how TCP traffic should be routed by a
/// Mesh/Gateway resource.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TcpRoute {
    /// Required. Name of the TcpRoute resource. It matches pattern
    /// `projects/*/locations/global/tcpRoutes/tcp_route_name>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server-defined URL of this resource
    #[prost(string, tag = "11")]
    pub self_link: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Output only. The timestamp when the resource was updated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Optional. A free-text description of the resource. Max length 1024
    /// characters.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Required. Rules that define how traffic is routed and handled. At least one
    /// RouteRule must be supplied. If there are multiple rules then the action
    /// taken will be the first rule to match.
    #[prost(message, repeated, tag = "5")]
    pub rules: ::prost::alloc::vec::Vec<tcp_route::RouteRule>,
    /// Optional. Meshes defines a list of meshes this TcpRoute is attached to, as
    /// one of the routing rules to route the requests served by the mesh.
    ///
    /// Each mesh reference should match the pattern:
    /// `projects/*/locations/global/meshes/<mesh_name>`
    ///
    /// The attached Mesh should be of a type SIDECAR
    #[prost(string, repeated, tag = "8")]
    pub meshes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Gateways defines a list of gateways this TcpRoute is attached to,
    /// as one of the routing rules to route the requests served by the gateway.
    ///
    /// Each gateway reference should match the pattern:
    /// `projects/*/locations/global/gateways/<gateway_name>`
    #[prost(string, repeated, tag = "9")]
    pub gateways: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Set of label tags associated with the TcpRoute resource.
    #[prost(map = "string, string", tag = "10")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `TcpRoute`.
pub mod tcp_route {
    /// Specifies how to match traffic and how to route traffic when traffic is
    /// matched.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteRule {
        /// Optional. RouteMatch defines the predicate used to match requests to a
        /// given action. Multiple match types are "OR"ed for evaluation. If no
        /// routeMatch field is specified, this rule will unconditionally match
        /// traffic.
        #[prost(message, repeated, tag = "1")]
        pub matches: ::prost::alloc::vec::Vec<RouteMatch>,
        /// Required. The detailed rule defining how to route matched traffic.
        #[prost(message, optional, tag = "2")]
        pub action: ::core::option::Option<RouteAction>,
    }
    /// RouteMatch defines the predicate used to match requests to a given action.
    /// Multiple match types are "OR"ed for evaluation.
    /// If no routeMatch field is specified, this rule will unconditionally match
    /// traffic.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteMatch {
        /// Required. Must be specified in the CIDR range format. A CIDR range
        /// consists of an IP Address and a prefix length to construct the subnet
        /// mask. By default, the prefix length is 32 (i.e. matches a single IP
        /// address). Only IPV4 addresses are supported. Examples: "10.0.0.1" -
        /// matches against this exact IP address. "10.0.0.0/8" - matches against any
        /// IP address within the 10.0.0.0 subnet and 255.255.255.0 mask. "0.0.0.0/0"
        /// - matches against any IP address'.
        #[prost(string, tag = "1")]
        pub address: ::prost::alloc::string::String,
        /// Required. Specifies the destination port to match against.
        #[prost(string, tag = "2")]
        pub port: ::prost::alloc::string::String,
    }
    /// The specifications for routing traffic and applying associated policies.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteAction {
        /// Optional. The destination services to which traffic should be forwarded.
        /// At least one destination service is required. Only one of route
        /// destination or original destination can be set.
        #[prost(message, repeated, tag = "1")]
        pub destinations: ::prost::alloc::vec::Vec<RouteDestination>,
        /// Optional. If true, Router will use the destination IP and port of the
        /// original connection as the destination of the request. Default is false.
        /// Only one of route destinations or original destination can be set.
        #[prost(bool, tag = "3")]
        pub original_destination: bool,
    }
    /// Describe the destination for traffic to be routed to.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteDestination {
        /// Required. The URL of a BackendService to route traffic to.
        #[prost(string, tag = "1")]
        pub service_name: ::prost::alloc::string::String,
        /// Optional. Specifies the proportion of requests forwarded to the backend
        /// referenced by the serviceName field. This is computed as:
        ///          weight/Sum(weights in this destination list).
        /// For non-zero values, there may be some epsilon from the exact proportion
        /// defined here depending on the precision an implementation supports.
        ///
        /// If only one serviceName is specified and it has a weight greater than 0,
        /// 100% of the traffic is forwarded to that backend.
        ///
        /// If weights are specified for any one service name, they need to be
        /// specified for all of them.
        ///
        /// If weights are unspecified for all services, then, traffic is distributed
        /// in equal proportions to all of them.
        #[prost(int32, tag = "2")]
        pub weight: i32,
    }
}
/// TlsRoute defines how traffic should be routed based on SNI and other matching
/// L3 attributes.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TlsRoute {
    /// Required. Name of the TlsRoute resource. It matches pattern
    /// `projects/*/locations/global/tlsRoutes/tls_route_name>`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. Server-defined URL of this resource
    #[prost(string, tag = "8")]
    pub self_link: ::prost::alloc::string::String,
    /// Output only. The timestamp when the resource was created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Output only. The timestamp when the resource was updated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::pbjson_types::Timestamp>,
    /// Optional. A free-text description of the resource. Max length 1024
    /// characters.
    #[prost(string, tag = "4")]
    pub description: ::prost::alloc::string::String,
    /// Required. Rules that define how traffic is routed and handled. At least one
    /// RouteRule must be supplied. If there are multiple rules then the action
    /// taken will be the first rule to match.
    #[prost(message, repeated, tag = "5")]
    pub rules: ::prost::alloc::vec::Vec<tls_route::RouteRule>,
    /// Optional. Meshes defines a list of meshes this TlsRoute is attached to, as
    /// one of the routing rules to route the requests served by the mesh.
    ///
    /// Each mesh reference should match the pattern:
    /// `projects/*/locations/global/meshes/<mesh_name>`
    ///
    /// The attached Mesh should be of a type SIDECAR
    #[prost(string, repeated, tag = "6")]
    pub meshes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Gateways defines a list of gateways this TlsRoute is attached to,
    /// as one of the routing rules to route the requests served by the gateway.
    ///
    /// Each gateway reference should match the pattern:
    /// `projects/*/locations/global/gateways/<gateway_name>`
    #[prost(string, repeated, tag = "7")]
    pub gateways: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `TlsRoute`.
pub mod tls_route {
    /// Specifies how to match traffic and how to route traffic when traffic is
    /// matched.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteRule {
        /// Required. RouteMatch defines the predicate used to match requests to a
        /// given action. Multiple match types are "OR"ed for evaluation.
        #[prost(message, repeated, tag = "1")]
        pub matches: ::prost::alloc::vec::Vec<RouteMatch>,
        /// Required. The detailed rule defining how to route matched traffic.
        #[prost(message, optional, tag = "2")]
        pub action: ::core::option::Option<RouteAction>,
    }
    /// RouteMatch defines the predicate used to match requests to a given action.
    /// Multiple match types are "AND"ed for evaluation.
    /// If no routeMatch field is specified, this rule will unconditionally match
    /// traffic.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteMatch {
        /// Optional. SNI (server name indicator) to match against.
        /// SNI will be matched against all wildcard domains, i.e. `www.example.com`
        /// will be first matched against `www.example.com`, then `*.example.com`,
        /// then `*.com.`
        /// Partial wildcards are not supported, and values like *w.example.com are
        /// invalid.
        /// At least one of sni_host and alpn is required.
        /// Up to 5 sni hosts across all matches can be set.
        #[prost(string, repeated, tag = "1")]
        pub sni_host: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
        /// Optional. ALPN (Application-Layer Protocol Negotiation) to match against.
        /// Examples: "http/1.1", "h2".
        /// At least one of sni_host and alpn is required.
        /// Up to 5 alpns across all matches can be set.
        #[prost(string, repeated, tag = "2")]
        pub alpn: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    }
    /// The specifications for routing traffic and applying associated policies.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteAction {
        /// Required. The destination services to which traffic should be forwarded.
        /// At least one destination service is required.
        #[prost(message, repeated, tag = "1")]
        pub destinations: ::prost::alloc::vec::Vec<RouteDestination>,
    }
    /// Describe the destination for traffic to be routed to.
    #[derive(serde::Serialize, serde::Deserialize)]
    #[serde(default)]
    #[serde(rename_all = "snake_case")]
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct RouteDestination {
        /// Required. The URL of a BackendService to route traffic to.
        #[prost(string, tag = "1")]
        pub service_name: ::prost::alloc::string::String,
        /// Optional. Specifies the proportion of requests forwareded to the backend
        /// referenced by the service_name field. This is computed as:
        ///          weight/Sum(weights in destinations)
        /// Weights in all destinations does not need to sum up to 100.
        #[prost(int32, tag = "2")]
        pub weight: i32,
    }
}
/// The data within all EndpointPolicy events.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndpointPolicyEventData {
    /// Optional. The EndpointPolicy event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<EndpointPolicy>,
}
/// The data within all HttpRoute events.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpRouteEventData {
    /// Optional. The HttpRoute event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<HttpRoute>,
}
/// The data within all ServiceBinding events.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceBindingEventData {
    /// Optional. The ServiceBinding event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<ServiceBinding>,
}
/// The data within all Gateway events.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GatewayEventData {
    /// Optional. The Gateway event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<Gateway>,
}
/// The data within all TlsRoute events.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TlsRouteEventData {
    /// Optional. The TlsRoute event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<TlsRoute>,
}
/// The data within all GrpcRoute events.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GrpcRouteEventData {
    /// Optional. The GrpcRoute event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<GrpcRoute>,
}
/// The data within all Mesh events.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MeshEventData {
    /// Optional. The Mesh event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<Mesh>,
}
/// The data within all TcpRoute events.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TcpRouteEventData {
    /// Optional. The TcpRoute event payload. Unset for deletion events.
    #[prost(message, optional, tag = "1")]
    pub payload: ::core::option::Option<TcpRoute>,
}
/// The CloudEvent raised when an EndpointPolicy is created.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndpointPolicyCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<EndpointPolicyEventData>,
}
/// The CloudEvent raised when an EndpointPolicy is updated.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndpointPolicyUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<EndpointPolicyEventData>,
}
/// The CloudEvent raised when an EndpointPolicy is deleted.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndpointPolicyDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<EndpointPolicyEventData>,
}
/// The CloudEvent raised when a Gateway is created.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GatewayCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<GatewayEventData>,
}
/// The CloudEvent raised when a Gateway is updated.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GatewayUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<GatewayEventData>,
}
/// The CloudEvent raised when a Gateway is deleted.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GatewayDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<GatewayEventData>,
}
/// The CloudEvent raised when a GrpcRoute is created.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GrpcRouteCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<GrpcRouteEventData>,
}
/// The CloudEvent raised when a GrpcRoute is updated.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GrpcRouteUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<GrpcRouteEventData>,
}
/// The CloudEvent raised when a GrpcRoute is deleted.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GrpcRouteDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<GrpcRouteEventData>,
}
/// The CloudEvent raised when a HttpRoute is created.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpRouteCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<HttpRouteEventData>,
}
/// The CloudEvent raised when a HttpRoute is updated.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpRouteUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<HttpRouteEventData>,
}
/// The CloudEvent raised when a HttpRoute is deleted.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HttpRouteDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<HttpRouteEventData>,
}
/// The CloudEvent raised when a TcpRoute is created.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TcpRouteCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<TcpRouteEventData>,
}
/// The CloudEvent raised when a TcpRoute is updated.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TcpRouteUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<TcpRouteEventData>,
}
/// The CloudEvent raised when a TcpRoute is deleted.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TcpRouteDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<TcpRouteEventData>,
}
/// The CloudEvent raised when a TlsRoute is created.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TlsRouteCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<TlsRouteEventData>,
}
/// The CloudEvent raised when a TlsRoute is updated.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TlsRouteUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<TlsRouteEventData>,
}
/// The CloudEvent raised when a TlsRoute is deleted.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TlsRouteDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<TlsRouteEventData>,
}
/// The CloudEvent raised when a ServiceBinding is created.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceBindingCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<ServiceBindingEventData>,
}
/// The CloudEvent raised when a ServiceBinding is deleted.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ServiceBindingDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<ServiceBindingEventData>,
}
/// The CloudEvent raised when a Mesh is created.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MeshCreatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<MeshEventData>,
}
/// The CloudEvent raised when a Mesh is updated.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MeshUpdatedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<MeshEventData>,
}
/// The CloudEvent raised when a Mesh is deleted.
#[derive(serde::Serialize, serde::Deserialize)]
#[serde(default)]
#[serde(rename_all = "snake_case")]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MeshDeletedEvent {
    /// The data associated with the event.
    #[prost(message, optional, tag = "1")]
    pub data: ::core::option::Option<MeshEventData>,
}