// This file is @generated by prost-build.
/// Trace represents one simulated packet forwarding path.
///
/// * Each trace contains multiple ordered steps.
/// * Each step is in a particular state with associated configuration.
/// * State is categorized as final or non-final states.
/// * Each final state has a reason associated.
/// * Each trace must end with a final state (the last step).
///
/// ```text,
///   |---------------------Trace----------------------|
///   Step1(State) Step2(State) ---  StepN(State(final))
/// ```
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Trace {
    /// Derived from the source and destination endpoints definition specified by
    /// user request, and validated by the data plane model.
    /// If there are multiple traces starting from different source locations, then
    /// the endpoint_info may be different between traces.
    #[prost(message, optional, tag = "1")]
    pub endpoint_info: ::core::option::Option<EndpointInfo>,
    /// A trace of a test contains multiple steps from the initial state to the
    /// final state (delivered, dropped, forwarded, or aborted).
    ///
    /// The steps are ordered by the processing sequence within the simulated
    /// network state machine. It is critical to preserve the order of the steps
    /// and avoid reordering or sorting them.
    #[prost(message, repeated, tag = "2")]
    pub steps: ::prost::alloc::vec::Vec<Step>,
    /// ID of trace. For forward traces, this ID is unique for each trace. For
    /// return traces, it matches ID of associated forward trace. A single forward
    /// trace can be associated with none, one or more than one return trace.
    #[prost(int32, tag = "4")]
    pub forward_trace_id: i32,
}
/// A simulated forwarding path is composed of multiple steps.
/// Each step has a well-defined state and an associated configuration.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Step {
    /// A description of the step. Usually this is a summary of the state.
    #[prost(string, tag = "1")]
    pub description: ::prost::alloc::string::String,
    /// Each step is in one of the pre-defined states.
    #[prost(enumeration = "step::State", tag = "2")]
    pub state: i32,
    /// This is a step that leads to the final state Drop.
    #[prost(bool, tag = "3")]
    pub causes_drop: bool,
    /// Project ID that contains the configuration this step is validating.
    #[prost(string, tag = "4")]
    pub project_id: ::prost::alloc::string::String,
    /// Configuration or metadata associated with each step.
    /// The configuration is filtered based on viewer's permission. If a viewer
    /// has no permission to view the configuration in this step, for non-final
    /// states a special state is populated (VIEWER_PERMISSION_MISSING), and for
    /// final state the configuration is cleared.
    #[prost(
        oneof = "step::StepInfo",
        tags = "5, 6, 7, 8, 24, 9, 36, 10, 11, 35, 21, 33, 34, 12, 13, 14, 15, 16, 17, 18, 37, 38, 39, 40, 19, 30, 31, 20, 22, 23, 25, 26, 27, 28, 29, 42"
    )]
    pub step_info: ::core::option::Option<step::StepInfo>,
}
/// Nested message and enum types in `Step`.
pub mod step {
    /// Type of states that are defined in the network state machine.
    /// Each step in the packet trace is in a specific state.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// Unspecified state.
        Unspecified = 0,
        /// Initial state: packet originating from a Compute Engine instance.
        /// An InstanceInfo is populated with starting instance information.
        StartFromInstance = 1,
        /// Initial state: packet originating from the internet.
        /// The endpoint information is populated.
        StartFromInternet = 2,
        /// Initial state: packet originating from a Google service.
        /// The google_service information is populated.
        StartFromGoogleService = 27,
        /// Initial state: packet originating from a VPC or on-premises network
        /// with internal source IP.
        /// If the source is a VPC network visible to the user, a NetworkInfo
        /// is populated with details of the network.
        StartFromPrivateNetwork = 3,
        /// Initial state: packet originating from a Google Kubernetes Engine cluster
        /// master. A GKEMasterInfo is populated with starting instance information.
        StartFromGkeMaster = 21,
        /// Initial state: packet originating from a Cloud SQL instance.
        /// A CloudSQLInstanceInfo is populated with starting instance information.
        StartFromCloudSqlInstance = 22,
        /// Initial state: packet originating from a Google Kubernetes Engine Pod.
        /// A GkePodInfo is populated with starting Pod information.
        StartFromGkePod = 39,
        /// Initial state: packet originating from a Redis instance.
        /// A RedisInstanceInfo is populated with starting instance information.
        StartFromRedisInstance = 32,
        /// Initial state: packet originating from a Redis Cluster.
        /// A RedisClusterInfo is populated with starting Cluster information.
        StartFromRedisCluster = 33,
        /// Initial state: packet originating from a Cloud Function.
        /// A CloudFunctionInfo is populated with starting function information.
        StartFromCloudFunction = 23,
        /// Initial state: packet originating from an App Engine service version.
        /// An AppEngineVersionInfo is populated with starting version information.
        StartFromAppEngineVersion = 25,
        /// Initial state: packet originating from a Cloud Run revision.
        /// A CloudRunRevisionInfo is populated with starting revision information.
        StartFromCloudRunRevision = 26,
        /// Initial state: packet originating from a Storage Bucket. Used only for
        /// return traces.
        /// The storage_bucket information is populated.
        StartFromStorageBucket = 29,
        /// Initial state: packet originating from a published service that uses
        /// Private Service Connect. Used only for return traces.
        StartFromPscPublishedService = 30,
        /// Initial state: packet originating from a serverless network endpoint
        /// group backend. Used only for return traces.
        /// The serverless_neg information is populated.
        StartFromServerlessNeg = 31,
        /// Config checking state: verify ingress firewall rule.
        ApplyIngressFirewallRule = 4,
        /// Config checking state: verify egress firewall rule.
        ApplyEgressFirewallRule = 5,
        /// Config checking state: verify route.
        ApplyRoute = 6,
        /// Config checking state: match forwarding rule.
        ApplyForwardingRule = 7,
        /// Config checking state: verify load balancer backend configuration.
        AnalyzeLoadBalancerBackend = 28,
        /// Config checking state: packet sent or received under foreign IP
        /// address and allowed.
        SpoofingApproved = 8,
        /// Forwarding state: arriving at a Compute Engine instance.
        ArriveAtInstance = 9,
        /// Forwarding state: arriving at a Compute Engine internal load balancer.
        /// Deprecated in favor of the `ANALYZE_LOAD_BALANCER_BACKEND` state, not
        /// used in new tests.
        #[deprecated]
        ArriveAtInternalLoadBalancer = 10,
        /// Forwarding state: arriving at a Compute Engine external load balancer.
        /// Deprecated in favor of the `ANALYZE_LOAD_BALANCER_BACKEND` state, not
        /// used in new tests.
        #[deprecated]
        ArriveAtExternalLoadBalancer = 11,
        /// Forwarding state: arriving at a hybrid subnet. Appropriate routing
        /// configuration will be determined here.
        ArriveAtHybridSubnet = 38,
        /// Forwarding state: arriving at a Cloud VPN gateway.
        ArriveAtVpnGateway = 12,
        /// Forwarding state: arriving at a Cloud VPN tunnel.
        ArriveAtVpnTunnel = 13,
        /// Forwarding state: arriving at an interconnect attachment.
        ArriveAtInterconnectAttachment = 37,
        /// Forwarding state: arriving at a VPC connector.
        ArriveAtVpcConnector = 24,
        /// Forwarding state: arriving at a GKE Pod.
        ArriveAtGkePod = 44,
        /// Forwarding state: for packets originating from a serverless endpoint
        /// forwarded through Direct VPC egress.
        DirectVpcEgressConnection = 35,
        /// Forwarding state: for packets originating from a serverless endpoint
        /// forwarded through public (external) connectivity.
        ServerlessExternalConnection = 36,
        /// Forwarding state: Layer 7 packet inspection by the firewall endpoint
        /// based on the configured security profile group.
        NgfwPacketInspection = 47,
        /// Transition state: packet header translated. The `nat` field is populated
        /// with the translation information.
        Nat = 14,
        /// Transition state: GKE Pod IP masquerading is skipped. The
        /// `ip_masquerading_skipped` field is populated with the reason.
        SkipGkePodIpMasquerading = 40,
        /// Transition state: GKE Ingress Network Policy is skipped. The
        /// `gke_network_policy_skipped` field is populated with the reason.
        SkipGkeIngressNetworkPolicy = 41,
        /// Transition state: GKE Egress Network Policy is skipped. The
        /// `gke_network_policy_skipped` field is populated with the reason.
        SkipGkeEgressNetworkPolicy = 42,
        /// Config checking state: verify ingress GKE network policy.
        ApplyIngressGkeNetworkPolicy = 45,
        /// Config checking state: verify egress GKE network policy.
        ApplyEgressGkeNetworkPolicy = 46,
        /// Transition state: original connection is terminated and a new proxied
        /// connection is initiated.
        ProxyConnection = 15,
        /// Final state: packet could be delivered.
        Deliver = 16,
        /// Final state: packet could be dropped.
        Drop = 17,
        /// Final state: packet could be forwarded to a network with an unknown
        /// configuration.
        Forward = 18,
        /// Final state: analysis is aborted.
        Abort = 19,
        /// Special state: viewer of the test result does not have permission to
        /// see the configuration in this step.
        ViewerPermissionMissing = 20,
    }
    impl State {
        /// 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 => "STATE_UNSPECIFIED",
                Self::StartFromInstance => "START_FROM_INSTANCE",
                Self::StartFromInternet => "START_FROM_INTERNET",
                Self::StartFromGoogleService => "START_FROM_GOOGLE_SERVICE",
                Self::StartFromPrivateNetwork => "START_FROM_PRIVATE_NETWORK",
                Self::StartFromGkeMaster => "START_FROM_GKE_MASTER",
                Self::StartFromCloudSqlInstance => "START_FROM_CLOUD_SQL_INSTANCE",
                Self::StartFromGkePod => "START_FROM_GKE_POD",
                Self::StartFromRedisInstance => "START_FROM_REDIS_INSTANCE",
                Self::StartFromRedisCluster => "START_FROM_REDIS_CLUSTER",
                Self::StartFromCloudFunction => "START_FROM_CLOUD_FUNCTION",
                Self::StartFromAppEngineVersion => "START_FROM_APP_ENGINE_VERSION",
                Self::StartFromCloudRunRevision => "START_FROM_CLOUD_RUN_REVISION",
                Self::StartFromStorageBucket => "START_FROM_STORAGE_BUCKET",
                Self::StartFromPscPublishedService => "START_FROM_PSC_PUBLISHED_SERVICE",
                Self::StartFromServerlessNeg => "START_FROM_SERVERLESS_NEG",
                Self::ApplyIngressFirewallRule => "APPLY_INGRESS_FIREWALL_RULE",
                Self::ApplyEgressFirewallRule => "APPLY_EGRESS_FIREWALL_RULE",
                Self::ApplyRoute => "APPLY_ROUTE",
                Self::ApplyForwardingRule => "APPLY_FORWARDING_RULE",
                Self::AnalyzeLoadBalancerBackend => "ANALYZE_LOAD_BALANCER_BACKEND",
                Self::SpoofingApproved => "SPOOFING_APPROVED",
                Self::ArriveAtInstance => "ARRIVE_AT_INSTANCE",
                #[allow(deprecated)]
                Self::ArriveAtInternalLoadBalancer => "ARRIVE_AT_INTERNAL_LOAD_BALANCER",
                #[allow(deprecated)]
                Self::ArriveAtExternalLoadBalancer => "ARRIVE_AT_EXTERNAL_LOAD_BALANCER",
                Self::ArriveAtHybridSubnet => "ARRIVE_AT_HYBRID_SUBNET",
                Self::ArriveAtVpnGateway => "ARRIVE_AT_VPN_GATEWAY",
                Self::ArriveAtVpnTunnel => "ARRIVE_AT_VPN_TUNNEL",
                Self::ArriveAtInterconnectAttachment => {
                    "ARRIVE_AT_INTERCONNECT_ATTACHMENT"
                }
                Self::ArriveAtVpcConnector => "ARRIVE_AT_VPC_CONNECTOR",
                Self::ArriveAtGkePod => "ARRIVE_AT_GKE_POD",
                Self::DirectVpcEgressConnection => "DIRECT_VPC_EGRESS_CONNECTION",
                Self::ServerlessExternalConnection => "SERVERLESS_EXTERNAL_CONNECTION",
                Self::NgfwPacketInspection => "NGFW_PACKET_INSPECTION",
                Self::Nat => "NAT",
                Self::SkipGkePodIpMasquerading => "SKIP_GKE_POD_IP_MASQUERADING",
                Self::SkipGkeIngressNetworkPolicy => "SKIP_GKE_INGRESS_NETWORK_POLICY",
                Self::SkipGkeEgressNetworkPolicy => "SKIP_GKE_EGRESS_NETWORK_POLICY",
                Self::ApplyIngressGkeNetworkPolicy => "APPLY_INGRESS_GKE_NETWORK_POLICY",
                Self::ApplyEgressGkeNetworkPolicy => "APPLY_EGRESS_GKE_NETWORK_POLICY",
                Self::ProxyConnection => "PROXY_CONNECTION",
                Self::Deliver => "DELIVER",
                Self::Drop => "DROP",
                Self::Forward => "FORWARD",
                Self::Abort => "ABORT",
                Self::ViewerPermissionMissing => "VIEWER_PERMISSION_MISSING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "START_FROM_INSTANCE" => Some(Self::StartFromInstance),
                "START_FROM_INTERNET" => Some(Self::StartFromInternet),
                "START_FROM_GOOGLE_SERVICE" => Some(Self::StartFromGoogleService),
                "START_FROM_PRIVATE_NETWORK" => Some(Self::StartFromPrivateNetwork),
                "START_FROM_GKE_MASTER" => Some(Self::StartFromGkeMaster),
                "START_FROM_CLOUD_SQL_INSTANCE" => Some(Self::StartFromCloudSqlInstance),
                "START_FROM_GKE_POD" => Some(Self::StartFromGkePod),
                "START_FROM_REDIS_INSTANCE" => Some(Self::StartFromRedisInstance),
                "START_FROM_REDIS_CLUSTER" => Some(Self::StartFromRedisCluster),
                "START_FROM_CLOUD_FUNCTION" => Some(Self::StartFromCloudFunction),
                "START_FROM_APP_ENGINE_VERSION" => Some(Self::StartFromAppEngineVersion),
                "START_FROM_CLOUD_RUN_REVISION" => Some(Self::StartFromCloudRunRevision),
                "START_FROM_STORAGE_BUCKET" => Some(Self::StartFromStorageBucket),
                "START_FROM_PSC_PUBLISHED_SERVICE" => {
                    Some(Self::StartFromPscPublishedService)
                }
                "START_FROM_SERVERLESS_NEG" => Some(Self::StartFromServerlessNeg),
                "APPLY_INGRESS_FIREWALL_RULE" => Some(Self::ApplyIngressFirewallRule),
                "APPLY_EGRESS_FIREWALL_RULE" => Some(Self::ApplyEgressFirewallRule),
                "APPLY_ROUTE" => Some(Self::ApplyRoute),
                "APPLY_FORWARDING_RULE" => Some(Self::ApplyForwardingRule),
                "ANALYZE_LOAD_BALANCER_BACKEND" => Some(Self::AnalyzeLoadBalancerBackend),
                "SPOOFING_APPROVED" => Some(Self::SpoofingApproved),
                "ARRIVE_AT_INSTANCE" => Some(Self::ArriveAtInstance),
                "ARRIVE_AT_INTERNAL_LOAD_BALANCER" => {
                    Some(#[allow(deprecated)] Self::ArriveAtInternalLoadBalancer)
                }
                "ARRIVE_AT_EXTERNAL_LOAD_BALANCER" => {
                    Some(#[allow(deprecated)] Self::ArriveAtExternalLoadBalancer)
                }
                "ARRIVE_AT_HYBRID_SUBNET" => Some(Self::ArriveAtHybridSubnet),
                "ARRIVE_AT_VPN_GATEWAY" => Some(Self::ArriveAtVpnGateway),
                "ARRIVE_AT_VPN_TUNNEL" => Some(Self::ArriveAtVpnTunnel),
                "ARRIVE_AT_INTERCONNECT_ATTACHMENT" => {
                    Some(Self::ArriveAtInterconnectAttachment)
                }
                "ARRIVE_AT_VPC_CONNECTOR" => Some(Self::ArriveAtVpcConnector),
                "ARRIVE_AT_GKE_POD" => Some(Self::ArriveAtGkePod),
                "DIRECT_VPC_EGRESS_CONNECTION" => Some(Self::DirectVpcEgressConnection),
                "SERVERLESS_EXTERNAL_CONNECTION" => {
                    Some(Self::ServerlessExternalConnection)
                }
                "NGFW_PACKET_INSPECTION" => Some(Self::NgfwPacketInspection),
                "NAT" => Some(Self::Nat),
                "SKIP_GKE_POD_IP_MASQUERADING" => Some(Self::SkipGkePodIpMasquerading),
                "SKIP_GKE_INGRESS_NETWORK_POLICY" => {
                    Some(Self::SkipGkeIngressNetworkPolicy)
                }
                "SKIP_GKE_EGRESS_NETWORK_POLICY" => {
                    Some(Self::SkipGkeEgressNetworkPolicy)
                }
                "APPLY_INGRESS_GKE_NETWORK_POLICY" => {
                    Some(Self::ApplyIngressGkeNetworkPolicy)
                }
                "APPLY_EGRESS_GKE_NETWORK_POLICY" => {
                    Some(Self::ApplyEgressGkeNetworkPolicy)
                }
                "PROXY_CONNECTION" => Some(Self::ProxyConnection),
                "DELIVER" => Some(Self::Deliver),
                "DROP" => Some(Self::Drop),
                "FORWARD" => Some(Self::Forward),
                "ABORT" => Some(Self::Abort),
                "VIEWER_PERMISSION_MISSING" => Some(Self::ViewerPermissionMissing),
                _ => None,
            }
        }
    }
    /// Configuration or metadata associated with each step.
    /// The configuration is filtered based on viewer's permission. If a viewer
    /// has no permission to view the configuration in this step, for non-final
    /// states a special state is populated (VIEWER_PERMISSION_MISSING), and for
    /// final state the configuration is cleared.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum StepInfo {
        /// Display information of a Compute Engine instance.
        #[prost(message, tag = "5")]
        Instance(super::InstanceInfo),
        /// Display information of a Compute Engine firewall rule.
        #[prost(message, tag = "6")]
        Firewall(super::FirewallInfo),
        /// Display information of a Compute Engine route.
        #[prost(message, tag = "7")]
        Route(super::RouteInfo),
        /// Display information of the source and destination under analysis.
        /// The endpoint information in an intermediate state may differ with the
        /// initial input, as it might be modified by state like NAT,
        /// or Connection Proxy.
        #[prost(message, tag = "8")]
        Endpoint(super::EndpointInfo),
        /// Display information of a Google service
        #[prost(message, tag = "24")]
        GoogleService(super::GoogleServiceInfo),
        /// Display information of a Compute Engine forwarding rule.
        #[prost(message, tag = "9")]
        ForwardingRule(super::ForwardingRuleInfo),
        /// Display information of a hybrid subnet.
        #[prost(message, tag = "36")]
        HybridSubnet(super::HybridSubnetInfo),
        /// Display information of a Compute Engine VPN gateway.
        #[prost(message, tag = "10")]
        VpnGateway(super::VpnGatewayInfo),
        /// Display information of a Compute Engine VPN tunnel.
        #[prost(message, tag = "11")]
        VpnTunnel(super::VpnTunnelInfo),
        /// Display information of an interconnect attachment.
        #[prost(message, tag = "35")]
        InterconnectAttachment(super::InterconnectAttachmentInfo),
        /// Display information of a VPC connector.
        #[prost(message, tag = "21")]
        VpcConnector(super::VpcConnectorInfo),
        /// Display information of a serverless direct VPC egress connection.
        #[prost(message, tag = "33")]
        DirectVpcEgressConnection(super::DirectVpcEgressConnectionInfo),
        /// Display information of a serverless public (external) connection.
        #[prost(message, tag = "34")]
        ServerlessExternalConnection(super::ServerlessExternalConnectionInfo),
        /// Display information of the final state "deliver" and reason.
        #[prost(message, tag = "12")]
        Deliver(super::DeliverInfo),
        /// Display information of the final state "forward" and reason.
        #[prost(message, tag = "13")]
        Forward(super::ForwardInfo),
        /// Display information of the final state "abort" and reason.
        #[prost(message, tag = "14")]
        Abort(super::AbortInfo),
        /// Display information of the final state "drop" and reason.
        #[prost(message, tag = "15")]
        Drop(super::DropInfo),
        /// Display information of the load balancers. Deprecated in favor of the
        /// `load_balancer_backend_info` field, not used in new tests.
        #[deprecated]
        #[prost(message, tag = "16")]
        LoadBalancer(super::LoadBalancerInfo),
        /// Display information of a Google Cloud network.
        #[prost(message, tag = "17")]
        Network(super::NetworkInfo),
        /// Display information of a Google Kubernetes Engine cluster master.
        #[prost(message, tag = "18")]
        GkeMaster(super::GkeMasterInfo),
        /// Display information of a Google Kubernetes Engine Pod.
        #[prost(message, tag = "37")]
        GkePod(super::GkePodInfo),
        /// Display information of the reason why GKE Pod IP masquerading was
        /// skipped.
        #[prost(message, tag = "38")]
        IpMasqueradingSkipped(super::IpMasqueradingSkippedInfo),
        /// Display information of a GKE Network Policy.
        #[prost(message, tag = "39")]
        GkeNetworkPolicy(super::GkeNetworkPolicyInfo),
        /// Display information of the reason why GKE Network Policy evaluation was
        /// skipped.
        #[prost(message, tag = "40")]
        GkeNetworkPolicySkipped(super::GkeNetworkPolicySkippedInfo),
        /// Display information of a Cloud SQL instance.
        #[prost(message, tag = "19")]
        CloudSqlInstance(super::CloudSqlInstanceInfo),
        /// Display information of a Redis Instance.
        #[prost(message, tag = "30")]
        RedisInstance(super::RedisInstanceInfo),
        /// Display information of a Redis Cluster.
        #[prost(message, tag = "31")]
        RedisCluster(super::RedisClusterInfo),
        /// Display information of a Cloud Function.
        #[prost(message, tag = "20")]
        CloudFunction(super::CloudFunctionInfo),
        /// Display information of an App Engine service version.
        #[prost(message, tag = "22")]
        AppEngineVersion(super::AppEngineVersionInfo),
        /// Display information of a Cloud Run revision.
        #[prost(message, tag = "23")]
        CloudRunRevision(super::CloudRunRevisionInfo),
        /// Display information of a NAT.
        #[prost(message, tag = "25")]
        Nat(super::NatInfo),
        /// Display information of a ProxyConnection.
        #[prost(message, tag = "26")]
        ProxyConnection(super::ProxyConnectionInfo),
        /// Display information of a specific load balancer backend.
        #[prost(message, tag = "27")]
        LoadBalancerBackendInfo(super::LoadBalancerBackendInfo),
        /// Display information of a Storage Bucket. Used only for return traces.
        #[prost(message, tag = "28")]
        StorageBucket(super::StorageBucketInfo),
        /// Display information of a Serverless network endpoint group backend. Used
        /// only for return traces.
        #[prost(message, tag = "29")]
        ServerlessNeg(super::ServerlessNegInfo),
        /// Display information of a layer 7 packet inspection by the firewall.
        #[prost(message, tag = "42")]
        NgfwPacketInspection(super::NgfwPacketInspectionInfo),
    }
}
/// For display only. Metadata associated with a Compute Engine instance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InstanceInfo {
    /// Name of a Compute Engine instance.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a Compute Engine instance.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Name of the network interface of a Compute Engine instance.
    #[prost(string, tag = "3")]
    pub interface: ::prost::alloc::string::String,
    /// URI of a Compute Engine network.
    #[prost(string, tag = "4")]
    pub network_uri: ::prost::alloc::string::String,
    /// Internal IP address of the network interface.
    #[prost(string, tag = "5")]
    pub internal_ip: ::prost::alloc::string::String,
    /// External IP address of the network interface.
    #[prost(string, tag = "6")]
    pub external_ip: ::prost::alloc::string::String,
    /// Network tags configured on the instance.
    #[prost(string, repeated, tag = "7")]
    pub network_tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Service account authorized for the instance.
    #[deprecated]
    #[prost(string, tag = "8")]
    pub service_account: ::prost::alloc::string::String,
    /// URI of the PSC network attachment the NIC is attached to (if relevant).
    #[prost(string, tag = "9")]
    pub psc_network_attachment_uri: ::prost::alloc::string::String,
    /// Indicates whether the Compute Engine instance is running.
    /// Deprecated: use the `status` field instead.
    #[deprecated]
    #[prost(bool, tag = "10")]
    pub running: bool,
    /// The status of the instance.
    #[prost(enumeration = "instance_info::Status", tag = "11")]
    pub status: i32,
}
/// Nested message and enum types in `InstanceInfo`.
pub mod instance_info {
    /// The status of the instance. We treat all states other than "RUNNING" as
    /// not running.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Status {
        /// Default unspecified value.
        Unspecified = 0,
        /// The instance is running.
        Running = 1,
        /// The instance has any status other than "RUNNING".
        NotRunning = 2,
    }
    impl Status {
        /// 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 => "STATUS_UNSPECIFIED",
                Self::Running => "RUNNING",
                Self::NotRunning => "NOT_RUNNING",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATUS_UNSPECIFIED" => Some(Self::Unspecified),
                "RUNNING" => Some(Self::Running),
                "NOT_RUNNING" => Some(Self::NotRunning),
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with a Compute Engine network.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NetworkInfo {
    /// Name of a Compute Engine network.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a Compute Engine network.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// URI of the subnet matching the source IP address of the test.
    #[prost(string, tag = "5")]
    pub matched_subnet_uri: ::prost::alloc::string::String,
    /// The IP range of the subnet matching the source IP address of the test.
    #[prost(string, tag = "4")]
    pub matched_ip_range: ::prost::alloc::string::String,
    /// The region of the subnet matching the source IP address of the test.
    #[prost(string, tag = "6")]
    pub region: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a VPC firewall rule, an implied
/// VPC firewall rule, or a firewall policy rule.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FirewallInfo {
    /// The display name of the firewall rule. This field might be empty for
    /// firewall policy rules.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// The URI of the firewall rule. This field is not applicable to implied
    /// VPC firewall rules.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Possible values: INGRESS, EGRESS
    #[prost(string, tag = "3")]
    pub direction: ::prost::alloc::string::String,
    /// Possible values: ALLOW, DENY, APPLY_SECURITY_PROFILE_GROUP
    #[prost(string, tag = "4")]
    pub action: ::prost::alloc::string::String,
    /// The priority of the firewall rule.
    #[prost(int32, tag = "5")]
    pub priority: i32,
    /// The URI of the VPC network that the firewall rule is associated with.
    /// This field is not applicable to hierarchical firewall policy rules.
    #[prost(string, tag = "6")]
    pub network_uri: ::prost::alloc::string::String,
    /// The target tags defined by the VPC firewall rule. This field is not
    /// applicable to firewall policy rules.
    #[prost(string, repeated, tag = "7")]
    pub target_tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// The target service accounts specified by the firewall rule.
    #[prost(string, repeated, tag = "8")]
    pub target_service_accounts: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// The name of the firewall policy that this rule is associated with.
    /// This field is not applicable to VPC firewall rules and implied VPC firewall
    /// rules.
    #[prost(string, tag = "9")]
    pub policy: ::prost::alloc::string::String,
    /// The URI of the firewall policy that this rule is associated with.
    /// This field is not applicable to VPC firewall rules and implied VPC firewall
    /// rules.
    #[prost(string, tag = "11")]
    pub policy_uri: ::prost::alloc::string::String,
    /// The firewall rule's type.
    #[prost(enumeration = "firewall_info::FirewallRuleType", tag = "10")]
    pub firewall_rule_type: i32,
    /// The priority of the firewall policy that this rule is associated with.
    /// This field is not applicable to VPC firewall rules and implied VPC firewall
    /// rules.
    #[prost(int32, tag = "12")]
    pub policy_priority: i32,
    /// Target type of the firewall rule.
    #[prost(enumeration = "firewall_info::TargetType", tag = "13")]
    pub target_type: i32,
}
/// Nested message and enum types in `FirewallInfo`.
pub mod firewall_info {
    /// The firewall rule's type.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum FirewallRuleType {
        /// Unspecified type.
        Unspecified = 0,
        /// Hierarchical firewall policy rule. For details, see
        /// [Hierarchical firewall policies
        /// overview](<https://cloud.google.com/vpc/docs/firewall-policies>).
        HierarchicalFirewallPolicyRule = 1,
        /// VPC firewall rule. For details, see
        /// [VPC firewall rules
        /// overview](<https://cloud.google.com/vpc/docs/firewalls>).
        VpcFirewallRule = 2,
        /// Implied VPC firewall rule. For details, see
        /// [Implied
        /// rules](<https://cloud.google.com/vpc/docs/firewalls#default_firewall_rules>).
        ImpliedVpcFirewallRule = 3,
        /// Implicit firewall rules that are managed by serverless VPC access to
        /// allow ingress access. They are not visible in the Google Cloud console.
        /// For details, see [VPC connector's implicit
        /// rules](<https://cloud.google.com/functions/docs/networking/connecting-vpc#restrict-access>).
        ServerlessVpcAccessManagedFirewallRule = 4,
        /// User-defined global network firewall policy rule.
        /// For details, see [Network firewall
        /// policies](<https://cloud.google.com/vpc/docs/network-firewall-policies>).
        NetworkFirewallPolicyRule = 5,
        /// User-defined regional network firewall policy rule.
        /// For details, see [Regional network firewall
        /// policies](<https://cloud.google.com/firewall/docs/regional-firewall-policies>).
        NetworkRegionalFirewallPolicyRule = 6,
        /// System-defined global network firewall policy rule.
        SystemNetworkFirewallPolicyRule = 7,
        /// System-defined regional network firewall policy rule.
        SystemRegionalNetworkFirewallPolicyRule = 8,
        /// Firewall policy rule containing attributes not yet supported in
        /// Connectivity tests. Firewall analysis is skipped if such a rule can
        /// potentially be matched. Please see the [list of unsupported
        /// configurations](<https://cloud.google.com/network-intelligence-center/docs/connectivity-tests/concepts/overview#unsupported-configs>).
        UnsupportedFirewallPolicyRule = 100,
        /// Tracking state for response traffic created when request traffic goes
        /// through allow firewall rule.
        /// For details, see [firewall rules
        /// specifications](<https://cloud.google.com/firewall/docs/firewalls#specifications>)
        TrackingState = 101,
        /// Firewall analysis was skipped due to executing Connectivity Test in the
        /// BypassFirewallChecks mode
        AnalysisSkipped = 102,
    }
    impl FirewallRuleType {
        /// 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 => "FIREWALL_RULE_TYPE_UNSPECIFIED",
                Self::HierarchicalFirewallPolicyRule => {
                    "HIERARCHICAL_FIREWALL_POLICY_RULE"
                }
                Self::VpcFirewallRule => "VPC_FIREWALL_RULE",
                Self::ImpliedVpcFirewallRule => "IMPLIED_VPC_FIREWALL_RULE",
                Self::ServerlessVpcAccessManagedFirewallRule => {
                    "SERVERLESS_VPC_ACCESS_MANAGED_FIREWALL_RULE"
                }
                Self::NetworkFirewallPolicyRule => "NETWORK_FIREWALL_POLICY_RULE",
                Self::NetworkRegionalFirewallPolicyRule => {
                    "NETWORK_REGIONAL_FIREWALL_POLICY_RULE"
                }
                Self::SystemNetworkFirewallPolicyRule => {
                    "SYSTEM_NETWORK_FIREWALL_POLICY_RULE"
                }
                Self::SystemRegionalNetworkFirewallPolicyRule => {
                    "SYSTEM_REGIONAL_NETWORK_FIREWALL_POLICY_RULE"
                }
                Self::UnsupportedFirewallPolicyRule => "UNSUPPORTED_FIREWALL_POLICY_RULE",
                Self::TrackingState => "TRACKING_STATE",
                Self::AnalysisSkipped => "ANALYSIS_SKIPPED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "FIREWALL_RULE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "HIERARCHICAL_FIREWALL_POLICY_RULE" => {
                    Some(Self::HierarchicalFirewallPolicyRule)
                }
                "VPC_FIREWALL_RULE" => Some(Self::VpcFirewallRule),
                "IMPLIED_VPC_FIREWALL_RULE" => Some(Self::ImpliedVpcFirewallRule),
                "SERVERLESS_VPC_ACCESS_MANAGED_FIREWALL_RULE" => {
                    Some(Self::ServerlessVpcAccessManagedFirewallRule)
                }
                "NETWORK_FIREWALL_POLICY_RULE" => Some(Self::NetworkFirewallPolicyRule),
                "NETWORK_REGIONAL_FIREWALL_POLICY_RULE" => {
                    Some(Self::NetworkRegionalFirewallPolicyRule)
                }
                "SYSTEM_NETWORK_FIREWALL_POLICY_RULE" => {
                    Some(Self::SystemNetworkFirewallPolicyRule)
                }
                "SYSTEM_REGIONAL_NETWORK_FIREWALL_POLICY_RULE" => {
                    Some(Self::SystemRegionalNetworkFirewallPolicyRule)
                }
                "UNSUPPORTED_FIREWALL_POLICY_RULE" => {
                    Some(Self::UnsupportedFirewallPolicyRule)
                }
                "TRACKING_STATE" => Some(Self::TrackingState),
                "ANALYSIS_SKIPPED" => Some(Self::AnalysisSkipped),
                _ => None,
            }
        }
    }
    /// Target type of the firewall rule.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TargetType {
        /// Target type is not specified. In this case we treat the rule as applying
        /// to INSTANCES target type.
        Unspecified = 0,
        /// Firewall rule applies to instances.
        Instances = 1,
        /// Firewall rule applies to internal managed load balancers.
        InternalManagedLb = 2,
    }
    impl TargetType {
        /// 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 => "TARGET_TYPE_UNSPECIFIED",
                Self::Instances => "INSTANCES",
                Self::InternalManagedLb => "INTERNAL_MANAGED_LB",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TARGET_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "INSTANCES" => Some(Self::Instances),
                "INTERNAL_MANAGED_LB" => Some(Self::InternalManagedLb),
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with a Compute Engine route.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RouteInfo {
    /// Type of route.
    #[prost(enumeration = "route_info::RouteType", tag = "8")]
    pub route_type: i32,
    /// Type of next hop.
    #[prost(enumeration = "route_info::NextHopType", tag = "9")]
    pub next_hop_type: i32,
    /// Indicates where route is applicable. Deprecated, routes with NCC_HUB scope
    /// are not included in the trace in new tests.
    #[deprecated]
    #[prost(enumeration = "route_info::RouteScope", tag = "14")]
    pub route_scope: i32,
    /// Name of a route.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a route. SUBNET, STATIC, PEERING_SUBNET (only for peering network)
    /// and POLICY_BASED routes only.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Region of the route. DYNAMIC, PEERING_DYNAMIC, POLICY_BASED and ADVERTISED
    /// routes only. If set for POLICY_BASED route, this is a region of VLAN
    /// attachments for Cloud Interconnect the route applies to. If set to "all"
    /// for POLICY_BASED route, the route applies to VLAN attachments of Cloud
    /// Interconnect in all regions.
    #[prost(string, tag = "19")]
    pub region: ::prost::alloc::string::String,
    /// Destination IP range of the route.
    #[prost(string, tag = "3")]
    pub dest_ip_range: ::prost::alloc::string::String,
    /// String type of the next hop of the route (for example, "VPN tunnel").
    /// Deprecated in favor of the next_hop_type and next_hop_uri fields, not used
    /// in new tests.
    #[deprecated]
    #[prost(string, tag = "4")]
    pub next_hop: ::prost::alloc::string::String,
    /// URI of a VPC network where route is located.
    #[prost(string, tag = "5")]
    pub network_uri: ::prost::alloc::string::String,
    /// Priority of the route.
    #[prost(int32, tag = "6")]
    pub priority: i32,
    /// Instance tags of the route.
    #[prost(string, repeated, tag = "7")]
    pub instance_tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Source IP address range of the route. POLICY_BASED routes only.
    #[prost(string, tag = "10")]
    pub src_ip_range: ::prost::alloc::string::String,
    /// Destination port ranges of the route. POLICY_BASED routes only.
    #[prost(string, repeated, tag = "11")]
    pub dest_port_ranges: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Source port ranges of the route. POLICY_BASED routes only.
    #[prost(string, repeated, tag = "12")]
    pub src_port_ranges: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Protocols of the route. POLICY_BASED routes only.
    #[prost(string, repeated, tag = "13")]
    pub protocols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// URI of the NCC Hub the route is advertised by. PEERING_SUBNET and
    /// PEERING_DYNAMIC routes that are advertised by NCC Hub only.
    #[prost(string, optional, tag = "15")]
    pub ncc_hub_uri: ::core::option::Option<::prost::alloc::string::String>,
    /// URI of the destination NCC Spoke. PEERING_SUBNET and PEERING_DYNAMIC routes
    /// that are advertised by NCC Hub only.
    #[prost(string, optional, tag = "16")]
    pub ncc_spoke_uri: ::core::option::Option<::prost::alloc::string::String>,
    /// For ADVERTISED dynamic routes, the URI of the Cloud Router that advertised
    /// the corresponding IP prefix.
    #[prost(string, optional, tag = "17")]
    pub advertised_route_source_router_uri: ::core::option::Option<
        ::prost::alloc::string::String,
    >,
    /// For ADVERTISED routes, the URI of their next hop, i.e. the URI of the
    /// hybrid endpoint (VPN tunnel, Interconnect attachment, NCC router appliance)
    /// the advertised prefix is advertised through, or URI of the source peered
    /// network. Deprecated in favor of the next_hop_uri field, not used in new
    /// tests.
    #[deprecated]
    #[prost(string, optional, tag = "18")]
    pub advertised_route_next_hop_uri: ::core::option::Option<
        ::prost::alloc::string::String,
    >,
    /// URI of the next hop resource.
    #[prost(string, tag = "20")]
    pub next_hop_uri: ::prost::alloc::string::String,
    /// URI of a VPC network where the next hop resource is located.
    #[prost(string, tag = "21")]
    pub next_hop_network_uri: ::prost::alloc::string::String,
    /// For PEERING_SUBNET and PEERING_STATIC routes, the URI of the originating
    /// SUBNET/STATIC route.
    #[prost(string, tag = "22")]
    pub originating_route_uri: ::prost::alloc::string::String,
    /// For PEERING_SUBNET, PEERING_STATIC and PEERING_DYNAMIC routes, the name of
    /// the originating SUBNET/STATIC/DYNAMIC route.
    #[prost(string, tag = "23")]
    pub originating_route_display_name: ::prost::alloc::string::String,
    /// For PEERING_SUBNET and PEERING_DYNAMIC routes that are advertised by NCC
    /// Hub, the URI of the corresponding route in NCC Hub's routing table.
    #[prost(string, tag = "24")]
    pub ncc_hub_route_uri: ::prost::alloc::string::String,
}
/// Nested message and enum types in `RouteInfo`.
pub mod route_info {
    /// Type of route:
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RouteType {
        /// Unspecified type. Default value.
        Unspecified = 0,
        /// Route is a subnet route automatically created by the system.
        Subnet = 1,
        /// Static route created by the user, including the default route to the
        /// internet.
        Static = 2,
        /// Dynamic route exchanged between BGP peers.
        Dynamic = 3,
        /// A subnet route received from peering network or NCC Hub.
        PeeringSubnet = 4,
        /// A static route received from peering network.
        PeeringStatic = 5,
        /// A dynamic route received from peering network or NCC Hub.
        PeeringDynamic = 6,
        /// Policy based route.
        PolicyBased = 7,
        /// Advertised route. Synthetic route which is used to transition from the
        /// StartFromPrivateNetwork state in Connectivity tests.
        Advertised = 101,
    }
    impl RouteType {
        /// 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 => "ROUTE_TYPE_UNSPECIFIED",
                Self::Subnet => "SUBNET",
                Self::Static => "STATIC",
                Self::Dynamic => "DYNAMIC",
                Self::PeeringSubnet => "PEERING_SUBNET",
                Self::PeeringStatic => "PEERING_STATIC",
                Self::PeeringDynamic => "PEERING_DYNAMIC",
                Self::PolicyBased => "POLICY_BASED",
                Self::Advertised => "ADVERTISED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ROUTE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "SUBNET" => Some(Self::Subnet),
                "STATIC" => Some(Self::Static),
                "DYNAMIC" => Some(Self::Dynamic),
                "PEERING_SUBNET" => Some(Self::PeeringSubnet),
                "PEERING_STATIC" => Some(Self::PeeringStatic),
                "PEERING_DYNAMIC" => Some(Self::PeeringDynamic),
                "POLICY_BASED" => Some(Self::PolicyBased),
                "ADVERTISED" => Some(Self::Advertised),
                _ => None,
            }
        }
    }
    /// Type of next hop:
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum NextHopType {
        /// Unspecified type. Default value.
        Unspecified = 0,
        /// Next hop is an IP address.
        NextHopIp = 1,
        /// Next hop is a Compute Engine instance.
        NextHopInstance = 2,
        /// Next hop is a VPC network gateway.
        NextHopNetwork = 3,
        /// Next hop is a peering VPC. This scenario only happens when the user
        /// doesn't have permissions to the project where the next hop resource is
        /// located.
        NextHopPeering = 4,
        /// Next hop is an interconnect.
        NextHopInterconnect = 5,
        /// Next hop is a VPN tunnel.
        NextHopVpnTunnel = 6,
        /// Next hop is a VPN gateway. This scenario only happens when tracing
        /// connectivity from an on-premises network to Google Cloud through a VPN.
        /// The analysis simulates a packet departing from the on-premises network
        /// through a VPN tunnel and arriving at a Cloud VPN gateway.
        NextHopVpnGateway = 7,
        /// Next hop is an internet gateway.
        NextHopInternetGateway = 8,
        /// Next hop is blackhole; that is, the next hop either does not exist or is
        /// unusable.
        NextHopBlackhole = 9,
        /// Next hop is the forwarding rule of an Internal Load Balancer.
        NextHopIlb = 10,
        /// Next hop is a
        /// [router appliance
        /// instance](<https://cloud.google.com/network-connectivity/docs/network-connectivity-center/concepts/ra-overview>).
        NextHopRouterAppliance = 11,
        /// Next hop is an NCC hub. This scenario only happens when the user doesn't
        /// have permissions to the project where the next hop resource is located.
        NextHopNccHub = 12,
        /// Next hop is Secure Web Proxy Gateway.
        SecureWebProxyGateway = 13,
    }
    impl NextHopType {
        /// 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 => "NEXT_HOP_TYPE_UNSPECIFIED",
                Self::NextHopIp => "NEXT_HOP_IP",
                Self::NextHopInstance => "NEXT_HOP_INSTANCE",
                Self::NextHopNetwork => "NEXT_HOP_NETWORK",
                Self::NextHopPeering => "NEXT_HOP_PEERING",
                Self::NextHopInterconnect => "NEXT_HOP_INTERCONNECT",
                Self::NextHopVpnTunnel => "NEXT_HOP_VPN_TUNNEL",
                Self::NextHopVpnGateway => "NEXT_HOP_VPN_GATEWAY",
                Self::NextHopInternetGateway => "NEXT_HOP_INTERNET_GATEWAY",
                Self::NextHopBlackhole => "NEXT_HOP_BLACKHOLE",
                Self::NextHopIlb => "NEXT_HOP_ILB",
                Self::NextHopRouterAppliance => "NEXT_HOP_ROUTER_APPLIANCE",
                Self::NextHopNccHub => "NEXT_HOP_NCC_HUB",
                Self::SecureWebProxyGateway => "SECURE_WEB_PROXY_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 {
                "NEXT_HOP_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "NEXT_HOP_IP" => Some(Self::NextHopIp),
                "NEXT_HOP_INSTANCE" => Some(Self::NextHopInstance),
                "NEXT_HOP_NETWORK" => Some(Self::NextHopNetwork),
                "NEXT_HOP_PEERING" => Some(Self::NextHopPeering),
                "NEXT_HOP_INTERCONNECT" => Some(Self::NextHopInterconnect),
                "NEXT_HOP_VPN_TUNNEL" => Some(Self::NextHopVpnTunnel),
                "NEXT_HOP_VPN_GATEWAY" => Some(Self::NextHopVpnGateway),
                "NEXT_HOP_INTERNET_GATEWAY" => Some(Self::NextHopInternetGateway),
                "NEXT_HOP_BLACKHOLE" => Some(Self::NextHopBlackhole),
                "NEXT_HOP_ILB" => Some(Self::NextHopIlb),
                "NEXT_HOP_ROUTER_APPLIANCE" => Some(Self::NextHopRouterAppliance),
                "NEXT_HOP_NCC_HUB" => Some(Self::NextHopNccHub),
                "SECURE_WEB_PROXY_GATEWAY" => Some(Self::SecureWebProxyGateway),
                _ => None,
            }
        }
    }
    /// Indicates where routes are applicable.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RouteScope {
        /// Unspecified scope. Default value.
        Unspecified = 0,
        /// Route is applicable to packets in Network.
        Network = 1,
        /// Route is applicable to packets using NCC Hub's routing table.
        NccHub = 2,
    }
    impl RouteScope {
        /// 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 => "ROUTE_SCOPE_UNSPECIFIED",
                Self::Network => "NETWORK",
                Self::NccHub => "NCC_HUB",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ROUTE_SCOPE_UNSPECIFIED" => Some(Self::Unspecified),
                "NETWORK" => Some(Self::Network),
                "NCC_HUB" => Some(Self::NccHub),
                _ => None,
            }
        }
    }
}
/// For display only. Details of a Google Service sending packets to a
/// VPC network. Although the source IP might be a publicly routable address,
/// some Google Services use special routes within Google production
/// infrastructure to reach Compute Engine Instances.
/// <https://cloud.google.com/vpc/docs/routes#special_return_paths>
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GoogleServiceInfo {
    /// Source IP address.
    #[prost(string, tag = "1")]
    pub source_ip: ::prost::alloc::string::String,
    /// Recognized type of a Google Service.
    #[prost(enumeration = "google_service_info::GoogleServiceType", tag = "2")]
    pub google_service_type: i32,
}
/// Nested message and enum types in `GoogleServiceInfo`.
pub mod google_service_info {
    /// Recognized type of a Google Service.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum GoogleServiceType {
        /// Unspecified Google Service.
        Unspecified = 0,
        /// Identity aware proxy.
        /// <https://cloud.google.com/iap/docs/using-tcp-forwarding>
        Iap = 1,
        /// One of two services sharing IP ranges:
        ///
        /// * Load Balancer proxy
        /// * Centralized Health Check prober
        ///   <https://cloud.google.com/load-balancing/docs/firewall-rules>
        GfeProxyOrHealthCheckProber = 2,
        /// Connectivity from Cloud DNS to forwarding targets or alternate name
        /// servers that use private routing.
        /// <https://cloud.google.com/dns/docs/zones/forwarding-zones#firewall-rules>
        /// <https://cloud.google.com/dns/docs/policies#firewall-rules>
        CloudDns = 3,
        /// private.googleapis.com and restricted.googleapis.com
        GoogleApi = 4,
        /// Google API via Private Service Connect.
        /// <https://cloud.google.com/vpc/docs/configure-private-service-connect-apis>
        GoogleApiPsc = 5,
        /// Google API via VPC Service Controls.
        /// <https://cloud.google.com/vpc/docs/configure-private-service-connect-apis>
        GoogleApiVpcSc = 6,
        /// Google API via Serverless VPC Access.
        /// <https://cloud.google.com/vpc/docs/serverless-vpc-access>
        ServerlessVpcAccess = 7,
    }
    impl GoogleServiceType {
        /// 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 => "GOOGLE_SERVICE_TYPE_UNSPECIFIED",
                Self::Iap => "IAP",
                Self::GfeProxyOrHealthCheckProber => "GFE_PROXY_OR_HEALTH_CHECK_PROBER",
                Self::CloudDns => "CLOUD_DNS",
                Self::GoogleApi => "GOOGLE_API",
                Self::GoogleApiPsc => "GOOGLE_API_PSC",
                Self::GoogleApiVpcSc => "GOOGLE_API_VPC_SC",
                Self::ServerlessVpcAccess => "SERVERLESS_VPC_ACCESS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "GOOGLE_SERVICE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "IAP" => Some(Self::Iap),
                "GFE_PROXY_OR_HEALTH_CHECK_PROBER" => {
                    Some(Self::GfeProxyOrHealthCheckProber)
                }
                "CLOUD_DNS" => Some(Self::CloudDns),
                "GOOGLE_API" => Some(Self::GoogleApi),
                "GOOGLE_API_PSC" => Some(Self::GoogleApiPsc),
                "GOOGLE_API_VPC_SC" => Some(Self::GoogleApiVpcSc),
                "SERVERLESS_VPC_ACCESS" => Some(Self::ServerlessVpcAccess),
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with a Compute Engine forwarding rule.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ForwardingRuleInfo {
    /// Name of the forwarding rule.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of the forwarding rule.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Protocol defined in the forwarding rule that matches the packet.
    #[prost(string, tag = "3")]
    pub matched_protocol: ::prost::alloc::string::String,
    /// Port range defined in the forwarding rule that matches the packet.
    #[prost(string, tag = "6")]
    pub matched_port_range: ::prost::alloc::string::String,
    /// VIP of the forwarding rule.
    #[prost(string, tag = "4")]
    pub vip: ::prost::alloc::string::String,
    /// Target type of the forwarding rule.
    #[prost(string, tag = "5")]
    pub target: ::prost::alloc::string::String,
    /// Network URI.
    #[prost(string, tag = "7")]
    pub network_uri: ::prost::alloc::string::String,
    /// Region of the forwarding rule. Set only for regional forwarding rules.
    #[prost(string, tag = "8")]
    pub region: ::prost::alloc::string::String,
    /// Name of the load balancer the forwarding rule belongs to. Empty for
    /// forwarding rules not related to load balancers (like PSC forwarding rules).
    #[prost(string, tag = "9")]
    pub load_balancer_name: ::prost::alloc::string::String,
    /// URI of the PSC service attachment this forwarding rule targets (if
    /// applicable).
    #[prost(string, tag = "10")]
    pub psc_service_attachment_uri: ::prost::alloc::string::String,
    /// PSC Google API target this forwarding rule targets (if applicable).
    #[prost(string, tag = "11")]
    pub psc_google_api_target: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a load balancer.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LoadBalancerInfo {
    /// Type of the load balancer.
    #[prost(enumeration = "load_balancer_info::LoadBalancerType", tag = "1")]
    pub load_balancer_type: i32,
    /// URI of the health check for the load balancer. Deprecated and no longer
    /// populated as different load balancer backends might have different health
    /// checks.
    #[deprecated]
    #[prost(string, tag = "2")]
    pub health_check_uri: ::prost::alloc::string::String,
    /// Information for the loadbalancer backends.
    #[prost(message, repeated, tag = "3")]
    pub backends: ::prost::alloc::vec::Vec<LoadBalancerBackend>,
    /// Type of load balancer's backend configuration.
    #[prost(enumeration = "load_balancer_info::BackendType", tag = "4")]
    pub backend_type: i32,
    /// Backend configuration URI.
    #[prost(string, tag = "5")]
    pub backend_uri: ::prost::alloc::string::String,
}
/// Nested message and enum types in `LoadBalancerInfo`.
pub mod load_balancer_info {
    /// The type definition for a load balancer:
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum LoadBalancerType {
        /// Type is unspecified.
        Unspecified = 0,
        /// Internal TCP/UDP load balancer.
        InternalTcpUdp = 1,
        /// Network TCP/UDP load balancer.
        NetworkTcpUdp = 2,
        /// HTTP(S) proxy load balancer.
        HttpProxy = 3,
        /// TCP proxy load balancer.
        TcpProxy = 4,
        /// SSL proxy load balancer.
        SslProxy = 5,
    }
    impl LoadBalancerType {
        /// 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 => "LOAD_BALANCER_TYPE_UNSPECIFIED",
                Self::InternalTcpUdp => "INTERNAL_TCP_UDP",
                Self::NetworkTcpUdp => "NETWORK_TCP_UDP",
                Self::HttpProxy => "HTTP_PROXY",
                Self::TcpProxy => "TCP_PROXY",
                Self::SslProxy => "SSL_PROXY",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "LOAD_BALANCER_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "INTERNAL_TCP_UDP" => Some(Self::InternalTcpUdp),
                "NETWORK_TCP_UDP" => Some(Self::NetworkTcpUdp),
                "HTTP_PROXY" => Some(Self::HttpProxy),
                "TCP_PROXY" => Some(Self::TcpProxy),
                "SSL_PROXY" => Some(Self::SslProxy),
                _ => None,
            }
        }
    }
    /// The type definition for a load balancer backend configuration:
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BackendType {
        /// Type is unspecified.
        Unspecified = 0,
        /// Backend Service as the load balancer's backend.
        BackendService = 1,
        /// Target Pool as the load balancer's backend.
        TargetPool = 2,
        /// Target Instance as the load balancer's backend.
        TargetInstance = 3,
    }
    impl BackendType {
        /// 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 => "BACKEND_TYPE_UNSPECIFIED",
                Self::BackendService => "BACKEND_SERVICE",
                Self::TargetPool => "TARGET_POOL",
                Self::TargetInstance => "TARGET_INSTANCE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "BACKEND_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "BACKEND_SERVICE" => Some(Self::BackendService),
                "TARGET_POOL" => Some(Self::TargetPool),
                "TARGET_INSTANCE" => Some(Self::TargetInstance),
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with a specific load balancer backend.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LoadBalancerBackend {
    /// Name of a Compute Engine instance or network endpoint.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a Compute Engine instance or network endpoint.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// State of the health check firewall configuration.
    #[prost(enumeration = "load_balancer_backend::HealthCheckFirewallState", tag = "3")]
    pub health_check_firewall_state: i32,
    /// A list of firewall rule URIs allowing probes from health check IP ranges.
    #[prost(string, repeated, tag = "4")]
    pub health_check_allowing_firewall_rules: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
    /// A list of firewall rule URIs blocking probes from health check IP ranges.
    #[prost(string, repeated, tag = "5")]
    pub health_check_blocking_firewall_rules: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `LoadBalancerBackend`.
pub mod load_balancer_backend {
    /// State of a health check firewall configuration:
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum HealthCheckFirewallState {
        /// State is unspecified. Default state if not populated.
        Unspecified = 0,
        /// There are configured firewall rules to allow health check probes to the
        /// backend.
        Configured = 1,
        /// There are firewall rules configured to allow partial health check ranges
        /// or block all health check ranges.
        /// If a health check probe is sent from denied IP ranges,
        /// the health check to the backend will fail. Then, the backend will be
        /// marked unhealthy and will not receive traffic sent to the load balancer.
        Misconfigured = 2,
    }
    impl HealthCheckFirewallState {
        /// 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 => "HEALTH_CHECK_FIREWALL_STATE_UNSPECIFIED",
                Self::Configured => "CONFIGURED",
                Self::Misconfigured => "MISCONFIGURED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "HEALTH_CHECK_FIREWALL_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "CONFIGURED" => Some(Self::Configured),
                "MISCONFIGURED" => Some(Self::Misconfigured),
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with a hybrid subnet.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct HybridSubnetInfo {
    /// Name of a hybrid subnet.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a hybrid subnet.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Name of a Google Cloud region where the hybrid subnet is configured.
    #[prost(string, tag = "3")]
    pub region: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a Compute Engine VPN gateway.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VpnGatewayInfo {
    /// Name of a VPN gateway.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a VPN gateway.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// URI of a Compute Engine network where the VPN gateway is configured.
    #[prost(string, tag = "3")]
    pub network_uri: ::prost::alloc::string::String,
    /// IP address of the VPN gateway.
    #[prost(string, tag = "4")]
    pub ip_address: ::prost::alloc::string::String,
    /// A VPN tunnel that is associated with this VPN gateway.
    /// There may be multiple VPN tunnels configured on a VPN gateway, and only
    /// the one relevant to the test is displayed.
    #[prost(string, tag = "5")]
    pub vpn_tunnel_uri: ::prost::alloc::string::String,
    /// Name of a Google Cloud region where this VPN gateway is configured.
    #[prost(string, tag = "6")]
    pub region: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a Compute Engine VPN tunnel.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VpnTunnelInfo {
    /// Name of a VPN tunnel.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a VPN tunnel.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// URI of the VPN gateway at local end of the tunnel.
    #[prost(string, tag = "3")]
    pub source_gateway: ::prost::alloc::string::String,
    /// URI of a VPN gateway at remote end of the tunnel.
    #[prost(string, tag = "4")]
    pub remote_gateway: ::prost::alloc::string::String,
    /// Remote VPN gateway's IP address.
    #[prost(string, tag = "5")]
    pub remote_gateway_ip: ::prost::alloc::string::String,
    /// Local VPN gateway's IP address.
    #[prost(string, tag = "6")]
    pub source_gateway_ip: ::prost::alloc::string::String,
    /// URI of a Compute Engine network where the VPN tunnel is configured.
    #[prost(string, tag = "7")]
    pub network_uri: ::prost::alloc::string::String,
    /// Name of a Google Cloud region where this VPN tunnel is configured.
    #[prost(string, tag = "8")]
    pub region: ::prost::alloc::string::String,
    /// Type of the routing policy.
    #[prost(enumeration = "vpn_tunnel_info::RoutingType", tag = "9")]
    pub routing_type: i32,
}
/// Nested message and enum types in `VpnTunnelInfo`.
pub mod vpn_tunnel_info {
    /// Types of VPN routing policy. For details, refer to [Networks and Tunnel
    /// routing](<https://cloud.google.com/network-connectivity/docs/vpn/concepts/choosing-networks-routing/>).
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum RoutingType {
        /// Unspecified type. Default value.
        Unspecified = 0,
        /// Route based VPN.
        RouteBased = 1,
        /// Policy based routing.
        PolicyBased = 2,
        /// Dynamic (BGP) routing.
        Dynamic = 3,
    }
    impl RoutingType {
        /// 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 => "ROUTING_TYPE_UNSPECIFIED",
                Self::RouteBased => "ROUTE_BASED",
                Self::PolicyBased => "POLICY_BASED",
                Self::Dynamic => "DYNAMIC",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "ROUTING_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "ROUTE_BASED" => Some(Self::RouteBased),
                "POLICY_BASED" => Some(Self::PolicyBased),
                "DYNAMIC" => Some(Self::Dynamic),
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with an Interconnect attachment.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct InterconnectAttachmentInfo {
    /// Name of an Interconnect attachment.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of an Interconnect attachment.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// URI of the Interconnect where the Interconnect attachment is
    /// configured.
    #[prost(string, tag = "3")]
    pub interconnect_uri: ::prost::alloc::string::String,
    /// Name of a Google Cloud region where the Interconnect attachment is
    /// configured.
    #[prost(string, tag = "4")]
    pub region: ::prost::alloc::string::String,
    /// URI of the Cloud Router to be used for dynamic routing.
    #[prost(string, tag = "5")]
    pub cloud_router_uri: ::prost::alloc::string::String,
    /// The type of interconnect attachment this is.
    #[prost(enumeration = "interconnect_attachment_info::Type", tag = "6")]
    pub r#type: i32,
    /// Appliance IP address that was matched for L2_DEDICATED attachments.
    #[prost(string, tag = "7")]
    pub l2_attachment_matched_ip_address: ::prost::alloc::string::String,
}
/// Nested message and enum types in `InterconnectAttachmentInfo`.
pub mod interconnect_attachment_info {
    /// What type of interconnect attachment this is.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// Unspecified type.
        Unspecified = 0,
        /// Attachment to a dedicated interconnect.
        Dedicated = 1,
        /// Attachment to a partner interconnect, created by the customer.
        Partner = 2,
        /// Attachment to a partner interconnect, created by the partner.
        PartnerProvider = 3,
        /// Attachment to a L2 interconnect, created by the customer.
        L2Dedicated = 4,
    }
    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::Dedicated => "DEDICATED",
                Self::Partner => "PARTNER",
                Self::PartnerProvider => "PARTNER_PROVIDER",
                Self::L2Dedicated => "L2_DEDICATED",
            }
        }
        /// 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),
                "DEDICATED" => Some(Self::Dedicated),
                "PARTNER" => Some(Self::Partner),
                "PARTNER_PROVIDER" => Some(Self::PartnerProvider),
                "L2_DEDICATED" => Some(Self::L2Dedicated),
                _ => None,
            }
        }
    }
}
/// For display only. The specification of the endpoints for the test.
/// EndpointInfo is derived from source and destination Endpoint and validated
/// by the backend data plane model.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct EndpointInfo {
    /// Source IP address.
    #[prost(string, tag = "1")]
    pub source_ip: ::prost::alloc::string::String,
    /// Destination IP address.
    #[prost(string, tag = "2")]
    pub destination_ip: ::prost::alloc::string::String,
    /// IP protocol in string format, for example: "TCP", "UDP", "ICMP".
    #[prost(string, tag = "3")]
    pub protocol: ::prost::alloc::string::String,
    /// Source port. Only valid when protocol is TCP or UDP.
    #[prost(int32, tag = "4")]
    pub source_port: i32,
    /// Destination port. Only valid when protocol is TCP or UDP.
    #[prost(int32, tag = "5")]
    pub destination_port: i32,
    /// URI of the network where this packet originates from.
    #[prost(string, tag = "6")]
    pub source_network_uri: ::prost::alloc::string::String,
    /// URI of the network where this packet is sent to.
    #[prost(string, tag = "7")]
    pub destination_network_uri: ::prost::alloc::string::String,
    /// URI of the source telemetry agent this packet originates from.
    #[prost(string, tag = "8")]
    pub source_agent_uri: ::prost::alloc::string::String,
}
/// Details of the final state "deliver" and associated resource.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeliverInfo {
    /// Target type where the packet is delivered to.
    #[prost(enumeration = "deliver_info::Target", tag = "1")]
    pub target: i32,
    /// URI of the resource that the packet is delivered to.
    #[prost(string, tag = "2")]
    pub resource_uri: ::prost::alloc::string::String,
    /// IP address of the target (if applicable).
    #[prost(string, tag = "3")]
    pub ip_address: ::prost::alloc::string::String,
    /// Name of the Cloud Storage Bucket the packet is delivered to (if
    /// applicable).
    #[prost(string, tag = "4")]
    pub storage_bucket: ::prost::alloc::string::String,
    /// PSC Google API target the packet is delivered to (if applicable).
    #[prost(string, tag = "5")]
    pub psc_google_api_target: ::prost::alloc::string::String,
    /// Recognized type of a Google Service the packet is delivered to (if
    /// applicable).
    #[prost(enumeration = "deliver_info::GoogleServiceType", tag = "6")]
    pub google_service_type: i32,
}
/// Nested message and enum types in `DeliverInfo`.
pub mod deliver_info {
    /// Deliver target types:
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Target {
        /// Target not specified.
        Unspecified = 0,
        /// Target is a Compute Engine instance.
        Instance = 1,
        /// Target is the internet.
        Internet = 2,
        /// Target is a Google API.
        GoogleApi = 3,
        /// Target is a Google Kubernetes Engine cluster master.
        GkeMaster = 4,
        /// Target is a Cloud SQL instance.
        CloudSqlInstance = 5,
        /// Target is a published service that uses [Private Service
        /// Connect](<https://cloud.google.com/vpc/docs/configure-private-service-connect-services>).
        PscPublishedService = 6,
        /// Target is Google APIs that use [Private Service
        /// Connect](<https://cloud.google.com/vpc/docs/configure-private-service-connect-apis>).
        PscGoogleApi = 7,
        /// Target is a VPC-SC that uses [Private Service
        /// Connect](<https://cloud.google.com/vpc/docs/configure-private-service-connect-apis>).
        PscVpcSc = 8,
        /// Target is a serverless network endpoint group.
        ServerlessNeg = 9,
        /// Target is a Cloud Storage bucket.
        StorageBucket = 10,
        /// Target is a private network. Used only for return traces.
        PrivateNetwork = 11,
        /// Target is a Cloud Function. Used only for return traces.
        CloudFunction = 12,
        /// Target is a App Engine service version. Used only for return traces.
        AppEngineVersion = 13,
        /// Target is a Cloud Run revision. Used only for return traces.
        CloudRunRevision = 14,
        /// Target is a Google-managed service. Used only for return traces.
        GoogleManagedService = 15,
        /// Target is a Redis Instance.
        RedisInstance = 16,
        /// Target is a Redis Cluster.
        RedisCluster = 17,
        /// Target is a GKE Pod.
        GkePod = 19,
    }
    impl Target {
        /// 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 => "TARGET_UNSPECIFIED",
                Self::Instance => "INSTANCE",
                Self::Internet => "INTERNET",
                Self::GoogleApi => "GOOGLE_API",
                Self::GkeMaster => "GKE_MASTER",
                Self::CloudSqlInstance => "CLOUD_SQL_INSTANCE",
                Self::PscPublishedService => "PSC_PUBLISHED_SERVICE",
                Self::PscGoogleApi => "PSC_GOOGLE_API",
                Self::PscVpcSc => "PSC_VPC_SC",
                Self::ServerlessNeg => "SERVERLESS_NEG",
                Self::StorageBucket => "STORAGE_BUCKET",
                Self::PrivateNetwork => "PRIVATE_NETWORK",
                Self::CloudFunction => "CLOUD_FUNCTION",
                Self::AppEngineVersion => "APP_ENGINE_VERSION",
                Self::CloudRunRevision => "CLOUD_RUN_REVISION",
                Self::GoogleManagedService => "GOOGLE_MANAGED_SERVICE",
                Self::RedisInstance => "REDIS_INSTANCE",
                Self::RedisCluster => "REDIS_CLUSTER",
                Self::GkePod => "GKE_POD",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TARGET_UNSPECIFIED" => Some(Self::Unspecified),
                "INSTANCE" => Some(Self::Instance),
                "INTERNET" => Some(Self::Internet),
                "GOOGLE_API" => Some(Self::GoogleApi),
                "GKE_MASTER" => Some(Self::GkeMaster),
                "CLOUD_SQL_INSTANCE" => Some(Self::CloudSqlInstance),
                "PSC_PUBLISHED_SERVICE" => Some(Self::PscPublishedService),
                "PSC_GOOGLE_API" => Some(Self::PscGoogleApi),
                "PSC_VPC_SC" => Some(Self::PscVpcSc),
                "SERVERLESS_NEG" => Some(Self::ServerlessNeg),
                "STORAGE_BUCKET" => Some(Self::StorageBucket),
                "PRIVATE_NETWORK" => Some(Self::PrivateNetwork),
                "CLOUD_FUNCTION" => Some(Self::CloudFunction),
                "APP_ENGINE_VERSION" => Some(Self::AppEngineVersion),
                "CLOUD_RUN_REVISION" => Some(Self::CloudRunRevision),
                "GOOGLE_MANAGED_SERVICE" => Some(Self::GoogleManagedService),
                "REDIS_INSTANCE" => Some(Self::RedisInstance),
                "REDIS_CLUSTER" => Some(Self::RedisCluster),
                "GKE_POD" => Some(Self::GkePod),
                _ => None,
            }
        }
    }
    /// Recognized type of a Google Service.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum GoogleServiceType {
        /// Unspecified Google Service.
        Unspecified = 0,
        /// Identity aware proxy.
        /// <https://cloud.google.com/iap/docs/using-tcp-forwarding>
        Iap = 1,
        /// One of two services sharing IP ranges:
        ///
        /// * Load Balancer proxy
        /// * Centralized Health Check prober
        ///   <https://cloud.google.com/load-balancing/docs/firewall-rules>
        GfeProxyOrHealthCheckProber = 2,
        /// Connectivity from Cloud DNS to forwarding targets or alternate name
        /// servers that use private routing.
        /// <https://cloud.google.com/dns/docs/zones/forwarding-zones#firewall-rules>
        /// <https://cloud.google.com/dns/docs/policies#firewall-rules>
        CloudDns = 3,
        /// private.googleapis.com and restricted.googleapis.com
        PrivateGoogleAccess = 4,
        /// Google API via Serverless VPC Access.
        /// <https://cloud.google.com/vpc/docs/serverless-vpc-access>
        ServerlessVpcAccess = 5,
    }
    impl GoogleServiceType {
        /// 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 => "GOOGLE_SERVICE_TYPE_UNSPECIFIED",
                Self::Iap => "IAP",
                Self::GfeProxyOrHealthCheckProber => "GFE_PROXY_OR_HEALTH_CHECK_PROBER",
                Self::CloudDns => "CLOUD_DNS",
                Self::PrivateGoogleAccess => "PRIVATE_GOOGLE_ACCESS",
                Self::ServerlessVpcAccess => "SERVERLESS_VPC_ACCESS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "GOOGLE_SERVICE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "IAP" => Some(Self::Iap),
                "GFE_PROXY_OR_HEALTH_CHECK_PROBER" => {
                    Some(Self::GfeProxyOrHealthCheckProber)
                }
                "CLOUD_DNS" => Some(Self::CloudDns),
                "PRIVATE_GOOGLE_ACCESS" => Some(Self::PrivateGoogleAccess),
                "SERVERLESS_VPC_ACCESS" => Some(Self::ServerlessVpcAccess),
                _ => None,
            }
        }
    }
}
/// Details of the final state "forward" and associated resource.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ForwardInfo {
    /// Target type where this packet is forwarded to.
    #[prost(enumeration = "forward_info::Target", tag = "1")]
    pub target: i32,
    /// URI of the resource that the packet is forwarded to.
    #[prost(string, tag = "2")]
    pub resource_uri: ::prost::alloc::string::String,
    /// IP address of the target (if applicable).
    #[prost(string, tag = "3")]
    pub ip_address: ::prost::alloc::string::String,
}
/// Nested message and enum types in `ForwardInfo`.
pub mod forward_info {
    /// Forward target types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Target {
        /// Target not specified.
        Unspecified = 0,
        /// Forwarded to a VPC peering network.
        PeeringVpc = 1,
        /// Forwarded to a Cloud VPN gateway.
        VpnGateway = 2,
        /// Forwarded to a Cloud Interconnect connection.
        Interconnect = 3,
        /// Forwarded to a Google Kubernetes Engine Container cluster master.
        #[deprecated]
        GkeMaster = 4,
        /// Forwarded to the next hop of a custom route imported from a peering VPC.
        ImportedCustomRouteNextHop = 5,
        /// Forwarded to a Cloud SQL instance.
        #[deprecated]
        CloudSqlInstance = 6,
        /// Forwarded to a VPC network in another project.
        AnotherProject = 7,
        /// Forwarded to an NCC Hub.
        NccHub = 8,
        /// Forwarded to a router appliance.
        RouterAppliance = 9,
        /// Forwarded to a Secure Web Proxy Gateway.
        SecureWebProxyGateway = 10,
    }
    impl Target {
        /// 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 => "TARGET_UNSPECIFIED",
                Self::PeeringVpc => "PEERING_VPC",
                Self::VpnGateway => "VPN_GATEWAY",
                Self::Interconnect => "INTERCONNECT",
                #[allow(deprecated)]
                Self::GkeMaster => "GKE_MASTER",
                Self::ImportedCustomRouteNextHop => "IMPORTED_CUSTOM_ROUTE_NEXT_HOP",
                #[allow(deprecated)]
                Self::CloudSqlInstance => "CLOUD_SQL_INSTANCE",
                Self::AnotherProject => "ANOTHER_PROJECT",
                Self::NccHub => "NCC_HUB",
                Self::RouterAppliance => "ROUTER_APPLIANCE",
                Self::SecureWebProxyGateway => "SECURE_WEB_PROXY_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 {
                "TARGET_UNSPECIFIED" => Some(Self::Unspecified),
                "PEERING_VPC" => Some(Self::PeeringVpc),
                "VPN_GATEWAY" => Some(Self::VpnGateway),
                "INTERCONNECT" => Some(Self::Interconnect),
                "GKE_MASTER" => Some(#[allow(deprecated)] Self::GkeMaster),
                "IMPORTED_CUSTOM_ROUTE_NEXT_HOP" => {
                    Some(Self::ImportedCustomRouteNextHop)
                }
                "CLOUD_SQL_INSTANCE" => Some(#[allow(deprecated)] Self::CloudSqlInstance),
                "ANOTHER_PROJECT" => Some(Self::AnotherProject),
                "NCC_HUB" => Some(Self::NccHub),
                "ROUTER_APPLIANCE" => Some(Self::RouterAppliance),
                "SECURE_WEB_PROXY_GATEWAY" => Some(Self::SecureWebProxyGateway),
                _ => None,
            }
        }
    }
}
/// Details of the final state "abort" and associated resource.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AbortInfo {
    /// Causes that the analysis is aborted.
    #[prost(enumeration = "abort_info::Cause", tag = "1")]
    pub cause: i32,
    /// URI of the resource that caused the abort.
    #[prost(string, tag = "2")]
    pub resource_uri: ::prost::alloc::string::String,
    /// IP address that caused the abort.
    #[prost(string, tag = "4")]
    pub ip_address: ::prost::alloc::string::String,
    /// List of project IDs the user specified in the request but lacks access to.
    /// In this case, analysis is aborted with the PERMISSION_DENIED cause.
    #[prost(string, repeated, tag = "3")]
    pub projects_missing_permission: ::prost::alloc::vec::Vec<
        ::prost::alloc::string::String,
    >,
}
/// Nested message and enum types in `AbortInfo`.
pub mod abort_info {
    /// Abort cause types:
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Cause {
        /// Cause is unspecified.
        Unspecified = 0,
        /// Aborted due to unknown network. Deprecated, not used in the new tests.
        #[deprecated]
        UnknownNetwork = 1,
        /// Aborted because no project information can be derived from the test
        /// input. Deprecated, not used in the new tests.
        #[deprecated]
        UnknownProject = 3,
        /// Aborted because traffic is sent from a public IP to an instance without
        /// an external IP. Deprecated, not used in the new tests.
        #[deprecated]
        NoExternalIp = 7,
        /// Aborted because none of the traces matches destination information
        /// specified in the input test request. Deprecated, not used in the new
        /// tests.
        #[deprecated]
        UnintendedDestination = 8,
        /// Aborted because the source endpoint could not be found. Deprecated, not
        /// used in the new tests.
        #[deprecated]
        SourceEndpointNotFound = 11,
        /// Aborted because the source network does not match the source endpoint.
        /// Deprecated, not used in the new tests.
        #[deprecated]
        MismatchedSourceNetwork = 12,
        /// Aborted because the destination endpoint could not be found. Deprecated,
        /// not used in the new tests.
        #[deprecated]
        DestinationEndpointNotFound = 13,
        /// Aborted because the destination network does not match the destination
        /// endpoint. Deprecated, not used in the new tests.
        #[deprecated]
        MismatchedDestinationNetwork = 14,
        /// Aborted because no endpoint with the packet's destination IP address is
        /// found.
        UnknownIp = 2,
        /// Aborted because no endpoint with the packet's destination IP is found in
        /// the Google-managed project.
        GoogleManagedServiceUnknownIp = 32,
        /// Aborted because the source IP address doesn't belong to any of the
        /// subnets of the source VPC network.
        SourceIpAddressNotInSourceNetwork = 23,
        /// Aborted because user lacks permission to access all or part of the
        /// network configurations required to run the test.
        PermissionDenied = 4,
        /// Aborted because user lacks permission to access Cloud NAT configs
        /// required to run the test.
        PermissionDeniedNoCloudNatConfigs = 28,
        /// Aborted because user lacks permission to access Network endpoint group
        /// endpoint configs required to run the test.
        PermissionDeniedNoNegEndpointConfigs = 29,
        /// Aborted because user lacks permission to access Cloud Router configs
        /// required to run the test.
        PermissionDeniedNoCloudRouterConfigs = 36,
        /// Aborted because no valid source or destination endpoint can be derived
        /// from the test request.
        NoSourceLocation = 5,
        /// Aborted because the source IP address is not contained within the subnet
        /// ranges of the provided VPC network.
        NoSourceGcpNetworkLocation = 42,
        /// Aborted because the source IP address is not contained within the
        /// destination ranges of the routes towards non-GCP networks in the provided
        /// VPC network.
        NoSourceNonGcpNetworkLocation = 43,
        /// Aborted because the source IP address can't be resolved as an Internet
        /// IP address.
        NoSourceInternetLocation = 44,
        /// Aborted because the source or destination endpoint specified in
        /// the request is invalid. Some examples:
        ///
        /// * The request might contain malformed resource URI, project ID, or IP
        ///   address.
        /// * The request might contain inconsistent information (for example, the
        ///   request might include both the instance and the network, but the instance
        ///   might not have a NIC in that network).
        InvalidArgument = 6,
        /// Aborted because the number of steps in the trace exceeds a certain
        /// limit. It might be caused by a routing loop.
        TraceTooLong = 9,
        /// Aborted due to internal server error.
        InternalError = 10,
        /// Aborted because the test scenario is not supported.
        Unsupported = 15,
        /// Aborted because the source and destination resources have no common IP
        /// version.
        MismatchedIpVersion = 16,
        /// Aborted because the connection between the control plane and the node of
        /// the source cluster is initiated by the node and managed by the
        /// Konnectivity proxy.
        GkeKonnectivityProxyUnsupported = 17,
        /// Aborted because expected resource configuration was missing.
        ResourceConfigNotFound = 18,
        /// Aborted because expected VM instance configuration was missing.
        VmInstanceConfigNotFound = 24,
        /// Aborted because expected network configuration was missing.
        NetworkConfigNotFound = 25,
        /// Aborted because expected firewall configuration was missing.
        FirewallConfigNotFound = 26,
        /// Aborted because expected route configuration was missing.
        RouteConfigNotFound = 27,
        /// Aborted because PSC endpoint selection for the Google-managed service
        /// is ambiguous (several PSC endpoints satisfy test input).
        GoogleManagedServiceAmbiguousPscEndpoint = 19,
        /// Aborted because endpoint selection for the Google-managed service is
        /// ambiguous (several endpoints satisfy test input).
        GoogleManagedServiceAmbiguousEndpoint = 39,
        /// Aborted because tests with a PSC-based Cloud SQL instance as a source are
        /// not supported.
        SourcePscCloudSqlUnsupported = 20,
        /// Aborted because tests with the external database as a source are not
        /// supported. In such replication scenarios, the connection is initiated by
        /// the Cloud SQL replica instance.
        SourceExternalCloudSqlUnsupported = 45,
        /// Aborted because tests with a Redis Cluster as a source are not supported.
        SourceRedisClusterUnsupported = 34,
        /// Aborted because tests with a Redis Instance as a source are not
        /// supported.
        SourceRedisInstanceUnsupported = 35,
        /// Aborted because tests with a forwarding rule as a source are not
        /// supported.
        SourceForwardingRuleUnsupported = 21,
        /// Aborted because one of the endpoints is a non-routable IP address
        /// (loopback, link-local, etc).
        NonRoutableIpAddress = 22,
        /// Aborted due to an unknown issue in the Google-managed project.
        UnknownIssueInGoogleManagedProject = 30,
        /// Aborted due to an unsupported configuration of the Google-managed
        /// project.
        UnsupportedGoogleManagedProjectConfig = 31,
        /// Aborted because the source endpoint is a Cloud Run revision with direct
        /// VPC access enabled, but there are no reserved serverless IP ranges.
        NoServerlessIpRanges = 37,
        /// Aborted because the used protocol is not supported for the used IP
        /// version.
        IpVersionProtocolMismatch = 40,
        /// Aborted because selected GKE Pod endpoint location is unknown. This is
        /// often the case for "Pending" Pods, which don't have assigned IP addresses
        /// yet.
        GkePodUnknownEndpointLocation = 41,
    }
    impl Cause {
        /// 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 => "CAUSE_UNSPECIFIED",
                #[allow(deprecated)]
                Self::UnknownNetwork => "UNKNOWN_NETWORK",
                #[allow(deprecated)]
                Self::UnknownProject => "UNKNOWN_PROJECT",
                #[allow(deprecated)]
                Self::NoExternalIp => "NO_EXTERNAL_IP",
                #[allow(deprecated)]
                Self::UnintendedDestination => "UNINTENDED_DESTINATION",
                #[allow(deprecated)]
                Self::SourceEndpointNotFound => "SOURCE_ENDPOINT_NOT_FOUND",
                #[allow(deprecated)]
                Self::MismatchedSourceNetwork => "MISMATCHED_SOURCE_NETWORK",
                #[allow(deprecated)]
                Self::DestinationEndpointNotFound => "DESTINATION_ENDPOINT_NOT_FOUND",
                #[allow(deprecated)]
                Self::MismatchedDestinationNetwork => "MISMATCHED_DESTINATION_NETWORK",
                Self::UnknownIp => "UNKNOWN_IP",
                Self::GoogleManagedServiceUnknownIp => {
                    "GOOGLE_MANAGED_SERVICE_UNKNOWN_IP"
                }
                Self::SourceIpAddressNotInSourceNetwork => {
                    "SOURCE_IP_ADDRESS_NOT_IN_SOURCE_NETWORK"
                }
                Self::PermissionDenied => "PERMISSION_DENIED",
                Self::PermissionDeniedNoCloudNatConfigs => {
                    "PERMISSION_DENIED_NO_CLOUD_NAT_CONFIGS"
                }
                Self::PermissionDeniedNoNegEndpointConfigs => {
                    "PERMISSION_DENIED_NO_NEG_ENDPOINT_CONFIGS"
                }
                Self::PermissionDeniedNoCloudRouterConfigs => {
                    "PERMISSION_DENIED_NO_CLOUD_ROUTER_CONFIGS"
                }
                Self::NoSourceLocation => "NO_SOURCE_LOCATION",
                Self::NoSourceGcpNetworkLocation => "NO_SOURCE_GCP_NETWORK_LOCATION",
                Self::NoSourceNonGcpNetworkLocation => {
                    "NO_SOURCE_NON_GCP_NETWORK_LOCATION"
                }
                Self::NoSourceInternetLocation => "NO_SOURCE_INTERNET_LOCATION",
                Self::InvalidArgument => "INVALID_ARGUMENT",
                Self::TraceTooLong => "TRACE_TOO_LONG",
                Self::InternalError => "INTERNAL_ERROR",
                Self::Unsupported => "UNSUPPORTED",
                Self::MismatchedIpVersion => "MISMATCHED_IP_VERSION",
                Self::GkeKonnectivityProxyUnsupported => {
                    "GKE_KONNECTIVITY_PROXY_UNSUPPORTED"
                }
                Self::ResourceConfigNotFound => "RESOURCE_CONFIG_NOT_FOUND",
                Self::VmInstanceConfigNotFound => "VM_INSTANCE_CONFIG_NOT_FOUND",
                Self::NetworkConfigNotFound => "NETWORK_CONFIG_NOT_FOUND",
                Self::FirewallConfigNotFound => "FIREWALL_CONFIG_NOT_FOUND",
                Self::RouteConfigNotFound => "ROUTE_CONFIG_NOT_FOUND",
                Self::GoogleManagedServiceAmbiguousPscEndpoint => {
                    "GOOGLE_MANAGED_SERVICE_AMBIGUOUS_PSC_ENDPOINT"
                }
                Self::GoogleManagedServiceAmbiguousEndpoint => {
                    "GOOGLE_MANAGED_SERVICE_AMBIGUOUS_ENDPOINT"
                }
                Self::SourcePscCloudSqlUnsupported => "SOURCE_PSC_CLOUD_SQL_UNSUPPORTED",
                Self::SourceExternalCloudSqlUnsupported => {
                    "SOURCE_EXTERNAL_CLOUD_SQL_UNSUPPORTED"
                }
                Self::SourceRedisClusterUnsupported => "SOURCE_REDIS_CLUSTER_UNSUPPORTED",
                Self::SourceRedisInstanceUnsupported => {
                    "SOURCE_REDIS_INSTANCE_UNSUPPORTED"
                }
                Self::SourceForwardingRuleUnsupported => {
                    "SOURCE_FORWARDING_RULE_UNSUPPORTED"
                }
                Self::NonRoutableIpAddress => "NON_ROUTABLE_IP_ADDRESS",
                Self::UnknownIssueInGoogleManagedProject => {
                    "UNKNOWN_ISSUE_IN_GOOGLE_MANAGED_PROJECT"
                }
                Self::UnsupportedGoogleManagedProjectConfig => {
                    "UNSUPPORTED_GOOGLE_MANAGED_PROJECT_CONFIG"
                }
                Self::NoServerlessIpRanges => "NO_SERVERLESS_IP_RANGES",
                Self::IpVersionProtocolMismatch => "IP_VERSION_PROTOCOL_MISMATCH",
                Self::GkePodUnknownEndpointLocation => {
                    "GKE_POD_UNKNOWN_ENDPOINT_LOCATION"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CAUSE_UNSPECIFIED" => Some(Self::Unspecified),
                "UNKNOWN_NETWORK" => Some(#[allow(deprecated)] Self::UnknownNetwork),
                "UNKNOWN_PROJECT" => Some(#[allow(deprecated)] Self::UnknownProject),
                "NO_EXTERNAL_IP" => Some(#[allow(deprecated)] Self::NoExternalIp),
                "UNINTENDED_DESTINATION" => {
                    Some(#[allow(deprecated)] Self::UnintendedDestination)
                }
                "SOURCE_ENDPOINT_NOT_FOUND" => {
                    Some(#[allow(deprecated)] Self::SourceEndpointNotFound)
                }
                "MISMATCHED_SOURCE_NETWORK" => {
                    Some(#[allow(deprecated)] Self::MismatchedSourceNetwork)
                }
                "DESTINATION_ENDPOINT_NOT_FOUND" => {
                    Some(#[allow(deprecated)] Self::DestinationEndpointNotFound)
                }
                "MISMATCHED_DESTINATION_NETWORK" => {
                    Some(#[allow(deprecated)] Self::MismatchedDestinationNetwork)
                }
                "UNKNOWN_IP" => Some(Self::UnknownIp),
                "GOOGLE_MANAGED_SERVICE_UNKNOWN_IP" => {
                    Some(Self::GoogleManagedServiceUnknownIp)
                }
                "SOURCE_IP_ADDRESS_NOT_IN_SOURCE_NETWORK" => {
                    Some(Self::SourceIpAddressNotInSourceNetwork)
                }
                "PERMISSION_DENIED" => Some(Self::PermissionDenied),
                "PERMISSION_DENIED_NO_CLOUD_NAT_CONFIGS" => {
                    Some(Self::PermissionDeniedNoCloudNatConfigs)
                }
                "PERMISSION_DENIED_NO_NEG_ENDPOINT_CONFIGS" => {
                    Some(Self::PermissionDeniedNoNegEndpointConfigs)
                }
                "PERMISSION_DENIED_NO_CLOUD_ROUTER_CONFIGS" => {
                    Some(Self::PermissionDeniedNoCloudRouterConfigs)
                }
                "NO_SOURCE_LOCATION" => Some(Self::NoSourceLocation),
                "NO_SOURCE_GCP_NETWORK_LOCATION" => {
                    Some(Self::NoSourceGcpNetworkLocation)
                }
                "NO_SOURCE_NON_GCP_NETWORK_LOCATION" => {
                    Some(Self::NoSourceNonGcpNetworkLocation)
                }
                "NO_SOURCE_INTERNET_LOCATION" => Some(Self::NoSourceInternetLocation),
                "INVALID_ARGUMENT" => Some(Self::InvalidArgument),
                "TRACE_TOO_LONG" => Some(Self::TraceTooLong),
                "INTERNAL_ERROR" => Some(Self::InternalError),
                "UNSUPPORTED" => Some(Self::Unsupported),
                "MISMATCHED_IP_VERSION" => Some(Self::MismatchedIpVersion),
                "GKE_KONNECTIVITY_PROXY_UNSUPPORTED" => {
                    Some(Self::GkeKonnectivityProxyUnsupported)
                }
                "RESOURCE_CONFIG_NOT_FOUND" => Some(Self::ResourceConfigNotFound),
                "VM_INSTANCE_CONFIG_NOT_FOUND" => Some(Self::VmInstanceConfigNotFound),
                "NETWORK_CONFIG_NOT_FOUND" => Some(Self::NetworkConfigNotFound),
                "FIREWALL_CONFIG_NOT_FOUND" => Some(Self::FirewallConfigNotFound),
                "ROUTE_CONFIG_NOT_FOUND" => Some(Self::RouteConfigNotFound),
                "GOOGLE_MANAGED_SERVICE_AMBIGUOUS_PSC_ENDPOINT" => {
                    Some(Self::GoogleManagedServiceAmbiguousPscEndpoint)
                }
                "GOOGLE_MANAGED_SERVICE_AMBIGUOUS_ENDPOINT" => {
                    Some(Self::GoogleManagedServiceAmbiguousEndpoint)
                }
                "SOURCE_PSC_CLOUD_SQL_UNSUPPORTED" => {
                    Some(Self::SourcePscCloudSqlUnsupported)
                }
                "SOURCE_EXTERNAL_CLOUD_SQL_UNSUPPORTED" => {
                    Some(Self::SourceExternalCloudSqlUnsupported)
                }
                "SOURCE_REDIS_CLUSTER_UNSUPPORTED" => {
                    Some(Self::SourceRedisClusterUnsupported)
                }
                "SOURCE_REDIS_INSTANCE_UNSUPPORTED" => {
                    Some(Self::SourceRedisInstanceUnsupported)
                }
                "SOURCE_FORWARDING_RULE_UNSUPPORTED" => {
                    Some(Self::SourceForwardingRuleUnsupported)
                }
                "NON_ROUTABLE_IP_ADDRESS" => Some(Self::NonRoutableIpAddress),
                "UNKNOWN_ISSUE_IN_GOOGLE_MANAGED_PROJECT" => {
                    Some(Self::UnknownIssueInGoogleManagedProject)
                }
                "UNSUPPORTED_GOOGLE_MANAGED_PROJECT_CONFIG" => {
                    Some(Self::UnsupportedGoogleManagedProjectConfig)
                }
                "NO_SERVERLESS_IP_RANGES" => Some(Self::NoServerlessIpRanges),
                "IP_VERSION_PROTOCOL_MISMATCH" => Some(Self::IpVersionProtocolMismatch),
                "GKE_POD_UNKNOWN_ENDPOINT_LOCATION" => {
                    Some(Self::GkePodUnknownEndpointLocation)
                }
                _ => None,
            }
        }
    }
}
/// Details of the final state "drop" and associated resource.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DropInfo {
    /// Cause that the packet is dropped.
    #[prost(enumeration = "drop_info::Cause", tag = "1")]
    pub cause: i32,
    /// URI of the resource that caused the drop.
    #[prost(string, tag = "2")]
    pub resource_uri: ::prost::alloc::string::String,
    /// Source IP address of the dropped packet (if relevant).
    #[prost(string, tag = "3")]
    pub source_ip: ::prost::alloc::string::String,
    /// Destination IP address of the dropped packet (if relevant).
    #[prost(string, tag = "4")]
    pub destination_ip: ::prost::alloc::string::String,
    /// Region of the dropped packet (if relevant).
    #[prost(string, tag = "5")]
    pub region: ::prost::alloc::string::String,
    /// Geolocation (region code) of the source IP address (if relevant).
    #[prost(string, tag = "6")]
    pub source_geolocation_code: ::prost::alloc::string::String,
    /// Geolocation (region code) of the destination IP address (if relevant).
    #[prost(string, tag = "7")]
    pub destination_geolocation_code: ::prost::alloc::string::String,
}
/// Nested message and enum types in `DropInfo`.
pub mod drop_info {
    /// Drop cause types:
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Cause {
        /// Cause is unspecified.
        Unspecified = 0,
        /// Destination external address cannot be resolved to a known target. If
        /// the address is used in a Google Cloud project, provide the project ID
        /// as test input.
        UnknownExternalAddress = 1,
        /// A Compute Engine instance can only send or receive a packet with a
        /// foreign IP address if ip_forward is enabled.
        ForeignIpDisallowed = 2,
        /// Dropped due to a firewall rule, unless allowed due to connection
        /// tracking.
        FirewallRule = 3,
        /// Dropped due to no matching routes.
        NoRoute = 4,
        /// Dropped due to invalid route. Route's next hop is a blackhole.
        RouteBlackhole = 5,
        /// Packet is sent to a wrong (unintended) network. Example: you trace a
        /// packet from VM1:Network1 to VM2:Network2, however, the route configured
        /// in Network1 sends the packet destined for VM2's IP address to Network3.
        RouteWrongNetwork = 6,
        /// Route's next hop IP address cannot be resolved to a GCP resource.
        RouteNextHopIpAddressNotResolved = 42,
        /// Route's next hop resource is not found.
        RouteNextHopResourceNotFound = 43,
        /// Route's next hop instance doesn't have a NIC in the route's network.
        RouteNextHopInstanceWrongNetwork = 49,
        /// Route's next hop IP address is not a primary IP address of the next hop
        /// instance.
        RouteNextHopInstanceNonPrimaryIp = 50,
        /// Route's next hop forwarding rule doesn't match next hop IP address.
        RouteNextHopForwardingRuleIpMismatch = 51,
        /// Route's next hop VPN tunnel is down (does not have valid IKE SAs).
        RouteNextHopVpnTunnelNotEstablished = 52,
        /// Route's next hop forwarding rule type is invalid (it's not a forwarding
        /// rule of the internal passthrough load balancer).
        RouteNextHopForwardingRuleTypeInvalid = 53,
        /// Packet is sent from the Internet to the private IPv6 address.
        NoRouteFromInternetToPrivateIpv6Address = 44,
        /// Packet is sent from the Internet to the private IPv4 address.
        NoRouteFromInternetToPrivateIpv4Address = 109,
        /// Packet is sent from the external IPv6 source address of an instance to
        /// the private IPv6 address of an instance.
        NoRouteFromExternalIpv6SourceToPrivateIpv6Address = 98,
        /// The packet does not match a policy-based VPN tunnel local selector.
        VpnTunnelLocalSelectorMismatch = 45,
        /// The packet does not match a policy-based VPN tunnel remote selector.
        VpnTunnelRemoteSelectorMismatch = 46,
        /// Packet with internal destination address sent to the internet gateway.
        PrivateTrafficToInternet = 7,
        /// Endpoint with only an internal IP address tries to access Google API and
        /// services, but Private Google Access is not enabled in the subnet or is
        /// not applicable.
        PrivateGoogleAccessDisallowed = 8,
        /// Source endpoint tries to access Google API and services through the VPN
        /// tunnel to another network, but Private Google Access needs to be enabled
        /// in the source endpoint network.
        PrivateGoogleAccessViaVpnTunnelUnsupported = 47,
        /// Endpoint with only an internal IP address tries to access external hosts,
        /// but there is no matching Cloud NAT gateway in the subnet.
        NoExternalAddress = 9,
        /// Destination internal address cannot be resolved to a known target. If
        /// this is a shared VPC scenario, verify if the service project ID is
        /// provided as test input. Otherwise, verify if the IP address is being
        /// used in the project.
        UnknownInternalAddress = 10,
        /// Forwarding rule's protocol and ports do not match the packet header.
        ForwardingRuleMismatch = 11,
        /// Forwarding rule does not have backends configured.
        ForwardingRuleNoInstances = 12,
        /// Firewalls block the health check probes to the backends and cause
        /// the backends to be unavailable for traffic from the load balancer.
        /// For more details, see [Health check firewall
        /// rules](<https://cloud.google.com/load-balancing/docs/health-checks#firewall_rules>).
        FirewallBlockingLoadBalancerBackendHealthCheck = 13,
        /// Matching ingress firewall rules by network tags for packets sent via
        /// serverless VPC direct egress is unsupported. Behavior is undefined.
        /// <https://cloud.google.com/run/docs/configuring/vpc-direct-vpc#limitations>
        IngressFirewallTagsUnsupportedByDirectVpcEgress = 85,
        /// Packet is sent from or to a Compute Engine instance that is not in a
        /// running state.
        InstanceNotRunning = 14,
        /// Packet sent from or to a GKE cluster that is not in running state.
        GkeClusterNotRunning = 27,
        /// Packet sent from or to a GKE Pod that is not in running state.
        GkePodNotRunning = 103,
        /// Packet sent from or to a Cloud SQL instance that is not in running state.
        CloudSqlInstanceNotRunning = 28,
        /// Packet sent from or to a Redis Instance that is not in running state.
        RedisInstanceNotRunning = 68,
        /// Packet sent from or to a Redis Cluster that is not in running state.
        RedisClusterNotRunning = 69,
        /// The type of traffic is blocked and the user cannot configure a firewall
        /// rule to enable it. See [Always blocked
        /// traffic](<https://cloud.google.com/vpc/docs/firewalls#blockedtraffic>) for
        /// more details.
        TrafficTypeBlocked = 15,
        /// Access to Google Kubernetes Engine cluster master's endpoint is not
        /// authorized. See [Access to the cluster
        /// endpoints](<https://cloud.google.com/kubernetes-engine/docs/how-to/private-clusters#access_to_the_cluster_endpoints>)
        /// for more details.
        GkeMasterUnauthorizedAccess = 16,
        /// Access to the Cloud SQL instance endpoint is not authorized.
        /// See [Authorizing with authorized
        /// networks](<https://cloud.google.com/sql/docs/mysql/authorize-networks>) for
        /// more details.
        CloudSqlInstanceUnauthorizedAccess = 17,
        /// Packet was dropped inside Google Kubernetes Engine Service.
        DroppedInsideGkeService = 18,
        /// Packet was dropped inside Cloud SQL Service.
        DroppedInsideCloudSqlService = 19,
        /// Packet was dropped because there is no peering between the originating
        /// network and the Google Managed Services Network.
        GoogleManagedServiceNoPeering = 20,
        /// Packet was dropped because the Google-managed service uses Private
        /// Service Connect (PSC), but the PSC endpoint is not found in the project.
        GoogleManagedServiceNoPscEndpoint = 38,
        /// Packet was dropped because the GKE cluster uses Private Service Connect
        /// (PSC), but the PSC endpoint is not found in the project.
        GkePscEndpointMissing = 36,
        /// Packet was dropped because the Cloud SQL instance has neither a private
        /// nor a public IP address.
        CloudSqlInstanceNoIpAddress = 21,
        /// Packet was dropped because a GKE cluster private endpoint is
        /// unreachable from a region different from the cluster's region.
        GkeControlPlaneRegionMismatch = 30,
        /// Packet sent from a public GKE cluster control plane to a private
        /// IP address.
        PublicGkeControlPlaneToPrivateDestination = 31,
        /// Packet was dropped because there is no route from a GKE cluster
        /// control plane to a destination network.
        GkeControlPlaneNoRoute = 32,
        /// Packet sent from a Cloud SQL instance to an external IP address is not
        /// allowed. The Cloud SQL instance is not configured to send packets to
        /// external IP addresses.
        CloudSqlInstanceNotConfiguredForExternalTraffic = 33,
        /// Packet sent from a Cloud SQL instance with only a public IP address to a
        /// private IP address.
        PublicCloudSqlInstanceToPrivateDestination = 34,
        /// Packet was dropped because there is no route from a Cloud SQL
        /// instance to a destination network.
        CloudSqlInstanceNoRoute = 35,
        /// Packet was dropped because the Cloud SQL instance requires all
        /// connections to use Cloud SQL connectors and to target the Cloud SQL proxy
        /// port (3307).
        CloudSqlConnectorRequired = 63,
        /// Packet could be dropped because the Cloud Function is not in an active
        /// status.
        CloudFunctionNotActive = 22,
        /// Packet could be dropped because no VPC connector is set.
        VpcConnectorNotSet = 23,
        /// Packet could be dropped because the VPC connector is not in a running
        /// state.
        VpcConnectorNotRunning = 24,
        /// Packet could be dropped because the traffic from the serverless service
        /// to the VPC connector is not allowed.
        VpcConnectorServerlessTrafficBlocked = 60,
        /// Packet could be dropped because the health check traffic to the VPC
        /// connector is not allowed.
        VpcConnectorHealthCheckTrafficBlocked = 61,
        /// Packet could be dropped because it was sent from a different region
        /// to a regional forwarding without global access.
        ForwardingRuleRegionMismatch = 25,
        /// The Private Service Connect endpoint is in a project that is not approved
        /// to connect to the service.
        PscConnectionNotAccepted = 26,
        /// The packet is sent to the Private Service Connect endpoint over the
        /// peering, but [it's not
        /// supported](<https://cloud.google.com/vpc/docs/configure-private-service-connect-services#on-premises>).
        PscEndpointAccessedFromPeeredNetwork = 41,
        /// The packet is sent to the Private Service Connect backend (network
        /// endpoint group), but the producer PSC forwarding rule does not have
        /// global access enabled.
        PscNegProducerEndpointNoGlobalAccess = 48,
        /// The packet is sent to the Private Service Connect backend (network
        /// endpoint group), but the producer PSC forwarding rule has multiple ports
        /// specified.
        PscNegProducerForwardingRuleMultiplePorts = 54,
        /// The packet is sent to the Private Service Connect backend (network
        /// endpoint group) targeting a Cloud SQL service attachment, but this
        /// configuration is not supported.
        CloudSqlPscNegUnsupported = 58,
        /// No NAT subnets are defined for the PSC service attachment.
        NoNatSubnetsForPscServiceAttachment = 57,
        /// PSC endpoint is accessed via NCC, but PSC transitivity configuration is
        /// not yet propagated.
        PscTransitivityNotPropagated = 64,
        /// The packet sent from the hybrid NEG proxy matches a non-dynamic route,
        /// but such a configuration is not supported.
        HybridNegNonDynamicRouteMatched = 55,
        /// The packet sent from the hybrid NEG proxy matches a dynamic route with a
        /// next hop in a different region, but such a configuration is not
        /// supported.
        HybridNegNonLocalDynamicRouteMatched = 56,
        /// Packet sent from a Cloud Run revision that is not ready.
        CloudRunRevisionNotReady = 29,
        /// Packet was dropped inside Private Service Connect service producer.
        DroppedInsidePscServiceProducer = 37,
        /// Packet sent to a load balancer, which requires a proxy-only subnet and
        /// the subnet is not found.
        LoadBalancerHasNoProxySubnet = 39,
        /// Packet sent to Cloud Nat without active NAT IPs.
        CloudNatNoAddresses = 40,
        /// Packet is stuck in a routing loop.
        RoutingLoop = 59,
        /// Packet is dropped inside a Google-managed service due to being delivered
        /// in return trace to an endpoint that doesn't match the endpoint the packet
        /// was sent from in forward trace. Used only for return traces.
        DroppedInsideGoogleManagedService = 62,
        /// Packet is dropped due to a load balancer backend instance not having a
        /// network interface in the network expected by the load balancer.
        LoadBalancerBackendInvalidNetwork = 65,
        /// Packet is dropped due to a backend service named port not being defined
        /// on the instance group level.
        BackendServiceNamedPortNotDefined = 66,
        /// Packet is dropped due to a destination IP range being part of a Private
        /// NAT IP range.
        DestinationIsPrivateNatIpRange = 67,
        /// Generic drop cause for a packet being dropped inside a Redis Instance
        /// service project.
        DroppedInsideRedisInstanceService = 70,
        /// Packet is dropped due to an unsupported port being used to connect to a
        /// Redis Instance. Port 6379 should be used to connect to a Redis Instance.
        RedisInstanceUnsupportedPort = 71,
        /// Packet is dropped due to connecting from PUPI address to a PSA based
        /// Redis Instance.
        RedisInstanceConnectingFromPupiAddress = 72,
        /// Packet is dropped due to no route to the destination network.
        RedisInstanceNoRouteToDestinationNetwork = 73,
        /// Redis Instance does not have an external IP address.
        RedisInstanceNoExternalIp = 74,
        /// Packet is dropped due to an unsupported protocol being used to connect to
        /// a Redis Instance. Only TCP connections are accepted by a Redis Instance.
        RedisInstanceUnsupportedProtocol = 78,
        /// Generic drop cause for a packet being dropped inside a Redis Cluster
        /// service project.
        DroppedInsideRedisClusterService = 75,
        /// Packet is dropped due to an unsupported port being used to connect to a
        /// Redis Cluster. Ports 6379 and 11000 to 13047 should be used to connect to
        /// a Redis Cluster.
        RedisClusterUnsupportedPort = 76,
        /// Redis Cluster does not have an external IP address.
        RedisClusterNoExternalIp = 77,
        /// Packet is dropped due to an unsupported protocol being used to connect to
        /// a Redis Cluster. Only TCP connections are accepted by a Redis Cluster.
        RedisClusterUnsupportedProtocol = 79,
        /// Packet from the non-GCP (on-prem) or unknown GCP network is dropped due
        /// to the destination IP address not belonging to any IP prefix advertised
        /// via BGP by the Cloud Router.
        NoAdvertisedRouteToGcpDestination = 80,
        /// Packet from the non-GCP (on-prem) or unknown GCP network is dropped due
        /// to the destination IP address not belonging to any IP prefix included to
        /// the local traffic selector of the VPN tunnel.
        NoTrafficSelectorToGcpDestination = 81,
        /// Packet from the unknown peered network is dropped due to no known route
        /// from the source network to the destination IP address.
        NoKnownRouteFromPeeredNetworkToDestination = 82,
        /// Sending packets processed by the Private NAT Gateways to the Private
        /// Service Connect endpoints is not supported.
        PrivateNatToPscEndpointUnsupported = 83,
        /// Packet is sent to the PSC port mapping service, but its destination port
        /// does not match any port mapping rules.
        PscPortMappingPortMismatch = 86,
        /// Sending packets directly to the PSC port mapping service without going
        /// through the PSC connection is not supported.
        PscPortMappingWithoutPscConnectionUnsupported = 87,
        /// Packet with destination IP address within the reserved NAT64 range is
        /// dropped due to matching a route of an unsupported type.
        UnsupportedRouteMatchedForNat64Destination = 88,
        /// Packet could be dropped because hybrid endpoint like a VPN gateway or
        /// Interconnect is not allowed to send traffic to the Internet.
        TrafficFromHybridEndpointToInternetDisallowed = 89,
        /// Packet with destination IP address within the reserved NAT64 range is
        /// dropped due to no matching NAT gateway in the subnet.
        NoMatchingNat64Gateway = 90,
        /// Packet is dropped due to matching a Private NAT64 gateway with no rules
        /// for source IPv6 addresses.
        NoConfiguredPrivateNat64Rule = 107,
        /// Packet is dropped due to being sent to a backend of a passthrough load
        /// balancer that doesn't use the same IP version as the frontend.
        LoadBalancerBackendIpVersionMismatch = 96,
        /// Packet from the unknown NCC network is dropped due to no known route
        /// from the source network to the destination IP address.
        NoKnownRouteFromNccNetworkToDestination = 97,
        /// Packet is dropped by Cloud NAT due to using an unsupported protocol.
        CloudNatProtocolUnsupported = 99,
        /// Packet is dropped due to using an unsupported protocol (any other than
        /// UDP) for L2 Interconnect.
        L2InterconnectUnsupportedProtocol = 100,
        /// Packet is dropped due to using an unsupported port (any other than
        /// 6081) for L2 Interconnect.
        L2InterconnectUnsupportedPort = 101,
        /// Packet is dropped due to destination IP not matching the appliance
        /// mapping IPs configured on the L2 Interconnect attachment.
        L2InterconnectDestinationIpMismatch = 102,
        /// Packet could be dropped because it matches a route associated with an NCC
        /// spoke in the hybrid subnet context, but such a configuration is not
        /// supported.
        NccRouteWithinHybridSubnetUnsupported = 104,
        /// Packet is dropped because the region of the hybrid subnet is different
        /// from the region of the next hop of the route matched within this hybrid
        /// subnet.
        HybridSubnetRegionMismatch = 105,
        /// Packet is dropped because no matching route was found in the hybrid
        /// subnet.
        HybridSubnetNoRoute = 106,
        /// Packet is dropped by GKE Network Policy.
        GkeNetworkPolicy = 108,
        /// Packet is dropped because there is no valid matching route from the
        /// network of the Google-managed service to the destination.
        NoValidRouteFromGoogleManagedNetworkToDestination = 110,
    }
    impl Cause {
        /// 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 => "CAUSE_UNSPECIFIED",
                Self::UnknownExternalAddress => "UNKNOWN_EXTERNAL_ADDRESS",
                Self::ForeignIpDisallowed => "FOREIGN_IP_DISALLOWED",
                Self::FirewallRule => "FIREWALL_RULE",
                Self::NoRoute => "NO_ROUTE",
                Self::RouteBlackhole => "ROUTE_BLACKHOLE",
                Self::RouteWrongNetwork => "ROUTE_WRONG_NETWORK",
                Self::RouteNextHopIpAddressNotResolved => {
                    "ROUTE_NEXT_HOP_IP_ADDRESS_NOT_RESOLVED"
                }
                Self::RouteNextHopResourceNotFound => "ROUTE_NEXT_HOP_RESOURCE_NOT_FOUND",
                Self::RouteNextHopInstanceWrongNetwork => {
                    "ROUTE_NEXT_HOP_INSTANCE_WRONG_NETWORK"
                }
                Self::RouteNextHopInstanceNonPrimaryIp => {
                    "ROUTE_NEXT_HOP_INSTANCE_NON_PRIMARY_IP"
                }
                Self::RouteNextHopForwardingRuleIpMismatch => {
                    "ROUTE_NEXT_HOP_FORWARDING_RULE_IP_MISMATCH"
                }
                Self::RouteNextHopVpnTunnelNotEstablished => {
                    "ROUTE_NEXT_HOP_VPN_TUNNEL_NOT_ESTABLISHED"
                }
                Self::RouteNextHopForwardingRuleTypeInvalid => {
                    "ROUTE_NEXT_HOP_FORWARDING_RULE_TYPE_INVALID"
                }
                Self::NoRouteFromInternetToPrivateIpv6Address => {
                    "NO_ROUTE_FROM_INTERNET_TO_PRIVATE_IPV6_ADDRESS"
                }
                Self::NoRouteFromInternetToPrivateIpv4Address => {
                    "NO_ROUTE_FROM_INTERNET_TO_PRIVATE_IPV4_ADDRESS"
                }
                Self::NoRouteFromExternalIpv6SourceToPrivateIpv6Address => {
                    "NO_ROUTE_FROM_EXTERNAL_IPV6_SOURCE_TO_PRIVATE_IPV6_ADDRESS"
                }
                Self::VpnTunnelLocalSelectorMismatch => {
                    "VPN_TUNNEL_LOCAL_SELECTOR_MISMATCH"
                }
                Self::VpnTunnelRemoteSelectorMismatch => {
                    "VPN_TUNNEL_REMOTE_SELECTOR_MISMATCH"
                }
                Self::PrivateTrafficToInternet => "PRIVATE_TRAFFIC_TO_INTERNET",
                Self::PrivateGoogleAccessDisallowed => "PRIVATE_GOOGLE_ACCESS_DISALLOWED",
                Self::PrivateGoogleAccessViaVpnTunnelUnsupported => {
                    "PRIVATE_GOOGLE_ACCESS_VIA_VPN_TUNNEL_UNSUPPORTED"
                }
                Self::NoExternalAddress => "NO_EXTERNAL_ADDRESS",
                Self::UnknownInternalAddress => "UNKNOWN_INTERNAL_ADDRESS",
                Self::ForwardingRuleMismatch => "FORWARDING_RULE_MISMATCH",
                Self::ForwardingRuleNoInstances => "FORWARDING_RULE_NO_INSTANCES",
                Self::FirewallBlockingLoadBalancerBackendHealthCheck => {
                    "FIREWALL_BLOCKING_LOAD_BALANCER_BACKEND_HEALTH_CHECK"
                }
                Self::IngressFirewallTagsUnsupportedByDirectVpcEgress => {
                    "INGRESS_FIREWALL_TAGS_UNSUPPORTED_BY_DIRECT_VPC_EGRESS"
                }
                Self::InstanceNotRunning => "INSTANCE_NOT_RUNNING",
                Self::GkeClusterNotRunning => "GKE_CLUSTER_NOT_RUNNING",
                Self::GkePodNotRunning => "GKE_POD_NOT_RUNNING",
                Self::CloudSqlInstanceNotRunning => "CLOUD_SQL_INSTANCE_NOT_RUNNING",
                Self::RedisInstanceNotRunning => "REDIS_INSTANCE_NOT_RUNNING",
                Self::RedisClusterNotRunning => "REDIS_CLUSTER_NOT_RUNNING",
                Self::TrafficTypeBlocked => "TRAFFIC_TYPE_BLOCKED",
                Self::GkeMasterUnauthorizedAccess => "GKE_MASTER_UNAUTHORIZED_ACCESS",
                Self::CloudSqlInstanceUnauthorizedAccess => {
                    "CLOUD_SQL_INSTANCE_UNAUTHORIZED_ACCESS"
                }
                Self::DroppedInsideGkeService => "DROPPED_INSIDE_GKE_SERVICE",
                Self::DroppedInsideCloudSqlService => "DROPPED_INSIDE_CLOUD_SQL_SERVICE",
                Self::GoogleManagedServiceNoPeering => {
                    "GOOGLE_MANAGED_SERVICE_NO_PEERING"
                }
                Self::GoogleManagedServiceNoPscEndpoint => {
                    "GOOGLE_MANAGED_SERVICE_NO_PSC_ENDPOINT"
                }
                Self::GkePscEndpointMissing => "GKE_PSC_ENDPOINT_MISSING",
                Self::CloudSqlInstanceNoIpAddress => "CLOUD_SQL_INSTANCE_NO_IP_ADDRESS",
                Self::GkeControlPlaneRegionMismatch => {
                    "GKE_CONTROL_PLANE_REGION_MISMATCH"
                }
                Self::PublicGkeControlPlaneToPrivateDestination => {
                    "PUBLIC_GKE_CONTROL_PLANE_TO_PRIVATE_DESTINATION"
                }
                Self::GkeControlPlaneNoRoute => "GKE_CONTROL_PLANE_NO_ROUTE",
                Self::CloudSqlInstanceNotConfiguredForExternalTraffic => {
                    "CLOUD_SQL_INSTANCE_NOT_CONFIGURED_FOR_EXTERNAL_TRAFFIC"
                }
                Self::PublicCloudSqlInstanceToPrivateDestination => {
                    "PUBLIC_CLOUD_SQL_INSTANCE_TO_PRIVATE_DESTINATION"
                }
                Self::CloudSqlInstanceNoRoute => "CLOUD_SQL_INSTANCE_NO_ROUTE",
                Self::CloudSqlConnectorRequired => "CLOUD_SQL_CONNECTOR_REQUIRED",
                Self::CloudFunctionNotActive => "CLOUD_FUNCTION_NOT_ACTIVE",
                Self::VpcConnectorNotSet => "VPC_CONNECTOR_NOT_SET",
                Self::VpcConnectorNotRunning => "VPC_CONNECTOR_NOT_RUNNING",
                Self::VpcConnectorServerlessTrafficBlocked => {
                    "VPC_CONNECTOR_SERVERLESS_TRAFFIC_BLOCKED"
                }
                Self::VpcConnectorHealthCheckTrafficBlocked => {
                    "VPC_CONNECTOR_HEALTH_CHECK_TRAFFIC_BLOCKED"
                }
                Self::ForwardingRuleRegionMismatch => "FORWARDING_RULE_REGION_MISMATCH",
                Self::PscConnectionNotAccepted => "PSC_CONNECTION_NOT_ACCEPTED",
                Self::PscEndpointAccessedFromPeeredNetwork => {
                    "PSC_ENDPOINT_ACCESSED_FROM_PEERED_NETWORK"
                }
                Self::PscNegProducerEndpointNoGlobalAccess => {
                    "PSC_NEG_PRODUCER_ENDPOINT_NO_GLOBAL_ACCESS"
                }
                Self::PscNegProducerForwardingRuleMultiplePorts => {
                    "PSC_NEG_PRODUCER_FORWARDING_RULE_MULTIPLE_PORTS"
                }
                Self::CloudSqlPscNegUnsupported => "CLOUD_SQL_PSC_NEG_UNSUPPORTED",
                Self::NoNatSubnetsForPscServiceAttachment => {
                    "NO_NAT_SUBNETS_FOR_PSC_SERVICE_ATTACHMENT"
                }
                Self::PscTransitivityNotPropagated => "PSC_TRANSITIVITY_NOT_PROPAGATED",
                Self::HybridNegNonDynamicRouteMatched => {
                    "HYBRID_NEG_NON_DYNAMIC_ROUTE_MATCHED"
                }
                Self::HybridNegNonLocalDynamicRouteMatched => {
                    "HYBRID_NEG_NON_LOCAL_DYNAMIC_ROUTE_MATCHED"
                }
                Self::CloudRunRevisionNotReady => "CLOUD_RUN_REVISION_NOT_READY",
                Self::DroppedInsidePscServiceProducer => {
                    "DROPPED_INSIDE_PSC_SERVICE_PRODUCER"
                }
                Self::LoadBalancerHasNoProxySubnet => "LOAD_BALANCER_HAS_NO_PROXY_SUBNET",
                Self::CloudNatNoAddresses => "CLOUD_NAT_NO_ADDRESSES",
                Self::RoutingLoop => "ROUTING_LOOP",
                Self::DroppedInsideGoogleManagedService => {
                    "DROPPED_INSIDE_GOOGLE_MANAGED_SERVICE"
                }
                Self::LoadBalancerBackendInvalidNetwork => {
                    "LOAD_BALANCER_BACKEND_INVALID_NETWORK"
                }
                Self::BackendServiceNamedPortNotDefined => {
                    "BACKEND_SERVICE_NAMED_PORT_NOT_DEFINED"
                }
                Self::DestinationIsPrivateNatIpRange => {
                    "DESTINATION_IS_PRIVATE_NAT_IP_RANGE"
                }
                Self::DroppedInsideRedisInstanceService => {
                    "DROPPED_INSIDE_REDIS_INSTANCE_SERVICE"
                }
                Self::RedisInstanceUnsupportedPort => "REDIS_INSTANCE_UNSUPPORTED_PORT",
                Self::RedisInstanceConnectingFromPupiAddress => {
                    "REDIS_INSTANCE_CONNECTING_FROM_PUPI_ADDRESS"
                }
                Self::RedisInstanceNoRouteToDestinationNetwork => {
                    "REDIS_INSTANCE_NO_ROUTE_TO_DESTINATION_NETWORK"
                }
                Self::RedisInstanceNoExternalIp => "REDIS_INSTANCE_NO_EXTERNAL_IP",
                Self::RedisInstanceUnsupportedProtocol => {
                    "REDIS_INSTANCE_UNSUPPORTED_PROTOCOL"
                }
                Self::DroppedInsideRedisClusterService => {
                    "DROPPED_INSIDE_REDIS_CLUSTER_SERVICE"
                }
                Self::RedisClusterUnsupportedPort => "REDIS_CLUSTER_UNSUPPORTED_PORT",
                Self::RedisClusterNoExternalIp => "REDIS_CLUSTER_NO_EXTERNAL_IP",
                Self::RedisClusterUnsupportedProtocol => {
                    "REDIS_CLUSTER_UNSUPPORTED_PROTOCOL"
                }
                Self::NoAdvertisedRouteToGcpDestination => {
                    "NO_ADVERTISED_ROUTE_TO_GCP_DESTINATION"
                }
                Self::NoTrafficSelectorToGcpDestination => {
                    "NO_TRAFFIC_SELECTOR_TO_GCP_DESTINATION"
                }
                Self::NoKnownRouteFromPeeredNetworkToDestination => {
                    "NO_KNOWN_ROUTE_FROM_PEERED_NETWORK_TO_DESTINATION"
                }
                Self::PrivateNatToPscEndpointUnsupported => {
                    "PRIVATE_NAT_TO_PSC_ENDPOINT_UNSUPPORTED"
                }
                Self::PscPortMappingPortMismatch => "PSC_PORT_MAPPING_PORT_MISMATCH",
                Self::PscPortMappingWithoutPscConnectionUnsupported => {
                    "PSC_PORT_MAPPING_WITHOUT_PSC_CONNECTION_UNSUPPORTED"
                }
                Self::UnsupportedRouteMatchedForNat64Destination => {
                    "UNSUPPORTED_ROUTE_MATCHED_FOR_NAT64_DESTINATION"
                }
                Self::TrafficFromHybridEndpointToInternetDisallowed => {
                    "TRAFFIC_FROM_HYBRID_ENDPOINT_TO_INTERNET_DISALLOWED"
                }
                Self::NoMatchingNat64Gateway => "NO_MATCHING_NAT64_GATEWAY",
                Self::NoConfiguredPrivateNat64Rule => "NO_CONFIGURED_PRIVATE_NAT64_RULE",
                Self::LoadBalancerBackendIpVersionMismatch => {
                    "LOAD_BALANCER_BACKEND_IP_VERSION_MISMATCH"
                }
                Self::NoKnownRouteFromNccNetworkToDestination => {
                    "NO_KNOWN_ROUTE_FROM_NCC_NETWORK_TO_DESTINATION"
                }
                Self::CloudNatProtocolUnsupported => "CLOUD_NAT_PROTOCOL_UNSUPPORTED",
                Self::L2InterconnectUnsupportedProtocol => {
                    "L2_INTERCONNECT_UNSUPPORTED_PROTOCOL"
                }
                Self::L2InterconnectUnsupportedPort => "L2_INTERCONNECT_UNSUPPORTED_PORT",
                Self::L2InterconnectDestinationIpMismatch => {
                    "L2_INTERCONNECT_DESTINATION_IP_MISMATCH"
                }
                Self::NccRouteWithinHybridSubnetUnsupported => {
                    "NCC_ROUTE_WITHIN_HYBRID_SUBNET_UNSUPPORTED"
                }
                Self::HybridSubnetRegionMismatch => "HYBRID_SUBNET_REGION_MISMATCH",
                Self::HybridSubnetNoRoute => "HYBRID_SUBNET_NO_ROUTE",
                Self::GkeNetworkPolicy => "GKE_NETWORK_POLICY",
                Self::NoValidRouteFromGoogleManagedNetworkToDestination => {
                    "NO_VALID_ROUTE_FROM_GOOGLE_MANAGED_NETWORK_TO_DESTINATION"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CAUSE_UNSPECIFIED" => Some(Self::Unspecified),
                "UNKNOWN_EXTERNAL_ADDRESS" => Some(Self::UnknownExternalAddress),
                "FOREIGN_IP_DISALLOWED" => Some(Self::ForeignIpDisallowed),
                "FIREWALL_RULE" => Some(Self::FirewallRule),
                "NO_ROUTE" => Some(Self::NoRoute),
                "ROUTE_BLACKHOLE" => Some(Self::RouteBlackhole),
                "ROUTE_WRONG_NETWORK" => Some(Self::RouteWrongNetwork),
                "ROUTE_NEXT_HOP_IP_ADDRESS_NOT_RESOLVED" => {
                    Some(Self::RouteNextHopIpAddressNotResolved)
                }
                "ROUTE_NEXT_HOP_RESOURCE_NOT_FOUND" => {
                    Some(Self::RouteNextHopResourceNotFound)
                }
                "ROUTE_NEXT_HOP_INSTANCE_WRONG_NETWORK" => {
                    Some(Self::RouteNextHopInstanceWrongNetwork)
                }
                "ROUTE_NEXT_HOP_INSTANCE_NON_PRIMARY_IP" => {
                    Some(Self::RouteNextHopInstanceNonPrimaryIp)
                }
                "ROUTE_NEXT_HOP_FORWARDING_RULE_IP_MISMATCH" => {
                    Some(Self::RouteNextHopForwardingRuleIpMismatch)
                }
                "ROUTE_NEXT_HOP_VPN_TUNNEL_NOT_ESTABLISHED" => {
                    Some(Self::RouteNextHopVpnTunnelNotEstablished)
                }
                "ROUTE_NEXT_HOP_FORWARDING_RULE_TYPE_INVALID" => {
                    Some(Self::RouteNextHopForwardingRuleTypeInvalid)
                }
                "NO_ROUTE_FROM_INTERNET_TO_PRIVATE_IPV6_ADDRESS" => {
                    Some(Self::NoRouteFromInternetToPrivateIpv6Address)
                }
                "NO_ROUTE_FROM_INTERNET_TO_PRIVATE_IPV4_ADDRESS" => {
                    Some(Self::NoRouteFromInternetToPrivateIpv4Address)
                }
                "NO_ROUTE_FROM_EXTERNAL_IPV6_SOURCE_TO_PRIVATE_IPV6_ADDRESS" => {
                    Some(Self::NoRouteFromExternalIpv6SourceToPrivateIpv6Address)
                }
                "VPN_TUNNEL_LOCAL_SELECTOR_MISMATCH" => {
                    Some(Self::VpnTunnelLocalSelectorMismatch)
                }
                "VPN_TUNNEL_REMOTE_SELECTOR_MISMATCH" => {
                    Some(Self::VpnTunnelRemoteSelectorMismatch)
                }
                "PRIVATE_TRAFFIC_TO_INTERNET" => Some(Self::PrivateTrafficToInternet),
                "PRIVATE_GOOGLE_ACCESS_DISALLOWED" => {
                    Some(Self::PrivateGoogleAccessDisallowed)
                }
                "PRIVATE_GOOGLE_ACCESS_VIA_VPN_TUNNEL_UNSUPPORTED" => {
                    Some(Self::PrivateGoogleAccessViaVpnTunnelUnsupported)
                }
                "NO_EXTERNAL_ADDRESS" => Some(Self::NoExternalAddress),
                "UNKNOWN_INTERNAL_ADDRESS" => Some(Self::UnknownInternalAddress),
                "FORWARDING_RULE_MISMATCH" => Some(Self::ForwardingRuleMismatch),
                "FORWARDING_RULE_NO_INSTANCES" => Some(Self::ForwardingRuleNoInstances),
                "FIREWALL_BLOCKING_LOAD_BALANCER_BACKEND_HEALTH_CHECK" => {
                    Some(Self::FirewallBlockingLoadBalancerBackendHealthCheck)
                }
                "INGRESS_FIREWALL_TAGS_UNSUPPORTED_BY_DIRECT_VPC_EGRESS" => {
                    Some(Self::IngressFirewallTagsUnsupportedByDirectVpcEgress)
                }
                "INSTANCE_NOT_RUNNING" => Some(Self::InstanceNotRunning),
                "GKE_CLUSTER_NOT_RUNNING" => Some(Self::GkeClusterNotRunning),
                "GKE_POD_NOT_RUNNING" => Some(Self::GkePodNotRunning),
                "CLOUD_SQL_INSTANCE_NOT_RUNNING" => {
                    Some(Self::CloudSqlInstanceNotRunning)
                }
                "REDIS_INSTANCE_NOT_RUNNING" => Some(Self::RedisInstanceNotRunning),
                "REDIS_CLUSTER_NOT_RUNNING" => Some(Self::RedisClusterNotRunning),
                "TRAFFIC_TYPE_BLOCKED" => Some(Self::TrafficTypeBlocked),
                "GKE_MASTER_UNAUTHORIZED_ACCESS" => {
                    Some(Self::GkeMasterUnauthorizedAccess)
                }
                "CLOUD_SQL_INSTANCE_UNAUTHORIZED_ACCESS" => {
                    Some(Self::CloudSqlInstanceUnauthorizedAccess)
                }
                "DROPPED_INSIDE_GKE_SERVICE" => Some(Self::DroppedInsideGkeService),
                "DROPPED_INSIDE_CLOUD_SQL_SERVICE" => {
                    Some(Self::DroppedInsideCloudSqlService)
                }
                "GOOGLE_MANAGED_SERVICE_NO_PEERING" => {
                    Some(Self::GoogleManagedServiceNoPeering)
                }
                "GOOGLE_MANAGED_SERVICE_NO_PSC_ENDPOINT" => {
                    Some(Self::GoogleManagedServiceNoPscEndpoint)
                }
                "GKE_PSC_ENDPOINT_MISSING" => Some(Self::GkePscEndpointMissing),
                "CLOUD_SQL_INSTANCE_NO_IP_ADDRESS" => {
                    Some(Self::CloudSqlInstanceNoIpAddress)
                }
                "GKE_CONTROL_PLANE_REGION_MISMATCH" => {
                    Some(Self::GkeControlPlaneRegionMismatch)
                }
                "PUBLIC_GKE_CONTROL_PLANE_TO_PRIVATE_DESTINATION" => {
                    Some(Self::PublicGkeControlPlaneToPrivateDestination)
                }
                "GKE_CONTROL_PLANE_NO_ROUTE" => Some(Self::GkeControlPlaneNoRoute),
                "CLOUD_SQL_INSTANCE_NOT_CONFIGURED_FOR_EXTERNAL_TRAFFIC" => {
                    Some(Self::CloudSqlInstanceNotConfiguredForExternalTraffic)
                }
                "PUBLIC_CLOUD_SQL_INSTANCE_TO_PRIVATE_DESTINATION" => {
                    Some(Self::PublicCloudSqlInstanceToPrivateDestination)
                }
                "CLOUD_SQL_INSTANCE_NO_ROUTE" => Some(Self::CloudSqlInstanceNoRoute),
                "CLOUD_SQL_CONNECTOR_REQUIRED" => Some(Self::CloudSqlConnectorRequired),
                "CLOUD_FUNCTION_NOT_ACTIVE" => Some(Self::CloudFunctionNotActive),
                "VPC_CONNECTOR_NOT_SET" => Some(Self::VpcConnectorNotSet),
                "VPC_CONNECTOR_NOT_RUNNING" => Some(Self::VpcConnectorNotRunning),
                "VPC_CONNECTOR_SERVERLESS_TRAFFIC_BLOCKED" => {
                    Some(Self::VpcConnectorServerlessTrafficBlocked)
                }
                "VPC_CONNECTOR_HEALTH_CHECK_TRAFFIC_BLOCKED" => {
                    Some(Self::VpcConnectorHealthCheckTrafficBlocked)
                }
                "FORWARDING_RULE_REGION_MISMATCH" => {
                    Some(Self::ForwardingRuleRegionMismatch)
                }
                "PSC_CONNECTION_NOT_ACCEPTED" => Some(Self::PscConnectionNotAccepted),
                "PSC_ENDPOINT_ACCESSED_FROM_PEERED_NETWORK" => {
                    Some(Self::PscEndpointAccessedFromPeeredNetwork)
                }
                "PSC_NEG_PRODUCER_ENDPOINT_NO_GLOBAL_ACCESS" => {
                    Some(Self::PscNegProducerEndpointNoGlobalAccess)
                }
                "PSC_NEG_PRODUCER_FORWARDING_RULE_MULTIPLE_PORTS" => {
                    Some(Self::PscNegProducerForwardingRuleMultiplePorts)
                }
                "CLOUD_SQL_PSC_NEG_UNSUPPORTED" => Some(Self::CloudSqlPscNegUnsupported),
                "NO_NAT_SUBNETS_FOR_PSC_SERVICE_ATTACHMENT" => {
                    Some(Self::NoNatSubnetsForPscServiceAttachment)
                }
                "PSC_TRANSITIVITY_NOT_PROPAGATED" => {
                    Some(Self::PscTransitivityNotPropagated)
                }
                "HYBRID_NEG_NON_DYNAMIC_ROUTE_MATCHED" => {
                    Some(Self::HybridNegNonDynamicRouteMatched)
                }
                "HYBRID_NEG_NON_LOCAL_DYNAMIC_ROUTE_MATCHED" => {
                    Some(Self::HybridNegNonLocalDynamicRouteMatched)
                }
                "CLOUD_RUN_REVISION_NOT_READY" => Some(Self::CloudRunRevisionNotReady),
                "DROPPED_INSIDE_PSC_SERVICE_PRODUCER" => {
                    Some(Self::DroppedInsidePscServiceProducer)
                }
                "LOAD_BALANCER_HAS_NO_PROXY_SUBNET" => {
                    Some(Self::LoadBalancerHasNoProxySubnet)
                }
                "CLOUD_NAT_NO_ADDRESSES" => Some(Self::CloudNatNoAddresses),
                "ROUTING_LOOP" => Some(Self::RoutingLoop),
                "DROPPED_INSIDE_GOOGLE_MANAGED_SERVICE" => {
                    Some(Self::DroppedInsideGoogleManagedService)
                }
                "LOAD_BALANCER_BACKEND_INVALID_NETWORK" => {
                    Some(Self::LoadBalancerBackendInvalidNetwork)
                }
                "BACKEND_SERVICE_NAMED_PORT_NOT_DEFINED" => {
                    Some(Self::BackendServiceNamedPortNotDefined)
                }
                "DESTINATION_IS_PRIVATE_NAT_IP_RANGE" => {
                    Some(Self::DestinationIsPrivateNatIpRange)
                }
                "DROPPED_INSIDE_REDIS_INSTANCE_SERVICE" => {
                    Some(Self::DroppedInsideRedisInstanceService)
                }
                "REDIS_INSTANCE_UNSUPPORTED_PORT" => {
                    Some(Self::RedisInstanceUnsupportedPort)
                }
                "REDIS_INSTANCE_CONNECTING_FROM_PUPI_ADDRESS" => {
                    Some(Self::RedisInstanceConnectingFromPupiAddress)
                }
                "REDIS_INSTANCE_NO_ROUTE_TO_DESTINATION_NETWORK" => {
                    Some(Self::RedisInstanceNoRouteToDestinationNetwork)
                }
                "REDIS_INSTANCE_NO_EXTERNAL_IP" => Some(Self::RedisInstanceNoExternalIp),
                "REDIS_INSTANCE_UNSUPPORTED_PROTOCOL" => {
                    Some(Self::RedisInstanceUnsupportedProtocol)
                }
                "DROPPED_INSIDE_REDIS_CLUSTER_SERVICE" => {
                    Some(Self::DroppedInsideRedisClusterService)
                }
                "REDIS_CLUSTER_UNSUPPORTED_PORT" => {
                    Some(Self::RedisClusterUnsupportedPort)
                }
                "REDIS_CLUSTER_NO_EXTERNAL_IP" => Some(Self::RedisClusterNoExternalIp),
                "REDIS_CLUSTER_UNSUPPORTED_PROTOCOL" => {
                    Some(Self::RedisClusterUnsupportedProtocol)
                }
                "NO_ADVERTISED_ROUTE_TO_GCP_DESTINATION" => {
                    Some(Self::NoAdvertisedRouteToGcpDestination)
                }
                "NO_TRAFFIC_SELECTOR_TO_GCP_DESTINATION" => {
                    Some(Self::NoTrafficSelectorToGcpDestination)
                }
                "NO_KNOWN_ROUTE_FROM_PEERED_NETWORK_TO_DESTINATION" => {
                    Some(Self::NoKnownRouteFromPeeredNetworkToDestination)
                }
                "PRIVATE_NAT_TO_PSC_ENDPOINT_UNSUPPORTED" => {
                    Some(Self::PrivateNatToPscEndpointUnsupported)
                }
                "PSC_PORT_MAPPING_PORT_MISMATCH" => {
                    Some(Self::PscPortMappingPortMismatch)
                }
                "PSC_PORT_MAPPING_WITHOUT_PSC_CONNECTION_UNSUPPORTED" => {
                    Some(Self::PscPortMappingWithoutPscConnectionUnsupported)
                }
                "UNSUPPORTED_ROUTE_MATCHED_FOR_NAT64_DESTINATION" => {
                    Some(Self::UnsupportedRouteMatchedForNat64Destination)
                }
                "TRAFFIC_FROM_HYBRID_ENDPOINT_TO_INTERNET_DISALLOWED" => {
                    Some(Self::TrafficFromHybridEndpointToInternetDisallowed)
                }
                "NO_MATCHING_NAT64_GATEWAY" => Some(Self::NoMatchingNat64Gateway),
                "NO_CONFIGURED_PRIVATE_NAT64_RULE" => {
                    Some(Self::NoConfiguredPrivateNat64Rule)
                }
                "LOAD_BALANCER_BACKEND_IP_VERSION_MISMATCH" => {
                    Some(Self::LoadBalancerBackendIpVersionMismatch)
                }
                "NO_KNOWN_ROUTE_FROM_NCC_NETWORK_TO_DESTINATION" => {
                    Some(Self::NoKnownRouteFromNccNetworkToDestination)
                }
                "CLOUD_NAT_PROTOCOL_UNSUPPORTED" => {
                    Some(Self::CloudNatProtocolUnsupported)
                }
                "L2_INTERCONNECT_UNSUPPORTED_PROTOCOL" => {
                    Some(Self::L2InterconnectUnsupportedProtocol)
                }
                "L2_INTERCONNECT_UNSUPPORTED_PORT" => {
                    Some(Self::L2InterconnectUnsupportedPort)
                }
                "L2_INTERCONNECT_DESTINATION_IP_MISMATCH" => {
                    Some(Self::L2InterconnectDestinationIpMismatch)
                }
                "NCC_ROUTE_WITHIN_HYBRID_SUBNET_UNSUPPORTED" => {
                    Some(Self::NccRouteWithinHybridSubnetUnsupported)
                }
                "HYBRID_SUBNET_REGION_MISMATCH" => Some(Self::HybridSubnetRegionMismatch),
                "HYBRID_SUBNET_NO_ROUTE" => Some(Self::HybridSubnetNoRoute),
                "GKE_NETWORK_POLICY" => Some(Self::GkeNetworkPolicy),
                "NO_VALID_ROUTE_FROM_GOOGLE_MANAGED_NETWORK_TO_DESTINATION" => {
                    Some(Self::NoValidRouteFromGoogleManagedNetworkToDestination)
                }
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with a Google Kubernetes Engine (GKE)
/// cluster master.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GkeMasterInfo {
    /// URI of a GKE cluster.
    #[prost(string, tag = "2")]
    pub cluster_uri: ::prost::alloc::string::String,
    /// URI of a GKE cluster network.
    #[prost(string, tag = "4")]
    pub cluster_network_uri: ::prost::alloc::string::String,
    /// Internal IP address of a GKE cluster control plane.
    #[prost(string, tag = "5")]
    pub internal_ip: ::prost::alloc::string::String,
    /// External IP address of a GKE cluster control plane.
    #[prost(string, tag = "6")]
    pub external_ip: ::prost::alloc::string::String,
    /// DNS endpoint of a GKE cluster control plane.
    #[prost(string, tag = "7")]
    pub dns_endpoint: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a Google Kubernetes Engine (GKE)
/// Pod.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GkePodInfo {
    /// URI of a GKE Pod.
    /// For Pods in regional Clusters, the URI format is:
    /// `projects/{project}/locations/{location}/clusters/{cluster}/k8s/namespaces/{namespace}/pods/{pod}`
    /// For Pods in zonal Clusters, the URI format is:
    /// `projects/{project}/zones/{zone}/clusters/{cluster}/k8s/namespaces/{namespace}/pods/{pod}`
    #[prost(string, tag = "1")]
    pub pod_uri: ::prost::alloc::string::String,
    /// IP address of a GKE Pod. If the Pod is dual-stack, this is the IP address
    /// relevant to the trace.
    #[prost(string, tag = "2")]
    pub ip_address: ::prost::alloc::string::String,
    /// URI of the network containing the GKE Pod.
    #[prost(string, tag = "3")]
    pub network_uri: ::prost::alloc::string::String,
}
/// For display only. Contains information about why IP masquerading was skipped
/// for the packet.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct IpMasqueradingSkippedInfo {
    /// Reason why IP masquerading was not applied.
    #[prost(enumeration = "ip_masquerading_skipped_info::Reason", tag = "1")]
    pub reason: i32,
    /// The matched non-masquerade IP range. Only set if reason is
    /// DESTINATION_IP_IN_CONFIGURED_NON_MASQUERADE_RANGE or
    /// DESTINATION_IP_IN_DEFAULT_NON_MASQUERADE_RANGE.
    #[prost(string, tag = "2")]
    pub non_masquerade_range: ::prost::alloc::string::String,
}
/// Nested message and enum types in `IpMasqueradingSkippedInfo`.
pub mod ip_masquerading_skipped_info {
    /// Reason why IP masquerading was skipped.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Reason {
        /// Unused default value.
        Unspecified = 0,
        /// Masquerading not applied because destination IP is in one of configured
        /// non-masquerade ranges.
        DestinationIpInConfiguredNonMasqueradeRange = 1,
        /// Masquerading not applied because destination IP is in one of default
        /// non-masquerade ranges.
        DestinationIpInDefaultNonMasqueradeRange = 2,
        /// Masquerading not applied because destination is on the same Node.
        DestinationOnSameNode = 3,
        /// Masquerading not applied because ip-masq-agent doesn't exist and default
        /// SNAT is disabled.
        DefaultSnatDisabled = 4,
        /// Masquerading not applied because the packet's IP version is IPv6.
        NoMasqueradingForIpv6 = 5,
        /// Masquerading not applied because the source Pod uses the host Node's
        /// network namespace, including the Node's IP address.
        PodUsesNodeNetworkNamespace = 6,
        /// Masquerading not applied because the packet is a return packet.
        NoMasqueradingForReturnPacket = 7,
    }
    impl Reason {
        /// 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 => "REASON_UNSPECIFIED",
                Self::DestinationIpInConfiguredNonMasqueradeRange => {
                    "DESTINATION_IP_IN_CONFIGURED_NON_MASQUERADE_RANGE"
                }
                Self::DestinationIpInDefaultNonMasqueradeRange => {
                    "DESTINATION_IP_IN_DEFAULT_NON_MASQUERADE_RANGE"
                }
                Self::DestinationOnSameNode => "DESTINATION_ON_SAME_NODE",
                Self::DefaultSnatDisabled => "DEFAULT_SNAT_DISABLED",
                Self::NoMasqueradingForIpv6 => "NO_MASQUERADING_FOR_IPV6",
                Self::PodUsesNodeNetworkNamespace => "POD_USES_NODE_NETWORK_NAMESPACE",
                Self::NoMasqueradingForReturnPacket => {
                    "NO_MASQUERADING_FOR_RETURN_PACKET"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REASON_UNSPECIFIED" => Some(Self::Unspecified),
                "DESTINATION_IP_IN_CONFIGURED_NON_MASQUERADE_RANGE" => {
                    Some(Self::DestinationIpInConfiguredNonMasqueradeRange)
                }
                "DESTINATION_IP_IN_DEFAULT_NON_MASQUERADE_RANGE" => {
                    Some(Self::DestinationIpInDefaultNonMasqueradeRange)
                }
                "DESTINATION_ON_SAME_NODE" => Some(Self::DestinationOnSameNode),
                "DEFAULT_SNAT_DISABLED" => Some(Self::DefaultSnatDisabled),
                "NO_MASQUERADING_FOR_IPV6" => Some(Self::NoMasqueradingForIpv6),
                "POD_USES_NODE_NETWORK_NAMESPACE" => {
                    Some(Self::PodUsesNodeNetworkNamespace)
                }
                "NO_MASQUERADING_FOR_RETURN_PACKET" => {
                    Some(Self::NoMasqueradingForReturnPacket)
                }
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with a GKE Network Policy.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GkeNetworkPolicyInfo {
    /// The name of the Network Policy.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// The URI of the Network Policy.
    /// Format for a Network Policy in a zonal cluster:
    /// `projects/<project_id>/zones/<zone>/clusters/<cluster>/k8s/namespaces/<namespace>/networking.k8s.io/networkpolicies/<networkpolicy>`
    /// Format for a Network Policy in a regional cluster:
    /// `projects/<project_id>/locations/<location>/clusters/<cluster>/k8s/namespaces/<namespace>/networking.k8s.io/networkpolicies/<networkpolicy>`
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Possible values: INGRESS, EGRESS
    #[prost(string, tag = "3")]
    pub direction: ::prost::alloc::string::String,
    /// Possible values: ALLOW, DENY
    #[prost(string, tag = "4")]
    pub action: ::prost::alloc::string::String,
}
/// For display only. Contains information about why GKE Network Policy
/// evaluation was skipped.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GkeNetworkPolicySkippedInfo {
    /// Reason why Network Policy evaluation was skipped.
    #[prost(enumeration = "gke_network_policy_skipped_info::Reason", tag = "1")]
    pub reason: i32,
}
/// Nested message and enum types in `GkeNetworkPolicySkippedInfo`.
pub mod gke_network_policy_skipped_info {
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Reason {
        /// Unused default value.
        Unspecified = 0,
        /// Network Policy is disabled on the cluster.
        NetworkPolicyDisabled = 1,
        /// Ingress traffic to a Pod from a source on the same Node is always
        /// allowed.
        IngressSourceOnSameNode = 2,
        /// Egress traffic from a Pod that uses the Node's network namespace is not
        /// subject to Network Policy.
        EgressFromNodeNetworkNamespacePod = 3,
        /// Network Policy is not applied to response traffic. This is because GKE
        /// Network Policy evaluation is stateful in both GKE Dataplane V2 (eBPF) and
        /// legacy (iptables) implementations.
        NetworkPolicyNotAppliedToResponseTraffic = 4,
        /// Network Policy evaluation is currently not supported for clusters with
        /// FQDN Network Policies enabled.
        NetworkPolicyAnalysisUnsupported = 100,
    }
    impl Reason {
        /// 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 => "REASON_UNSPECIFIED",
                Self::NetworkPolicyDisabled => "NETWORK_POLICY_DISABLED",
                Self::IngressSourceOnSameNode => "INGRESS_SOURCE_ON_SAME_NODE",
                Self::EgressFromNodeNetworkNamespacePod => {
                    "EGRESS_FROM_NODE_NETWORK_NAMESPACE_POD"
                }
                Self::NetworkPolicyNotAppliedToResponseTraffic => {
                    "NETWORK_POLICY_NOT_APPLIED_TO_RESPONSE_TRAFFIC"
                }
                Self::NetworkPolicyAnalysisUnsupported => {
                    "NETWORK_POLICY_ANALYSIS_UNSUPPORTED"
                }
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "REASON_UNSPECIFIED" => Some(Self::Unspecified),
                "NETWORK_POLICY_DISABLED" => Some(Self::NetworkPolicyDisabled),
                "INGRESS_SOURCE_ON_SAME_NODE" => Some(Self::IngressSourceOnSameNode),
                "EGRESS_FROM_NODE_NETWORK_NAMESPACE_POD" => {
                    Some(Self::EgressFromNodeNetworkNamespacePod)
                }
                "NETWORK_POLICY_NOT_APPLIED_TO_RESPONSE_TRAFFIC" => {
                    Some(Self::NetworkPolicyNotAppliedToResponseTraffic)
                }
                "NETWORK_POLICY_ANALYSIS_UNSUPPORTED" => {
                    Some(Self::NetworkPolicyAnalysisUnsupported)
                }
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with a Cloud SQL instance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudSqlInstanceInfo {
    /// Name of a Cloud SQL instance.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a Cloud SQL instance.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// URI of a Cloud SQL instance network or empty string if the instance does
    /// not have one.
    #[prost(string, tag = "4")]
    pub network_uri: ::prost::alloc::string::String,
    /// Internal IP address of a Cloud SQL instance.
    #[prost(string, tag = "5")]
    pub internal_ip: ::prost::alloc::string::String,
    /// External IP address of a Cloud SQL instance.
    #[prost(string, tag = "6")]
    pub external_ip: ::prost::alloc::string::String,
    /// Region in which the Cloud SQL instance is running.
    #[prost(string, tag = "7")]
    pub region: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a Cloud Redis Instance.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RedisInstanceInfo {
    /// Name of a Cloud Redis Instance.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a Cloud Redis Instance.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// URI of a Cloud Redis Instance network.
    #[prost(string, tag = "3")]
    pub network_uri: ::prost::alloc::string::String,
    /// Primary endpoint IP address of a Cloud Redis Instance.
    #[prost(string, tag = "4")]
    pub primary_endpoint_ip: ::prost::alloc::string::String,
    /// Read endpoint IP address of a Cloud Redis Instance (if applicable).
    #[prost(string, tag = "5")]
    pub read_endpoint_ip: ::prost::alloc::string::String,
    /// Region in which the Cloud Redis Instance is defined.
    #[prost(string, tag = "6")]
    pub region: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a Redis Cluster.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RedisClusterInfo {
    /// Name of a Redis Cluster.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a Redis Cluster in format
    /// "projects/{project_id}/locations/{location}/clusters/{cluster_id}"
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// URI of the network containing the Redis Cluster endpoints in format
    /// "projects/{project_id}/global/networks/{network_id}".
    #[prost(string, tag = "3")]
    pub network_uri: ::prost::alloc::string::String,
    /// Discovery endpoint IP address of a Redis Cluster.
    #[prost(string, tag = "4")]
    pub discovery_endpoint_ip_address: ::prost::alloc::string::String,
    /// Secondary endpoint IP address of a Redis Cluster.
    #[prost(string, tag = "5")]
    pub secondary_endpoint_ip_address: ::prost::alloc::string::String,
    /// Name of the region in which the Redis Cluster is defined. For example,
    /// "us-central1".
    #[prost(string, tag = "6")]
    pub location: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a Cloud Function.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudFunctionInfo {
    /// Name of a Cloud Function.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a Cloud Function.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Location in which the Cloud Function is deployed.
    #[prost(string, tag = "3")]
    pub location: ::prost::alloc::string::String,
    /// Latest successfully deployed version id of the Cloud Function.
    #[prost(int64, tag = "4")]
    pub version_id: i64,
}
/// For display only. Metadata associated with a Cloud Run revision.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloudRunRevisionInfo {
    /// Name of a Cloud Run revision.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a Cloud Run revision.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Location in which this revision is deployed.
    #[prost(string, tag = "4")]
    pub location: ::prost::alloc::string::String,
    /// URI of Cloud Run service this revision belongs to.
    #[prost(string, tag = "5")]
    pub service_uri: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with an App Engine version.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AppEngineVersionInfo {
    /// Name of an App Engine version.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of an App Engine version.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Runtime of the App Engine version.
    #[prost(string, tag = "3")]
    pub runtime: ::prost::alloc::string::String,
    /// App Engine execution environment for a version.
    #[prost(string, tag = "4")]
    pub environment: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a VPC connector.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct VpcConnectorInfo {
    /// Name of a VPC connector.
    #[prost(string, tag = "1")]
    pub display_name: ::prost::alloc::string::String,
    /// URI of a VPC connector.
    #[prost(string, tag = "2")]
    pub uri: ::prost::alloc::string::String,
    /// Location in which the VPC connector is deployed.
    #[prost(string, tag = "3")]
    pub location: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a serverless direct VPC egress
/// connection.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DirectVpcEgressConnectionInfo {
    /// URI of direct access network.
    #[prost(string, tag = "1")]
    pub network_uri: ::prost::alloc::string::String,
    /// URI of direct access subnetwork.
    #[prost(string, tag = "2")]
    pub subnetwork_uri: ::prost::alloc::string::String,
    /// Selected IP range.
    #[prost(string, tag = "3")]
    pub selected_ip_range: ::prost::alloc::string::String,
    /// Selected starting IP address, from the selected IP range.
    #[prost(string, tag = "4")]
    pub selected_ip_address: ::prost::alloc::string::String,
    /// Region in which the Direct VPC egress is deployed.
    #[prost(string, tag = "5")]
    pub region: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a serverless public connection.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ServerlessExternalConnectionInfo {
    /// Selected starting IP address, from the Google dynamic address pool.
    #[prost(string, tag = "1")]
    pub selected_ip_address: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with NAT.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NatInfo {
    /// Type of NAT.
    #[prost(enumeration = "nat_info::Type", tag = "1")]
    pub r#type: i32,
    /// IP protocol in string format, for example: "TCP", "UDP", "ICMP".
    #[prost(string, tag = "2")]
    pub protocol: ::prost::alloc::string::String,
    /// URI of the network where NAT translation takes place.
    #[prost(string, tag = "3")]
    pub network_uri: ::prost::alloc::string::String,
    /// Source IP address before NAT translation.
    #[prost(string, tag = "4")]
    pub old_source_ip: ::prost::alloc::string::String,
    /// Source IP address after NAT translation.
    #[prost(string, tag = "5")]
    pub new_source_ip: ::prost::alloc::string::String,
    /// Destination IP address before NAT translation.
    #[prost(string, tag = "6")]
    pub old_destination_ip: ::prost::alloc::string::String,
    /// Destination IP address after NAT translation.
    #[prost(string, tag = "7")]
    pub new_destination_ip: ::prost::alloc::string::String,
    /// Source port before NAT translation. Only valid when protocol is TCP or UDP.
    #[prost(int32, tag = "8")]
    pub old_source_port: i32,
    /// Source port after NAT translation. Only valid when protocol is TCP or UDP.
    #[prost(int32, tag = "9")]
    pub new_source_port: i32,
    /// Destination port before NAT translation. Only valid when protocol is TCP or
    /// UDP.
    #[prost(int32, tag = "10")]
    pub old_destination_port: i32,
    /// Destination port after NAT translation. Only valid when protocol is TCP or
    /// UDP.
    #[prost(int32, tag = "11")]
    pub new_destination_port: i32,
    /// Uri of the Cloud Router. Only valid when type is CLOUD_NAT.
    #[prost(string, tag = "12")]
    pub router_uri: ::prost::alloc::string::String,
    /// The name of Cloud NAT Gateway. Only valid when type is CLOUD_NAT.
    #[prost(string, tag = "13")]
    pub nat_gateway_name: ::prost::alloc::string::String,
    /// Type of Cloud NAT gateway. Only valid when `type` is CLOUD_NAT.
    #[prost(enumeration = "nat_info::CloudNatGatewayType", tag = "14")]
    pub cloud_nat_gateway_type: i32,
}
/// Nested message and enum types in `NatInfo`.
pub mod nat_info {
    /// Types of NAT.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Type {
        /// Type is unspecified.
        Unspecified = 0,
        /// From Compute Engine instance's internal address to external address.
        InternalToExternal = 1,
        /// From Compute Engine instance's external address to internal address.
        ExternalToInternal = 2,
        /// Cloud NAT Gateway.
        CloudNat = 3,
        /// Private service connect NAT.
        PrivateServiceConnect = 4,
        /// GKE Pod IP address masquerading.
        GkePodIpMasquerading = 5,
    }
    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::InternalToExternal => "INTERNAL_TO_EXTERNAL",
                Self::ExternalToInternal => "EXTERNAL_TO_INTERNAL",
                Self::CloudNat => "CLOUD_NAT",
                Self::PrivateServiceConnect => "PRIVATE_SERVICE_CONNECT",
                Self::GkePodIpMasquerading => "GKE_POD_IP_MASQUERADING",
            }
        }
        /// 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),
                "INTERNAL_TO_EXTERNAL" => Some(Self::InternalToExternal),
                "EXTERNAL_TO_INTERNAL" => Some(Self::ExternalToInternal),
                "CLOUD_NAT" => Some(Self::CloudNat),
                "PRIVATE_SERVICE_CONNECT" => Some(Self::PrivateServiceConnect),
                "GKE_POD_IP_MASQUERADING" => Some(Self::GkePodIpMasquerading),
                _ => None,
            }
        }
    }
    /// Types of Cloud NAT gateway.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum CloudNatGatewayType {
        /// Type is unspecified.
        Unspecified = 0,
        /// Public NAT gateway.
        PublicNat44 = 1,
        /// Public NAT64 gateway.
        PublicNat64 = 2,
        /// Private NAT gateway for NCC.
        PrivateNatNcc = 3,
        /// Private NAT gateway for hybrid connectivity.
        PrivateNatHybrid = 4,
        /// Private NAT64 gateway.
        PrivateNat64 = 5,
    }
    impl CloudNatGatewayType {
        /// 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 => "CLOUD_NAT_GATEWAY_TYPE_UNSPECIFIED",
                Self::PublicNat44 => "PUBLIC_NAT44",
                Self::PublicNat64 => "PUBLIC_NAT64",
                Self::PrivateNatNcc => "PRIVATE_NAT_NCC",
                Self::PrivateNatHybrid => "PRIVATE_NAT_HYBRID",
                Self::PrivateNat64 => "PRIVATE_NAT64",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CLOUD_NAT_GATEWAY_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "PUBLIC_NAT44" => Some(Self::PublicNat44),
                "PUBLIC_NAT64" => Some(Self::PublicNat64),
                "PRIVATE_NAT_NCC" => Some(Self::PrivateNatNcc),
                "PRIVATE_NAT_HYBRID" => Some(Self::PrivateNatHybrid),
                "PRIVATE_NAT64" => Some(Self::PrivateNat64),
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with ProxyConnection.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProxyConnectionInfo {
    /// IP protocol in string format, for example: "TCP", "UDP", "ICMP".
    #[prost(string, tag = "1")]
    pub protocol: ::prost::alloc::string::String,
    /// Source IP address of an original connection.
    #[prost(string, tag = "2")]
    pub old_source_ip: ::prost::alloc::string::String,
    /// Source IP address of a new connection.
    #[prost(string, tag = "3")]
    pub new_source_ip: ::prost::alloc::string::String,
    /// Destination IP address of an original connection
    #[prost(string, tag = "4")]
    pub old_destination_ip: ::prost::alloc::string::String,
    /// Destination IP address of a new connection.
    #[prost(string, tag = "5")]
    pub new_destination_ip: ::prost::alloc::string::String,
    /// Source port of an original connection. Only valid when protocol is TCP or
    /// UDP.
    #[prost(int32, tag = "6")]
    pub old_source_port: i32,
    /// Source port of a new connection. Only valid when protocol is TCP or UDP.
    #[prost(int32, tag = "7")]
    pub new_source_port: i32,
    /// Destination port of an original connection. Only valid when protocol is TCP
    /// or UDP.
    #[prost(int32, tag = "8")]
    pub old_destination_port: i32,
    /// Destination port of a new connection. Only valid when protocol is TCP or
    /// UDP.
    #[prost(int32, tag = "9")]
    pub new_destination_port: i32,
    /// Uri of proxy subnet.
    #[prost(string, tag = "10")]
    pub subnet_uri: ::prost::alloc::string::String,
    /// URI of the network where connection is proxied.
    #[prost(string, tag = "11")]
    pub network_uri: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with the load balancer backend.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LoadBalancerBackendInfo {
    /// Display name of the backend. For example, it might be an instance name for
    /// the instance group backends, or an IP address and port for zonal network
    /// endpoint group backends.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// URI of the backend instance (if applicable). Populated for instance group
    /// backends, and zonal NEG backends.
    #[prost(string, tag = "2")]
    pub instance_uri: ::prost::alloc::string::String,
    /// URI of the backend service this backend belongs to (if applicable).
    #[prost(string, tag = "3")]
    pub backend_service_uri: ::prost::alloc::string::String,
    /// URI of the instance group this backend belongs to (if applicable).
    #[prost(string, tag = "4")]
    pub instance_group_uri: ::prost::alloc::string::String,
    /// URI of the network endpoint group this backend belongs to (if applicable).
    #[prost(string, tag = "5")]
    pub network_endpoint_group_uri: ::prost::alloc::string::String,
    /// URI of the backend bucket this backend targets (if applicable).
    #[prost(string, tag = "8")]
    pub backend_bucket_uri: ::prost::alloc::string::String,
    /// URI of the PSC service attachment this PSC NEG backend targets (if
    /// applicable).
    #[prost(string, tag = "9")]
    pub psc_service_attachment_uri: ::prost::alloc::string::String,
    /// PSC Google API target this PSC NEG backend targets (if applicable).
    #[prost(string, tag = "10")]
    pub psc_google_api_target: ::prost::alloc::string::String,
    /// URI of the health check attached to this backend (if applicable).
    #[prost(string, tag = "6")]
    pub health_check_uri: ::prost::alloc::string::String,
    /// Output only. Health check firewalls configuration state for the backend.
    /// This is a result of the static firewall analysis (verifying that health
    /// check traffic from required IP ranges to the backend is allowed or not).
    /// The backend might still be unhealthy even if these firewalls are
    /// configured. Please refer to the documentation for more information:
    /// <https://cloud.google.com/load-balancing/docs/firewall-rules>
    #[prost(
        enumeration = "load_balancer_backend_info::HealthCheckFirewallsConfigState",
        tag = "7"
    )]
    pub health_check_firewalls_config_state: i32,
}
/// Nested message and enum types in `LoadBalancerBackendInfo`.
pub mod load_balancer_backend_info {
    /// Health check firewalls configuration state enum.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum HealthCheckFirewallsConfigState {
        /// Configuration state unspecified. It usually means that the backend has
        /// no health check attached, or there was an unexpected configuration error
        /// preventing Connectivity tests from verifying health check configuration.
        Unspecified = 0,
        /// Firewall rules (policies) allowing health check traffic from all required
        /// IP ranges to the backend are configured.
        FirewallsConfigured = 1,
        /// Firewall rules (policies) allow health check traffic only from a part of
        /// required IP ranges.
        FirewallsPartiallyConfigured = 2,
        /// Firewall rules (policies) deny health check traffic from all required
        /// IP ranges to the backend.
        FirewallsNotConfigured = 3,
        /// The network contains firewall rules of unsupported types, so Connectivity
        /// tests were not able to verify health check configuration status. Please
        /// refer to the documentation for the list of unsupported configurations:
        /// <https://cloud.google.com/network-intelligence-center/docs/connectivity-tests/concepts/overview#unsupported-configs>
        FirewallsUnsupported = 4,
    }
    impl HealthCheckFirewallsConfigState {
        /// 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 => "HEALTH_CHECK_FIREWALLS_CONFIG_STATE_UNSPECIFIED",
                Self::FirewallsConfigured => "FIREWALLS_CONFIGURED",
                Self::FirewallsPartiallyConfigured => "FIREWALLS_PARTIALLY_CONFIGURED",
                Self::FirewallsNotConfigured => "FIREWALLS_NOT_CONFIGURED",
                Self::FirewallsUnsupported => "FIREWALLS_UNSUPPORTED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "HEALTH_CHECK_FIREWALLS_CONFIG_STATE_UNSPECIFIED" => {
                    Some(Self::Unspecified)
                }
                "FIREWALLS_CONFIGURED" => Some(Self::FirewallsConfigured),
                "FIREWALLS_PARTIALLY_CONFIGURED" => {
                    Some(Self::FirewallsPartiallyConfigured)
                }
                "FIREWALLS_NOT_CONFIGURED" => Some(Self::FirewallsNotConfigured),
                "FIREWALLS_UNSUPPORTED" => Some(Self::FirewallsUnsupported),
                _ => None,
            }
        }
    }
}
/// For display only. Metadata associated with Storage Bucket.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StorageBucketInfo {
    /// Cloud Storage Bucket name.
    #[prost(string, tag = "1")]
    pub bucket: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with the serverless network endpoint
/// group backend.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ServerlessNegInfo {
    /// URI of the serverless network endpoint group.
    #[prost(string, tag = "1")]
    pub neg_uri: ::prost::alloc::string::String,
}
/// For display only. Metadata associated with a layer 7 packet inspection by the
/// firewall.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct NgfwPacketInspectionInfo {
    /// URI of the security profile group associated with this firewall packet
    /// inspection.
    #[prost(string, tag = "1")]
    pub security_profile_group_uri: ::prost::alloc::string::String,
}
/// Type of a load balancer. For more information, see [Summary of Google Cloud
/// load
/// balancers](<https://cloud.google.com/load-balancing/docs/load-balancing-overview#summary-of-google-cloud-load-balancers>).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum LoadBalancerType {
    /// Forwarding rule points to a different target than a load balancer or a
    /// load balancer type is unknown.
    Unspecified = 0,
    /// Global external HTTP(S) load balancer.
    HttpsAdvancedLoadBalancer = 1,
    /// Global external HTTP(S) load balancer (classic)
    HttpsLoadBalancer = 2,
    /// Regional external HTTP(S) load balancer.
    RegionalHttpsLoadBalancer = 3,
    /// Internal HTTP(S) load balancer.
    InternalHttpsLoadBalancer = 4,
    /// External SSL proxy load balancer.
    SslProxyLoadBalancer = 5,
    /// External TCP proxy load balancer.
    TcpProxyLoadBalancer = 6,
    /// Internal regional TCP proxy load balancer.
    InternalTcpProxyLoadBalancer = 7,
    /// External TCP/UDP Network load balancer.
    NetworkLoadBalancer = 8,
    /// Target-pool based external TCP/UDP Network load balancer.
    LegacyNetworkLoadBalancer = 9,
    /// Internal TCP/UDP load balancer.
    TcpUdpInternalLoadBalancer = 10,
}
impl LoadBalancerType {
    /// 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 => "LOAD_BALANCER_TYPE_UNSPECIFIED",
            Self::HttpsAdvancedLoadBalancer => "HTTPS_ADVANCED_LOAD_BALANCER",
            Self::HttpsLoadBalancer => "HTTPS_LOAD_BALANCER",
            Self::RegionalHttpsLoadBalancer => "REGIONAL_HTTPS_LOAD_BALANCER",
            Self::InternalHttpsLoadBalancer => "INTERNAL_HTTPS_LOAD_BALANCER",
            Self::SslProxyLoadBalancer => "SSL_PROXY_LOAD_BALANCER",
            Self::TcpProxyLoadBalancer => "TCP_PROXY_LOAD_BALANCER",
            Self::InternalTcpProxyLoadBalancer => "INTERNAL_TCP_PROXY_LOAD_BALANCER",
            Self::NetworkLoadBalancer => "NETWORK_LOAD_BALANCER",
            Self::LegacyNetworkLoadBalancer => "LEGACY_NETWORK_LOAD_BALANCER",
            Self::TcpUdpInternalLoadBalancer => "TCP_UDP_INTERNAL_LOAD_BALANCER",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "LOAD_BALANCER_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "HTTPS_ADVANCED_LOAD_BALANCER" => Some(Self::HttpsAdvancedLoadBalancer),
            "HTTPS_LOAD_BALANCER" => Some(Self::HttpsLoadBalancer),
            "REGIONAL_HTTPS_LOAD_BALANCER" => Some(Self::RegionalHttpsLoadBalancer),
            "INTERNAL_HTTPS_LOAD_BALANCER" => Some(Self::InternalHttpsLoadBalancer),
            "SSL_PROXY_LOAD_BALANCER" => Some(Self::SslProxyLoadBalancer),
            "TCP_PROXY_LOAD_BALANCER" => Some(Self::TcpProxyLoadBalancer),
            "INTERNAL_TCP_PROXY_LOAD_BALANCER" => {
                Some(Self::InternalTcpProxyLoadBalancer)
            }
            "NETWORK_LOAD_BALANCER" => Some(Self::NetworkLoadBalancer),
            "LEGACY_NETWORK_LOAD_BALANCER" => Some(Self::LegacyNetworkLoadBalancer),
            "TCP_UDP_INTERNAL_LOAD_BALANCER" => Some(Self::TcpUdpInternalLoadBalancer),
            _ => None,
        }
    }
}
/// A Connectivity Test for a network reachability analysis.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConnectivityTest {
    /// Identifier. Unique name of the resource using the form:
    /// `projects/{project_id}/locations/global/connectivityTests/{test}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The user-supplied description of the Connectivity Test.
    /// Maximum of 512 characters.
    #[prost(string, tag = "2")]
    pub description: ::prost::alloc::string::String,
    /// Required. Source specification of the Connectivity Test.
    ///
    /// You can use a combination of source IP address, URI of a supported
    /// endpoint, project ID, or VPC network to identify the source location.
    ///
    /// Reachability analysis might proceed even if the source location is
    /// ambiguous. However, the test result might include endpoints or use a source
    /// that you don't intend to test.
    #[prost(message, optional, tag = "3")]
    pub source: ::core::option::Option<Endpoint>,
    /// Required. Destination specification of the Connectivity Test.
    ///
    /// You can use a combination of destination IP address, URI of a supported
    /// endpoint, project ID, or VPC network to identify the destination location.
    ///
    /// Reachability analysis proceeds even if the destination location is
    /// ambiguous. However, the test result might include endpoints or use a
    /// destination that you don't intend to test.
    #[prost(message, optional, tag = "4")]
    pub destination: ::core::option::Option<Endpoint>,
    /// IP Protocol of the test. When not provided, "TCP" is assumed.
    #[prost(string, tag = "5")]
    pub protocol: ::prost::alloc::string::String,
    /// Other projects that may be relevant for reachability analysis.
    /// This is applicable to scenarios where a test can cross project boundaries.
    #[prost(string, repeated, tag = "6")]
    pub related_projects: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Output only. The display name of a Connectivity Test.
    #[prost(string, tag = "7")]
    pub display_name: ::prost::alloc::string::String,
    /// Resource labels to represent user-provided metadata.
    #[prost(map = "string, string", tag = "8")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. The time the test was created.
    #[prost(message, optional, tag = "10")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the test's configuration was updated.
    #[prost(message, optional, tag = "11")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The reachability details of this test from the latest run.
    /// The details are updated when creating a new test, updating an
    /// existing test, or triggering a one-time rerun of an existing test.
    #[prost(message, optional, tag = "12")]
    pub reachability_details: ::core::option::Option<ReachabilityDetails>,
    /// Output only. The probing details of this test from the latest run, present
    /// for applicable tests only. The details are updated when creating a new
    /// test, updating an existing test, or triggering a one-time rerun of an
    /// existing test.
    #[prost(message, optional, tag = "14")]
    pub probing_details: ::core::option::Option<ProbingDetails>,
    /// Whether run analysis for the return path from destination to source.
    /// Default value is false.
    #[prost(bool, tag = "15")]
    pub round_trip: bool,
    /// Output only. The reachability details of this test from the latest run for
    /// the return path. The details are updated when creating a new test,
    /// updating an existing test, or triggering a one-time rerun of an existing
    /// test.
    #[prost(message, optional, tag = "16")]
    pub return_reachability_details: ::core::option::Option<ReachabilityDetails>,
    /// Whether the analysis should skip firewall checking. Default value is false.
    #[prost(bool, tag = "17")]
    pub bypass_firewall_checks: bool,
}
/// Source or destination of the Connectivity Test.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Endpoint {
    /// The IP address of the endpoint, which can be an external or internal IP.
    #[prost(string, tag = "1")]
    pub ip_address: ::prost::alloc::string::String,
    /// The IP protocol port of the endpoint.
    /// Only applicable when protocol is TCP or UDP.
    #[prost(int32, tag = "2")]
    pub port: i32,
    /// A Compute Engine instance URI.
    #[prost(string, tag = "3")]
    pub instance: ::prost::alloc::string::String,
    /// A forwarding rule and its corresponding IP address represent the frontend
    /// configuration of a Google Cloud load balancer. Forwarding rules are also
    /// used for protocol forwarding, Private Service Connect and other network
    /// services to provide forwarding information in the control plane. Applicable
    /// only to destination endpoint. Format:
    /// `projects/{project}/global/forwardingRules/{id}` or
    /// `projects/{project}/regions/{region}/forwardingRules/{id}`
    #[prost(string, tag = "13")]
    pub forwarding_rule: ::prost::alloc::string::String,
    /// Output only. Specifies the type of the target of the forwarding rule.
    #[prost(enumeration = "endpoint::ForwardingRuleTarget", optional, tag = "14")]
    pub forwarding_rule_target: ::core::option::Option<i32>,
    /// Output only. ID of the load balancer the forwarding rule points to. Empty
    /// for forwarding rules not related to load balancers.
    #[prost(string, optional, tag = "15")]
    pub load_balancer_id: ::core::option::Option<::prost::alloc::string::String>,
    /// Output only. Type of the load balancer the forwarding rule points to.
    #[prost(enumeration = "LoadBalancerType", optional, tag = "16")]
    pub load_balancer_type: ::core::option::Option<i32>,
    /// A cluster URI for [Google Kubernetes Engine cluster control
    /// plane](<https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture>).
    #[prost(string, tag = "7")]
    pub gke_master_cluster: ::prost::alloc::string::String,
    /// DNS endpoint of [Google Kubernetes Engine cluster control
    /// plane](<https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-architecture>).
    /// Requires gke_master_cluster to be set, can't be used simultaneoulsly with
    /// ip_address or network. Applicable only to destination endpoint.
    #[prost(string, tag = "19")]
    pub fqdn: ::prost::alloc::string::String,
    /// A [Cloud SQL](<https://cloud.google.com/sql>) instance URI.
    #[prost(string, tag = "8")]
    pub cloud_sql_instance: ::prost::alloc::string::String,
    /// A [Redis Instance](<https://cloud.google.com/memorystore/docs/redis>) URI.
    /// Applicable only to destination endpoint.
    #[prost(string, tag = "17")]
    pub redis_instance: ::prost::alloc::string::String,
    /// A [Redis Cluster](<https://cloud.google.com/memorystore/docs/cluster>) URI.
    /// Applicable only to destination endpoint.
    #[prost(string, tag = "18")]
    pub redis_cluster: ::prost::alloc::string::String,
    /// A [GKE Pod](<https://cloud.google.com/kubernetes-engine/docs/concepts/pod>)
    /// URI.
    #[prost(string, tag = "21")]
    pub gke_pod: ::prost::alloc::string::String,
    /// A [Cloud Function](<https://cloud.google.com/functions>). Applicable only to
    /// source endpoint.
    #[prost(message, optional, tag = "10")]
    pub cloud_function: ::core::option::Option<endpoint::CloudFunctionEndpoint>,
    /// An [App Engine](<https://cloud.google.com/appengine>) [service
    /// version](<https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions>).
    /// Applicable only to source endpoint.
    #[prost(message, optional, tag = "11")]
    pub app_engine_version: ::core::option::Option<endpoint::AppEngineVersionEndpoint>,
    /// A [Cloud Run](<https://cloud.google.com/run>)
    /// [revision](<https://cloud.google.com/run/docs/reference/rest/v1/namespaces.revisions/get>)
    /// Applicable only to source endpoint.
    #[prost(message, optional, tag = "12")]
    pub cloud_run_revision: ::core::option::Option<endpoint::CloudRunRevisionEndpoint>,
    /// A VPC network URI. For source endpoints, used according to the
    /// `network_type`. For destination endpoints, used only when the source is an
    /// external IP address endpoint, and the destination is an internal IP address
    /// endpoint.
    #[prost(string, tag = "4")]
    pub network: ::prost::alloc::string::String,
    /// For source endpoints, type of the network where the endpoint is located.
    /// Not relevant for destination endpoints.
    #[prost(enumeration = "endpoint::NetworkType", tag = "5")]
    pub network_type: i32,
    /// For source endpoints, endpoint project ID. Used according to the
    /// `network_type`. Not relevant for destination endpoints.
    #[prost(string, tag = "6")]
    pub project_id: ::prost::alloc::string::String,
}
/// Nested message and enum types in `Endpoint`.
pub mod endpoint {
    /// Wrapper for Cloud Function attributes.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CloudFunctionEndpoint {
        /// A [Cloud Function](<https://cloud.google.com/functions>) name.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
    }
    /// Wrapper for the App Engine service version attributes.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct AppEngineVersionEndpoint {
        /// An [App Engine](<https://cloud.google.com/appengine>) [service
        /// version](<https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions>)
        /// name.
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
    }
    /// Wrapper for Cloud Run revision attributes.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct CloudRunRevisionEndpoint {
        /// A [Cloud Run](<https://cloud.google.com/run>)
        /// [revision](<https://cloud.google.com/run/docs/reference/rest/v1/namespaces.revisions/get>)
        /// URI. The format is:
        /// projects/{project}/locations/{location}/revisions/{revision}
        #[prost(string, tag = "1")]
        pub uri: ::prost::alloc::string::String,
        /// Output only. The URI of the Cloud Run service that the revision belongs
        /// to. The format is:
        /// projects/{project}/locations/{location}/services/{service}
        #[prost(string, tag = "2")]
        pub service_uri: ::prost::alloc::string::String,
    }
    /// The type of the network of the IP address endpoint. Relevant for the source
    /// IP address endpoints.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum NetworkType {
        /// Unspecified. The test will analyze all possible IP address locations.
        /// This might take longer and produce inaccurate or ambiguous results, so
        /// prefer specifying an explicit network type.
        ///
        /// The `project_id` field should be set to the project where the GCP
        /// endpoint is located, or where the non-GCP endpoint should be reachable
        /// from (via routes to non-GCP networks). The project might also be inferred
        /// from the Connectivity Test project or other projects referenced in the
        /// request.
        Unspecified = 0,
        /// A VPC network. Should be used for internal IP addresses in VPC networks.
        /// The `network` field should be set to the URI of this network. Only
        /// endpoints within this network will be considered.
        GcpNetwork = 1,
        /// A non-GCP network (for example, an on-premises network or another cloud
        /// provider network). Should be used for internal IP addresses outside of
        /// Google Cloud. The `network` field should be set to the URI of the VPC
        /// network containing a corresponding Cloud VPN tunnel, Cloud Interconnect
        /// VLAN attachment, or a router appliance instance. Only endpoints reachable
        /// from the provided VPC network via the routes to non-GCP networks will be
        /// considered.
        NonGcpNetwork = 2,
        /// Internet. Should be used for internet-routable external IP addresses or
        /// IP addresses for global Google APIs and services.
        Internet = 3,
    }
    impl NetworkType {
        /// 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 => "NETWORK_TYPE_UNSPECIFIED",
                Self::GcpNetwork => "GCP_NETWORK",
                Self::NonGcpNetwork => "NON_GCP_NETWORK",
                Self::Internet => "INTERNET",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "NETWORK_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "GCP_NETWORK" => Some(Self::GcpNetwork),
                "NON_GCP_NETWORK" => Some(Self::NonGcpNetwork),
                "INTERNET" => Some(Self::Internet),
                _ => None,
            }
        }
    }
    /// Type of the target of a forwarding rule.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ForwardingRuleTarget {
        /// Forwarding rule target is unknown.
        Unspecified = 0,
        /// Compute Engine instance for protocol forwarding.
        Instance = 1,
        /// Load Balancer. The specific type can be found from \[load_balancer_type\]
        /// \[google.cloud.networkmanagement.v1beta1.Endpoint.load_balancer_type\].
        LoadBalancer = 2,
        /// Classic Cloud VPN Gateway.
        VpnGateway = 3,
        /// Forwarding Rule is a Private Service Connect endpoint.
        Psc = 4,
    }
    impl ForwardingRuleTarget {
        /// 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 => "FORWARDING_RULE_TARGET_UNSPECIFIED",
                Self::Instance => "INSTANCE",
                Self::LoadBalancer => "LOAD_BALANCER",
                Self::VpnGateway => "VPN_GATEWAY",
                Self::Psc => "PSC",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "FORWARDING_RULE_TARGET_UNSPECIFIED" => Some(Self::Unspecified),
                "INSTANCE" => Some(Self::Instance),
                "LOAD_BALANCER" => Some(Self::LoadBalancer),
                "VPN_GATEWAY" => Some(Self::VpnGateway),
                "PSC" => Some(Self::Psc),
                _ => None,
            }
        }
    }
}
/// Results of the configuration analysis from the last run of the test.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReachabilityDetails {
    /// The overall result of the test's configuration analysis.
    #[prost(enumeration = "reachability_details::Result", tag = "1")]
    pub result: i32,
    /// The time of the configuration analysis.
    #[prost(message, optional, tag = "2")]
    pub verify_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The details of a failure or a cancellation of reachability analysis.
    #[prost(message, optional, tag = "3")]
    pub error: ::core::option::Option<super::super::super::rpc::Status>,
    /// Result may contain a list of traces if a test has multiple possible
    /// paths in the network, such as when destination endpoint is a load balancer
    /// with multiple backends.
    #[prost(message, repeated, tag = "5")]
    pub traces: ::prost::alloc::vec::Vec<Trace>,
}
/// Nested message and enum types in `ReachabilityDetails`.
pub mod reachability_details {
    /// The overall result of the test's configuration analysis.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Result {
        /// No result was specified.
        Unspecified = 0,
        /// Possible scenarios are:
        ///
        /// * The configuration analysis determined that a packet originating from
        ///   the source is expected to reach the destination.
        /// * The analysis didn't complete because the user lacks permission for
        ///   some of the resources in the trace. However, at the time the user's
        ///   permission became insufficient, the trace had been successful so far.
        Reachable = 1,
        /// A packet originating from the source is expected to be dropped before
        /// reaching the destination.
        Unreachable = 2,
        /// The source and destination endpoints do not uniquely identify
        /// the test location in the network, and the reachability result contains
        /// multiple traces. For some traces, a packet could be delivered, and for
        /// others, it would not be. This result is also assigned to
        /// configuration analysis of return path if on its own it should be
        /// REACHABLE, but configuration analysis of forward path is AMBIGUOUS.
        Ambiguous = 4,
        /// The configuration analysis did not complete. Possible reasons are:
        ///
        /// * A permissions error occurred--for example, the user might not have
        ///   read permission for all of the resources named in the test.
        /// * An internal error occurred.
        /// * The analyzer received an invalid or unsupported argument or was unable
        ///   to identify a known endpoint.
        Undetermined = 5,
    }
    impl Result {
        /// 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 => "RESULT_UNSPECIFIED",
                Self::Reachable => "REACHABLE",
                Self::Unreachable => "UNREACHABLE",
                Self::Ambiguous => "AMBIGUOUS",
                Self::Undetermined => "UNDETERMINED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "RESULT_UNSPECIFIED" => Some(Self::Unspecified),
                "REACHABLE" => Some(Self::Reachable),
                "UNREACHABLE" => Some(Self::Unreachable),
                "AMBIGUOUS" => Some(Self::Ambiguous),
                "UNDETERMINED" => Some(Self::Undetermined),
                _ => None,
            }
        }
    }
}
/// Latency percentile rank and value.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LatencyPercentile {
    /// Percentage of samples this data point applies to.
    #[prost(int32, tag = "1")]
    pub percent: i32,
    /// percent-th percentile of latency observed, in microseconds.
    /// Fraction of percent/100 of samples have latency lower or
    /// equal to the value of this field.
    #[prost(int64, tag = "2")]
    pub latency_micros: i64,
}
/// Describes measured latency distribution.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LatencyDistribution {
    /// Representative latency percentiles.
    #[prost(message, repeated, tag = "1")]
    pub latency_percentiles: ::prost::alloc::vec::Vec<LatencyPercentile>,
}
/// Results of active probing from the last run of the test.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProbingDetails {
    /// The overall result of active probing.
    #[prost(enumeration = "probing_details::ProbingResult", tag = "1")]
    pub result: i32,
    /// The time that reachability was assessed through active probing.
    #[prost(message, optional, tag = "2")]
    pub verify_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Details about an internal failure or the cancellation of active probing.
    #[prost(message, optional, tag = "3")]
    pub error: ::core::option::Option<super::super::super::rpc::Status>,
    /// The reason probing was aborted.
    #[prost(enumeration = "probing_details::ProbingAbortCause", tag = "4")]
    pub abort_cause: i32,
    /// Number of probes sent.
    #[prost(int32, tag = "5")]
    pub sent_probe_count: i32,
    /// Number of probes that reached the destination.
    #[prost(int32, tag = "6")]
    pub successful_probe_count: i32,
    /// The source and destination endpoints derived from the test input and used
    /// for active probing.
    #[prost(message, optional, tag = "7")]
    pub endpoint_info: ::core::option::Option<EndpointInfo>,
    /// Latency as measured by active probing in one direction:
    /// from the source to the destination endpoint.
    #[prost(message, optional, tag = "8")]
    pub probing_latency: ::core::option::Option<LatencyDistribution>,
    /// The EdgeLocation from which a packet, destined to the internet, will egress
    /// the Google network.
    /// This will only be populated for a connectivity test which has an internet
    /// destination address.
    /// The absence of this field *must not* be used as an indication that the
    /// destination is part of the Google network.
    #[prost(message, optional, tag = "9")]
    pub destination_egress_location: ::core::option::Option<
        probing_details::EdgeLocation,
    >,
    /// Probing results for all edge devices.
    #[prost(message, repeated, tag = "10")]
    pub edge_responses: ::prost::alloc::vec::Vec<probing_details::SingleEdgeResponse>,
    /// Whether all relevant edge devices were probed.
    #[prost(bool, tag = "11")]
    pub probed_all_devices: bool,
}
/// Nested message and enum types in `ProbingDetails`.
pub mod probing_details {
    /// Representation of a network edge location as per
    /// <https://cloud.google.com/vpc/docs/edge-locations.>
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
    pub struct EdgeLocation {
        /// Name of the metropolitan area.
        #[prost(string, tag = "1")]
        pub metropolitan_area: ::prost::alloc::string::String,
    }
    /// Probing results for a single edge device.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct SingleEdgeResponse {
        /// The overall result of active probing for this egress device.
        #[prost(enumeration = "ProbingResult", tag = "1")]
        pub result: i32,
        /// Number of probes sent.
        #[prost(int32, tag = "2")]
        pub sent_probe_count: i32,
        /// Number of probes that reached the destination.
        #[prost(int32, tag = "3")]
        pub successful_probe_count: i32,
        /// Latency as measured by active probing in one direction: from the source
        /// to the destination endpoint.
        #[prost(message, optional, tag = "4")]
        pub probing_latency: ::core::option::Option<super::LatencyDistribution>,
        /// The EdgeLocation from which a packet, destined to the internet, will
        /// egress the Google network.
        /// This will only be populated for a connectivity test which has an internet
        /// destination address.
        /// The absence of this field *must not* be used as an indication that the
        /// destination is part of the Google network.
        #[prost(message, optional, tag = "5")]
        pub destination_egress_location: ::core::option::Option<EdgeLocation>,
        /// Router name in the format '{router}.{metroshard}'. For example:
        /// pf01.aaa01, pr02.aaa01.
        #[prost(string, tag = "6")]
        pub destination_router: ::prost::alloc::string::String,
    }
    /// Overall probing result of the test.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ProbingResult {
        /// No result was specified.
        Unspecified = 0,
        /// At least 95% of packets reached the destination.
        Reachable = 1,
        /// No packets reached the destination.
        Unreachable = 2,
        /// Less than 95% of packets reached the destination.
        ReachabilityInconsistent = 3,
        /// Reachability could not be determined. Possible reasons are:
        ///
        /// * The user lacks permission to access some of the network resources
        ///   required to run the test.
        /// * No valid source endpoint could be derived from the request.
        /// * An internal error occurred.
        Undetermined = 4,
    }
    impl ProbingResult {
        /// 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 => "PROBING_RESULT_UNSPECIFIED",
                Self::Reachable => "REACHABLE",
                Self::Unreachable => "UNREACHABLE",
                Self::ReachabilityInconsistent => "REACHABILITY_INCONSISTENT",
                Self::Undetermined => "UNDETERMINED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PROBING_RESULT_UNSPECIFIED" => Some(Self::Unspecified),
                "REACHABLE" => Some(Self::Reachable),
                "UNREACHABLE" => Some(Self::Unreachable),
                "REACHABILITY_INCONSISTENT" => Some(Self::ReachabilityInconsistent),
                "UNDETERMINED" => Some(Self::Undetermined),
                _ => None,
            }
        }
    }
    /// Abort cause types.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum ProbingAbortCause {
        /// No reason was specified.
        Unspecified = 0,
        /// The user lacks permission to access some of the
        /// network resources required to run the test.
        PermissionDenied = 1,
        /// No valid source endpoint could be derived from the request.
        NoSourceLocation = 2,
    }
    impl ProbingAbortCause {
        /// 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 => "PROBING_ABORT_CAUSE_UNSPECIFIED",
                Self::PermissionDenied => "PERMISSION_DENIED",
                Self::NoSourceLocation => "NO_SOURCE_LOCATION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "PROBING_ABORT_CAUSE_UNSPECIFIED" => Some(Self::Unspecified),
                "PERMISSION_DENIED" => Some(Self::PermissionDenied),
                "NO_SOURCE_LOCATION" => Some(Self::NoSourceLocation),
                _ => None,
            }
        }
    }
}
/// Request for the `ListConnectivityTests` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListConnectivityTestsRequest {
    /// Required. The parent resource of the Connectivity Tests:
    /// `projects/{project_id}/locations/global`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Number of `ConnectivityTests` to return.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Page token from an earlier query, as returned in `next_page_token`.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Lists the `ConnectivityTests` that match the filter expression. A filter
    /// expression filters the resources listed in the response. The expression
    /// must be of the form `<field> <operator> <value>` where operators: `<`, `>`,
    /// `<=`,
    /// `>=`,
    /// `!=`, `=`, `:` are supported (colon `:` represents a HAS operator which is
    /// roughly synonymous with equality). <field> can refer to a proto or JSON
    /// field, or a synthetic field. Field names can be camelCase or snake_case.
    ///
    /// Examples:
    ///
    /// * Filter by name:
    ///   name = "projects/proj-1/locations/global/connectivityTests/test-1
    ///
    /// * Filter by labels:
    ///
    ///   * Resources that have a key called `foo`
    ///     labels.foo:\*
    ///   * Resources that have a key called `foo` whose value is `bar`
    ///     labels.foo = bar
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Field to use to sort the list.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response for the `ListConnectivityTests` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListConnectivityTestsResponse {
    /// List of Connectivity Tests.
    #[prost(message, repeated, tag = "1")]
    pub resources: ::prost::alloc::vec::Vec<ConnectivityTest>,
    /// Page token to fetch the next set of Connectivity Tests.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached (when querying all locations with `-`).
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request for the `GetConnectivityTest` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetConnectivityTestRequest {
    /// Required. `ConnectivityTest` resource name using the form:
    /// `projects/{project_id}/locations/global/connectivityTests/{test_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for the `CreateConnectivityTest` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateConnectivityTestRequest {
    /// Required. The parent resource of the Connectivity Test to create:
    /// `projects/{project_id}/locations/global`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The logical name of the Connectivity Test in your project
    /// with the following restrictions:
    ///
    /// * Must contain only lowercase letters, numbers, and hyphens.
    /// * Must start with a letter.
    /// * Must be between 1-40 characters.
    /// * Must end with a number or a letter.
    /// * Must be unique within the customer project
    #[prost(string, tag = "2")]
    pub test_id: ::prost::alloc::string::String,
    /// Required. A `ConnectivityTest` resource
    #[prost(message, optional, tag = "3")]
    pub resource: ::core::option::Option<ConnectivityTest>,
}
/// Request for the `UpdateConnectivityTest` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateConnectivityTestRequest {
    /// Required. Mask of fields to update. At least one path must be supplied in
    /// this field.
    #[prost(message, optional, tag = "1")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Required. Only fields specified in update_mask are updated.
    #[prost(message, optional, tag = "2")]
    pub resource: ::core::option::Option<ConnectivityTest>,
}
/// Request for the `DeleteConnectivityTest` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteConnectivityTestRequest {
    /// Required. Connectivity Test resource name using the form:
    /// `projects/{project_id}/locations/global/connectivityTests/{test_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for the `RerunConnectivityTest` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RerunConnectivityTestRequest {
    /// Required. Connectivity Test resource name using the form:
    /// `projects/{project_id}/locations/global/connectivityTests/{test_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Metadata describing an \[Operation\]\[google.longrunning.Operation\]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OperationMetadata {
    /// The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Target of the operation - for example
    /// projects/project-1/locations/global/connectivityTests/test-1
    #[prost(string, tag = "3")]
    pub target: ::prost::alloc::string::String,
    /// Name of the verb executed by the operation.
    #[prost(string, tag = "4")]
    pub verb: ::prost::alloc::string::String,
    /// Human-readable status of the operation, if any.
    #[prost(string, tag = "5")]
    pub status_detail: ::prost::alloc::string::String,
    /// Specifies if cancellation was requested for the operation.
    #[prost(bool, tag = "6")]
    pub cancel_requested: bool,
    /// API version.
    #[prost(string, tag = "7")]
    pub api_version: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod reachability_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// The Reachability service in the Google Cloud Network Management API provides
    /// services that analyze the reachability within a single Google Virtual Private
    /// Cloud (VPC) network, between peered VPC networks, between VPC and on-premises
    /// networks, or between VPC networks and internet hosts. A reachability analysis
    /// is based on Google Cloud network configurations.
    ///
    /// You can use the analysis results to verify these configurations and
    /// to troubleshoot connectivity issues.
    #[derive(Debug, Clone)]
    pub struct ReachabilityServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl ReachabilityServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> ReachabilityServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> ReachabilityServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            ReachabilityServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Lists all Connectivity Tests owned by a project.
        pub async fn list_connectivity_tests(
            &mut self,
            request: impl tonic::IntoRequest<super::ListConnectivityTestsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListConnectivityTestsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.ReachabilityService/ListConnectivityTests",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.ReachabilityService",
                        "ListConnectivityTests",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the details of a specific Connectivity Test.
        pub async fn get_connectivity_test(
            &mut self,
            request: impl tonic::IntoRequest<super::GetConnectivityTestRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ConnectivityTest>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.ReachabilityService/GetConnectivityTest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.ReachabilityService",
                        "GetConnectivityTest",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new Connectivity Test.
        /// After you create a test, the reachability analysis is performed as part
        /// of the long running operation, which completes when the analysis completes.
        ///
        /// If the endpoint specifications in `ConnectivityTest` are invalid
        /// (for example, containing non-existent resources in the network, or you
        /// don't have read permissions to the network configurations of listed
        /// projects), then the reachability result returns a value of `UNKNOWN`.
        ///
        /// If the endpoint specifications in `ConnectivityTest` are
        /// incomplete, the reachability result returns a value of
        /// <code>AMBIGUOUS</code>. For more information,
        /// see the Connectivity Test documentation.
        pub async fn create_connectivity_test(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateConnectivityTestRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.ReachabilityService/CreateConnectivityTest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.ReachabilityService",
                        "CreateConnectivityTest",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the configuration of an existing `ConnectivityTest`.
        /// After you update a test, the reachability analysis is performed as part
        /// of the long running operation, which completes when the analysis completes.
        /// The Reachability state in the test resource is updated with the new result.
        ///
        /// If the endpoint specifications in `ConnectivityTest` are invalid
        /// (for example, they contain non-existent resources in the network, or the
        /// user does not have read permissions to the network configurations of
        /// listed projects), then the reachability result returns a value of
        /// <code>UNKNOWN</code>.
        ///
        /// If the endpoint specifications in `ConnectivityTest` are incomplete, the
        /// reachability result returns a value of `AMBIGUOUS`. See the documentation
        /// in `ConnectivityTest` for more details.
        pub async fn update_connectivity_test(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateConnectivityTestRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.ReachabilityService/UpdateConnectivityTest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.ReachabilityService",
                        "UpdateConnectivityTest",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Rerun an existing `ConnectivityTest`.
        /// After the user triggers the rerun, the reachability analysis is performed
        /// as part of the long running operation, which completes when the analysis
        /// completes.
        ///
        /// Even though the test configuration remains the same, the reachability
        /// result may change due to underlying network configuration changes.
        ///
        /// If the endpoint specifications in `ConnectivityTest` become invalid (for
        /// example, specified resources are deleted in the network, or you lost
        /// read permissions to the network configurations of listed projects), then
        /// the reachability result returns a value of `UNKNOWN`.
        pub async fn rerun_connectivity_test(
            &mut self,
            request: impl tonic::IntoRequest<super::RerunConnectivityTestRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.ReachabilityService/RerunConnectivityTest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.ReachabilityService",
                        "RerunConnectivityTest",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a specific `ConnectivityTest`.
        pub async fn delete_connectivity_test(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteConnectivityTestRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.ReachabilityService/DeleteConnectivityTest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.ReachabilityService",
                        "DeleteConnectivityTest",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// A configuration to generate VPC Flow Logs.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct VpcFlowLogsConfig {
    /// Identifier. Unique name of the configuration. The name can have one of the
    /// following forms:
    ///
    /// * For project-level configurations:
    ///   `projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`
    ///
    /// * For organization-level configurations:
    ///   `organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. The user-supplied description of the VPC Flow Logs configuration.
    /// Maximum of 512 characters.
    #[prost(string, optional, tag = "2")]
    pub description: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional. The state of the VPC Flow Log configuration. Default value is
    /// ENABLED. When creating a new configuration, it must be enabled. Setting
    /// state=DISABLED will pause the log generation for this config.
    #[prost(enumeration = "vpc_flow_logs_config::State", optional, tag = "3")]
    pub state: ::core::option::Option<i32>,
    /// Optional. The aggregation interval for the logs. Default value is
    /// INTERVAL_5_SEC.
    #[prost(
        enumeration = "vpc_flow_logs_config::AggregationInterval",
        optional,
        tag = "4"
    )]
    pub aggregation_interval: ::core::option::Option<i32>,
    /// Optional. The value of the field must be in (0, 1\]. The sampling rate of
    /// VPC Flow Logs where 1.0 means all collected logs are reported. Setting the
    /// sampling rate to 0.0 is not allowed. If you want to disable VPC Flow Logs,
    /// use the state field instead. Default value is 1.0.
    #[prost(float, optional, tag = "5")]
    pub flow_sampling: ::core::option::Option<f32>,
    /// Optional. Configures whether all, none or a subset of metadata fields
    /// should be added to the reported VPC flow logs. Default value is
    /// INCLUDE_ALL_METADATA.
    #[prost(enumeration = "vpc_flow_logs_config::Metadata", optional, tag = "6")]
    pub metadata: ::core::option::Option<i32>,
    /// Optional. Custom metadata fields to include in the reported VPC flow logs.
    /// Can only be specified if "metadata" was set to CUSTOM_METADATA.
    #[prost(string, repeated, tag = "7")]
    pub metadata_fields: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Optional. Export filter used to define which VPC Flow Logs should be
    /// logged.
    #[prost(string, optional, tag = "8")]
    pub filter_expr: ::core::option::Option<::prost::alloc::string::String>,
    /// Optional. Determines whether to include cross project annotations in the
    /// logs. This field is available only for organization configurations. If not
    /// specified in org configs will be set to CROSS_PROJECT_METADATA_ENABLED.
    #[prost(
        enumeration = "vpc_flow_logs_config::CrossProjectMetadata",
        optional,
        tag = "13"
    )]
    pub cross_project_metadata: ::core::option::Option<i32>,
    /// Output only. Describes the state of the configured target resource for
    /// diagnostic purposes.
    #[prost(
        enumeration = "vpc_flow_logs_config::TargetResourceState",
        optional,
        tag = "12"
    )]
    pub target_resource_state: ::core::option::Option<i32>,
    /// Optional. Resource labels to represent user-provided metadata.
    #[prost(map = "string, string", tag = "11")]
    pub labels: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Output only. The time the config was created.
    #[prost(message, optional, tag = "9")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the config was updated.
    #[prost(message, optional, tag = "10")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Reference to the resource of the config scope. That is, the scope from
    /// which traffic is logged. The target resource must belong to the same
    /// project as the configuration.
    /// This field is not supported for organization level configurations.
    #[prost(oneof = "vpc_flow_logs_config::TargetResource", tags = "100, 101, 102, 103")]
    pub target_resource: ::core::option::Option<vpc_flow_logs_config::TargetResource>,
}
/// Nested message and enum types in `VpcFlowLogsConfig`.
pub mod vpc_flow_logs_config {
    /// Determines whether this configuration will be generating logs.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// If not specified, will default to ENABLED.
        Unspecified = 0,
        /// When ENABLED, this configuration will generate logs.
        Enabled = 1,
        /// When DISABLED, this configuration will not generate logs.
        Disabled = 2,
    }
    impl State {
        /// 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 => "STATE_UNSPECIFIED",
                Self::Enabled => "ENABLED",
                Self::Disabled => "DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "ENABLED" => Some(Self::Enabled),
                "DISABLED" => Some(Self::Disabled),
                _ => None,
            }
        }
    }
    /// Toggles the aggregation interval for collecting flow logs by 5-tuple.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum AggregationInterval {
        /// If not specified, will default to INTERVAL_5_SEC.
        Unspecified = 0,
        /// Aggregate logs in 5s intervals.
        Interval5Sec = 1,
        /// Aggregate logs in 30s intervals.
        Interval30Sec = 2,
        /// Aggregate logs in 1m intervals.
        Interval1Min = 3,
        /// Aggregate logs in 5m intervals.
        Interval5Min = 4,
        /// Aggregate logs in 10m intervals.
        Interval10Min = 5,
        /// Aggregate logs in 15m intervals.
        Interval15Min = 6,
    }
    impl AggregationInterval {
        /// 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 => "AGGREGATION_INTERVAL_UNSPECIFIED",
                Self::Interval5Sec => "INTERVAL_5_SEC",
                Self::Interval30Sec => "INTERVAL_30_SEC",
                Self::Interval1Min => "INTERVAL_1_MIN",
                Self::Interval5Min => "INTERVAL_5_MIN",
                Self::Interval10Min => "INTERVAL_10_MIN",
                Self::Interval15Min => "INTERVAL_15_MIN",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "AGGREGATION_INTERVAL_UNSPECIFIED" => Some(Self::Unspecified),
                "INTERVAL_5_SEC" => Some(Self::Interval5Sec),
                "INTERVAL_30_SEC" => Some(Self::Interval30Sec),
                "INTERVAL_1_MIN" => Some(Self::Interval1Min),
                "INTERVAL_5_MIN" => Some(Self::Interval5Min),
                "INTERVAL_10_MIN" => Some(Self::Interval10Min),
                "INTERVAL_15_MIN" => Some(Self::Interval15Min),
                _ => None,
            }
        }
    }
    /// Configures which log fields would be included.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Metadata {
        /// If not specified, will default to INCLUDE_ALL_METADATA.
        Unspecified = 0,
        /// Include all metadata fields.
        IncludeAllMetadata = 1,
        /// Exclude all metadata fields.
        ExcludeAllMetadata = 2,
        /// Include only custom fields (specified in metadata_fields).
        CustomMetadata = 3,
    }
    impl Metadata {
        /// 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_UNSPECIFIED",
                Self::IncludeAllMetadata => "INCLUDE_ALL_METADATA",
                Self::ExcludeAllMetadata => "EXCLUDE_ALL_METADATA",
                Self::CustomMetadata => "CUSTOM_METADATA",
            }
        }
        /// 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_UNSPECIFIED" => Some(Self::Unspecified),
                "INCLUDE_ALL_METADATA" => Some(Self::IncludeAllMetadata),
                "EXCLUDE_ALL_METADATA" => Some(Self::ExcludeAllMetadata),
                "CUSTOM_METADATA" => Some(Self::CustomMetadata),
                _ => None,
            }
        }
    }
    /// Determines whether to include cross project annotations in the logs.
    /// Project configurations will always have CROSS_PROJECT_METADATA_DISABLED.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum CrossProjectMetadata {
        /// If not specified, the default is CROSS_PROJECT_METADATA_ENABLED.
        Unspecified = 0,
        /// When CROSS_PROJECT_METADATA_ENABLED, metadata from other projects will be
        /// included in the logs.
        Enabled = 1,
        /// When CROSS_PROJECT_METADATA_DISABLED, metadata from other projects will
        /// not be included in the logs.
        Disabled = 2,
    }
    impl CrossProjectMetadata {
        /// 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 => "CROSS_PROJECT_METADATA_UNSPECIFIED",
                Self::Enabled => "CROSS_PROJECT_METADATA_ENABLED",
                Self::Disabled => "CROSS_PROJECT_METADATA_DISABLED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "CROSS_PROJECT_METADATA_UNSPECIFIED" => Some(Self::Unspecified),
                "CROSS_PROJECT_METADATA_ENABLED" => Some(Self::Enabled),
                "CROSS_PROJECT_METADATA_DISABLED" => Some(Self::Disabled),
                _ => None,
            }
        }
    }
    /// Output only. Indicates whether the target resource exists, for diagnostic
    /// purposes.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum TargetResourceState {
        /// Unspecified target resource state.
        Unspecified = 0,
        /// Indicates that the target resource exists.
        TargetResourceExists = 1,
        /// Indicates that the target resource does not exist.
        TargetResourceDoesNotExist = 2,
    }
    impl TargetResourceState {
        /// 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 => "TARGET_RESOURCE_STATE_UNSPECIFIED",
                Self::TargetResourceExists => "TARGET_RESOURCE_EXISTS",
                Self::TargetResourceDoesNotExist => "TARGET_RESOURCE_DOES_NOT_EXIST",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TARGET_RESOURCE_STATE_UNSPECIFIED" => Some(Self::Unspecified),
                "TARGET_RESOURCE_EXISTS" => Some(Self::TargetResourceExists),
                "TARGET_RESOURCE_DOES_NOT_EXIST" => {
                    Some(Self::TargetResourceDoesNotExist)
                }
                _ => None,
            }
        }
    }
    /// Reference to the resource of the config scope. That is, the scope from
    /// which traffic is logged. The target resource must belong to the same
    /// project as the configuration.
    /// This field is not supported for organization level configurations.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum TargetResource {
        /// Traffic will be logged from VMs, VPN tunnels and Interconnect Attachments
        /// within the network.
        /// Format: projects/{project_id}/global/networks/{name}
        #[prost(string, tag = "100")]
        Network(::prost::alloc::string::String),
        /// Traffic will be logged from VMs within the subnetwork.
        /// Format: projects/{project_id}/regions/{region}/subnetworks/{name}
        #[prost(string, tag = "101")]
        Subnet(::prost::alloc::string::String),
        /// Traffic will be logged from the Interconnect Attachment.
        /// Format:
        /// projects/{project_id}/regions/{region}/interconnectAttachments/{name}
        #[prost(string, tag = "102")]
        InterconnectAttachment(::prost::alloc::string::String),
        /// Traffic will be logged from the VPN Tunnel.
        /// Format: projects/{project_id}/regions/{region}/vpnTunnels/{name}
        #[prost(string, tag = "103")]
        VpnTunnel(::prost::alloc::string::String),
    }
}
/// A configuration to generate a response for GetEffectiveVpcFlowLogsConfig
/// request.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EffectiveVpcFlowLogsConfig {
    /// Unique name of the configuration. The name can have one of the following
    /// forms:
    ///
    /// * For project-level configurations:
    ///   `projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`
    ///
    /// * For organization-level configurations:
    ///   `organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`
    ///
    /// * For a Compute config, the name will be the path of the subnet:
    ///   `projects/{project_id}/regions/{region}/subnetworks/{subnet_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// The state of the VPC Flow Log configuration. Default value is ENABLED.
    /// When creating a new configuration, it must be enabled.
    /// Setting state=DISABLED will pause the log generation for this config.
    #[prost(enumeration = "vpc_flow_logs_config::State", optional, tag = "3")]
    pub state: ::core::option::Option<i32>,
    /// The aggregation interval for the logs. Default value is INTERVAL_5_SEC.
    #[prost(
        enumeration = "vpc_flow_logs_config::AggregationInterval",
        optional,
        tag = "4"
    )]
    pub aggregation_interval: ::core::option::Option<i32>,
    /// The value of the field must be in (0, 1\]. The sampling rate of VPC Flow
    /// Logs where 1.0 means all collected logs are reported.
    /// Setting the sampling rate to 0.0 is not allowed. If you want to disable VPC
    /// Flow Logs, use the state field instead.
    /// Default value is 1.0.
    #[prost(float, optional, tag = "5")]
    pub flow_sampling: ::core::option::Option<f32>,
    /// Configures whether all, none or a subset of metadata fields should be
    /// added to the reported VPC flow logs.
    /// Default value is INCLUDE_ALL_METADATA.
    #[prost(enumeration = "vpc_flow_logs_config::Metadata", optional, tag = "6")]
    pub metadata: ::core::option::Option<i32>,
    /// Custom metadata fields to include in the reported VPC flow logs.
    /// Can only be specified if "metadata" was set to CUSTOM_METADATA.
    #[prost(string, repeated, tag = "7")]
    pub metadata_fields: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    /// Export filter used to define which VPC Flow Logs should be logged.
    #[prost(string, optional, tag = "8")]
    pub filter_expr: ::core::option::Option<::prost::alloc::string::String>,
    /// Determines whether to include cross project annotations in the logs.
    /// This field is available only for organization configurations. If not
    /// specified in org configs will be set to CROSS_PROJECT_METADATA_ENABLED.
    #[prost(
        enumeration = "vpc_flow_logs_config::CrossProjectMetadata",
        optional,
        tag = "13"
    )]
    pub cross_project_metadata: ::core::option::Option<i32>,
    /// Specifies the scope of the config (e.g., SUBNET, NETWORK, ORGANIZATION..).
    #[prost(enumeration = "effective_vpc_flow_logs_config::Scope", optional, tag = "12")]
    pub scope: ::core::option::Option<i32>,
    /// Reference to the resource of the config scope. That is, the scope from
    /// which traffic is logged. The target resource must belong to the same
    /// project as the configuration.
    /// This field is not supported for organization level configurations.
    #[prost(
        oneof = "effective_vpc_flow_logs_config::TargetResource",
        tags = "100, 101, 102, 103"
    )]
    pub target_resource: ::core::option::Option<
        effective_vpc_flow_logs_config::TargetResource,
    >,
}
/// Nested message and enum types in `EffectiveVpcFlowLogsConfig`.
pub mod effective_vpc_flow_logs_config {
    /// The scope for this flow log configuration.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum Scope {
        /// Scope is unspecified.
        Unspecified = 0,
        /// Target resource is a subnet (Network Management API).
        Subnet = 1,
        /// Target resource is a subnet, and the config originates from the Compute
        /// API.
        ComputeApiSubnet = 2,
        /// Target resource is a network.
        Network = 3,
        /// Target resource is a VPN tunnel.
        VpnTunnel = 4,
        /// Target resource is an interconnect attachment.
        InterconnectAttachment = 5,
        /// Configuration applies to an entire organization.
        Organization = 6,
    }
    impl Scope {
        /// 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 => "SCOPE_UNSPECIFIED",
                Self::Subnet => "SUBNET",
                Self::ComputeApiSubnet => "COMPUTE_API_SUBNET",
                Self::Network => "NETWORK",
                Self::VpnTunnel => "VPN_TUNNEL",
                Self::InterconnectAttachment => "INTERCONNECT_ATTACHMENT",
                Self::Organization => "ORGANIZATION",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "SCOPE_UNSPECIFIED" => Some(Self::Unspecified),
                "SUBNET" => Some(Self::Subnet),
                "COMPUTE_API_SUBNET" => Some(Self::ComputeApiSubnet),
                "NETWORK" => Some(Self::Network),
                "VPN_TUNNEL" => Some(Self::VpnTunnel),
                "INTERCONNECT_ATTACHMENT" => Some(Self::InterconnectAttachment),
                "ORGANIZATION" => Some(Self::Organization),
                _ => None,
            }
        }
    }
    /// Reference to the resource of the config scope. That is, the scope from
    /// which traffic is logged. The target resource must belong to the same
    /// project as the configuration.
    /// This field is not supported for organization level configurations.
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum TargetResource {
        /// Traffic will be logged from VMs, VPN tunnels and Interconnect Attachments
        /// within the network.
        /// Format: projects/{project_id}/global/networks/{name}
        #[prost(string, tag = "100")]
        Network(::prost::alloc::string::String),
        /// Traffic will be logged from VMs within the subnetwork.
        /// Format: projects/{project_id}/regions/{region}/subnetworks/{name}
        #[prost(string, tag = "101")]
        Subnet(::prost::alloc::string::String),
        /// Traffic will be logged from the Interconnect Attachment.
        /// Format:
        /// projects/{project_id}/regions/{region}/interconnectAttachments/{name}
        #[prost(string, tag = "102")]
        InterconnectAttachment(::prost::alloc::string::String),
        /// Traffic will be logged from the VPN Tunnel.
        /// Format: projects/{project_id}/regions/{region}/vpnTunnels/{name}
        #[prost(string, tag = "103")]
        VpnTunnel(::prost::alloc::string::String),
    }
}
/// Request for the `ListVpcFlowLogsConfigs` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ListVpcFlowLogsConfigsRequest {
    /// Required. The parent resource of the VpcFlowLogsConfig,
    /// in one of the following formats:
    ///
    /// * For project-level resources: `projects/{project_id}/locations/global`
    ///
    /// * For organization-level resources:
    ///   `organizations/{organization_id}/locations/global`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Number of `VpcFlowLogsConfigs` to return.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. Page token from an earlier query, as returned in
    /// `next_page_token`.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Lists the `VpcFlowLogsConfigs` that match the filter expression.
    /// A filter expression must use the supported \[CEL logic operators\]
    /// (<https://cloud.google.com/vpc/docs/about-flow-logs-records#supported_cel_logic_operators>).
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Optional. Field to use to sort the list.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Response for the `ListVpcFlowLogsConfigs` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListVpcFlowLogsConfigsResponse {
    /// List of VPC Flow Log configurations.
    #[prost(message, repeated, tag = "1")]
    pub vpc_flow_logs_configs: ::prost::alloc::vec::Vec<VpcFlowLogsConfig>,
    /// Page token to fetch the next set of configurations.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached (when querying all locations with `-`).
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request for the `GetVpcFlowLogsConfig` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetVpcFlowLogsConfigRequest {
    /// Required. The resource name of the VpcFlowLogsConfig,
    /// in one of the following formats:
    ///
    /// * For project-level resources:
    ///   `projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`
    ///
    /// * For organization-level resources:
    ///   `organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for the `CreateVpcFlowLogsConfig` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateVpcFlowLogsConfigRequest {
    /// Required. The parent resource of the VpcFlowLogsConfig to create,
    /// in one of the following formats:
    ///
    /// * For project-level resources: `projects/{project_id}/locations/global`
    ///
    /// * For organization-level resources:
    ///   `organizations/{organization_id}/locations/global`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. ID of the `VpcFlowLogsConfig`.
    #[prost(string, tag = "2")]
    pub vpc_flow_logs_config_id: ::prost::alloc::string::String,
    /// Required. A `VpcFlowLogsConfig` resource
    #[prost(message, optional, tag = "3")]
    pub vpc_flow_logs_config: ::core::option::Option<VpcFlowLogsConfig>,
}
/// Request for the `UpdateVpcFlowLogsConfig` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateVpcFlowLogsConfigRequest {
    /// Required. Mask of fields to update. At least one path must be supplied in
    /// this field.
    /// For example, to change the state of the configuration to ENABLED, specify
    /// `update_mask` = `"state"`, and the `vpc_flow_logs_config` would be:
    /// `vpc_flow_logs_config = {      name =      "projects/my-project/locations/global/vpcFlowLogsConfigs/my-config"      state = "ENABLED" }`
    #[prost(message, optional, tag = "1")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Required. Only fields specified in update_mask are updated.
    #[prost(message, optional, tag = "2")]
    pub vpc_flow_logs_config: ::core::option::Option<VpcFlowLogsConfig>,
}
/// Request for the `DeleteVpcFlowLogsConfig` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteVpcFlowLogsConfigRequest {
    /// Required. The resource name of the VpcFlowLogsConfig,
    /// in one of the following formats:
    ///
    /// * For a project-level resource:
    ///   `projects/{project_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`
    ///
    /// * For an organization-level resource:
    ///   `organizations/{organization_id}/locations/global/vpcFlowLogsConfigs/{vpc_flow_logs_config_id}`
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Request for the `QueryOrgVpcFlowLogsConfigs` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct QueryOrgVpcFlowLogsConfigsRequest {
    /// Required. The parent resource of the VpcFlowLogsConfig, specified in
    /// the following format: `projects/{project_id}/locations/global`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Optional. Number of `VpcFlowLogsConfigs` to return.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// Optional. Page token from an earlier query, as returned in
    /// `next_page_token`.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Lists the `VpcFlowLogsConfigs` that match the filter expression.
    /// A filter expression must use the supported \[CEL logic operators\]
    /// (<https://cloud.google.com/vpc/docs/about-flow-logs-records#supported_cel_logic_operators>).
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
}
/// Response for the `QueryVpcFlowLogsConfigs` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryOrgVpcFlowLogsConfigsResponse {
    /// List of VPC Flow Log configurations.
    #[prost(message, repeated, tag = "1")]
    pub vpc_flow_logs_configs: ::prost::alloc::vec::Vec<VpcFlowLogsConfig>,
    /// Page token to fetch the next set of configurations.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached (when querying all locations with `-`).
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request for the `ShowEffectiveFlowLogsConfigs` method.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ShowEffectiveFlowLogsConfigsRequest {
    /// Required. The parent resource of the VpcFlowLogsConfig, specified in
    /// the following format: `projects/{project_id}/locations/global`
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. The resource to get the effective VPC Flow Logs configuration
    /// for. The resource must belong to the same project as the parent. The
    /// resource must be a network, subnetwork, interconnect attachment, VPN
    /// tunnel, or a project.
    #[prost(string, tag = "2")]
    pub resource: ::prost::alloc::string::String,
    /// Optional. Number of `EffectiveVpcFlowLogsConfigs` to return. Default is 30.
    #[prost(int32, tag = "3")]
    pub page_size: i32,
    /// Optional. Page token from an earlier query, as returned in
    /// `next_page_token`.
    #[prost(string, tag = "4")]
    pub page_token: ::prost::alloc::string::String,
    /// Optional. Lists the `EffectiveVpcFlowLogsConfigs` that match the filter
    /// expression. A filter expression must use the supported \[CEL logic
    /// operators\]
    /// (<https://cloud.google.com/vpc/docs/about-flow-logs-records#supported_cel_logic_operators>).
    #[prost(string, tag = "5")]
    pub filter: ::prost::alloc::string::String,
}
/// Response for the `ShowEffectiveFlowLogsConfigs` method.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ShowEffectiveFlowLogsConfigsResponse {
    /// List of Effective Vpc Flow Logs configurations.
    #[prost(message, repeated, tag = "1")]
    pub effective_flow_logs_configs: ::prost::alloc::vec::Vec<
        EffectiveVpcFlowLogsConfig,
    >,
    /// Page token to fetch the next set of configurations.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached (when querying all locations with `-`).
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Generated client implementations.
pub mod vpc_flow_logs_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// The VPC Flow Logs service in the Google Cloud Network Management API provides
    /// configurations that generate Flow Logs. The service and the configuration
    /// resources created using this service are global.
    #[derive(Debug, Clone)]
    pub struct VpcFlowLogsServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl VpcFlowLogsServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> VpcFlowLogsServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> VpcFlowLogsServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            VpcFlowLogsServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Lists all `VpcFlowLogsConfigs` in a given project.
        pub async fn list_vpc_flow_logs_configs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListVpcFlowLogsConfigsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListVpcFlowLogsConfigsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.VpcFlowLogsService/ListVpcFlowLogsConfigs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.VpcFlowLogsService",
                        "ListVpcFlowLogsConfigs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the details of a specific `VpcFlowLogsConfig`.
        pub async fn get_vpc_flow_logs_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetVpcFlowLogsConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::VpcFlowLogsConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.VpcFlowLogsService/GetVpcFlowLogsConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.VpcFlowLogsService",
                        "GetVpcFlowLogsConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new `VpcFlowLogsConfig`.
        /// If a configuration with the exact same settings already exists (even if the
        /// ID is different), the creation fails.
        /// Notes:
        ///
        /// 1. Creating a configuration with `state=DISABLED` will fail
        /// 1. The following fields are not considered as settings for the purpose
        ///   of the check mentioned above, therefore - creating another configuration
        ///   with the same fields but different values for the following fields will
        ///   fail as well:
        ///   * name
        ///   * create_time
        ///   * update_time
        ///   * labels
        ///   * description
        pub async fn create_vpc_flow_logs_config(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateVpcFlowLogsConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.VpcFlowLogsService/CreateVpcFlowLogsConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.VpcFlowLogsService",
                        "CreateVpcFlowLogsConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing `VpcFlowLogsConfig`.
        /// If a configuration with the exact same settings already exists (even if the
        /// ID is different), the creation fails.
        /// Notes:
        ///
        /// 1. Updating a configuration with `state=DISABLED` will fail
        /// 1. The following fields are not considered as settings for the purpose
        ///   of the check mentioned above, therefore - updating another configuration
        ///   with the same fields but different values for the following fields will
        ///   fail as well:
        ///   * name
        ///   * create_time
        ///   * update_time
        ///   * labels
        ///   * description
        pub async fn update_vpc_flow_logs_config(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateVpcFlowLogsConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.VpcFlowLogsService/UpdateVpcFlowLogsConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.VpcFlowLogsService",
                        "UpdateVpcFlowLogsConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a specific `VpcFlowLogsConfig`.
        pub async fn delete_vpc_flow_logs_config(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteVpcFlowLogsConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.VpcFlowLogsService/DeleteVpcFlowLogsConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.VpcFlowLogsService",
                        "DeleteVpcFlowLogsConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// QueryOrgVpcFlowLogsConfigs returns a list of all organization-level VPC
        /// Flow Logs configurations applicable to the specified project.
        pub async fn query_org_vpc_flow_logs_configs(
            &mut self,
            request: impl tonic::IntoRequest<super::QueryOrgVpcFlowLogsConfigsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::QueryOrgVpcFlowLogsConfigsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.VpcFlowLogsService/QueryOrgVpcFlowLogsConfigs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.VpcFlowLogsService",
                        "QueryOrgVpcFlowLogsConfigs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// ShowEffectiveFlowLogsConfigs returns a list of all VPC Flow Logs
        /// configurations applicable to a specified resource.
        pub async fn show_effective_flow_logs_configs(
            &mut self,
            request: impl tonic::IntoRequest<super::ShowEffectiveFlowLogsConfigsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowEffectiveFlowLogsConfigsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.VpcFlowLogsService/ShowEffectiveFlowLogsConfigs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.VpcFlowLogsService",
                        "ShowEffectiveFlowLogsConfigs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated client implementations.
pub mod organization_vpc_flow_logs_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// The VPC Flow Logs organization service in the Google Cloud Network Management
    /// API provides organization level configurations that generate Flow Logs. The
    /// service and the configuration resources created using this service are
    /// global.
    #[derive(Debug, Clone)]
    pub struct OrganizationVpcFlowLogsServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl OrganizationVpcFlowLogsServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> OrganizationVpcFlowLogsServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> OrganizationVpcFlowLogsServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            OrganizationVpcFlowLogsServiceClient::new(
                InterceptedService::new(inner, interceptor),
            )
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Lists all `VpcFlowLogsConfigs` in a given organization.
        pub async fn list_vpc_flow_logs_configs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListVpcFlowLogsConfigsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListVpcFlowLogsConfigsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService/ListVpcFlowLogsConfigs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService",
                        "ListVpcFlowLogsConfigs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets the details of a specific `VpcFlowLogsConfig`.
        pub async fn get_vpc_flow_logs_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetVpcFlowLogsConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::VpcFlowLogsConfig>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService/GetVpcFlowLogsConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService",
                        "GetVpcFlowLogsConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new `VpcFlowLogsConfig`.
        /// If a configuration with the exact same settings already exists (even if the
        /// ID is different), the creation fails.
        /// Notes:
        ///
        /// 1. Creating a configuration with `state=DISABLED` will fail
        /// 1. The following fields are not considered as settings for the purpose
        ///   of the check mentioned above, therefore - creating another configuration
        ///   with the same fields but different values for the following fields will
        ///   fail as well:
        ///   * name
        ///   * create_time
        ///   * update_time
        ///   * labels
        ///   * description
        pub async fn create_vpc_flow_logs_config(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateVpcFlowLogsConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService/CreateVpcFlowLogsConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService",
                        "CreateVpcFlowLogsConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates an existing `VpcFlowLogsConfig`.
        /// If a configuration with the exact same settings already exists (even if the
        /// ID is different), the creation fails.
        /// Notes:
        ///
        /// 1. Updating a configuration with `state=DISABLED` will fail
        /// 1. The following fields are not considered as settings for the purpose
        ///   of the check mentioned above, therefore - updating another configuration
        ///   with the same fields but different values for the following fields will
        ///   fail as well:
        ///   * name
        ///   * create_time
        ///   * update_time
        ///   * labels
        ///   * description
        pub async fn update_vpc_flow_logs_config(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateVpcFlowLogsConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService/UpdateVpcFlowLogsConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService",
                        "UpdateVpcFlowLogsConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a specific `VpcFlowLogsConfig`.
        pub async fn delete_vpc_flow_logs_config(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteVpcFlowLogsConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService/DeleteVpcFlowLogsConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.networkmanagement.v1beta1.OrganizationVpcFlowLogsService",
                        "DeleteVpcFlowLogsConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}
