// This file is @generated by prost-build.
/// A representation of a blockchain node.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BlockchainNode {
    /// Output only. The fully qualified name of the blockchain node.
    /// e.g. `projects/my-project/locations/us-central1/blockchainNodes/my-node`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Output only. The timestamp at which the blockchain node was first created.
    #[prost(message, optional, tag = "2")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The timestamp at which the blockchain node was last updated.
    #[prost(message, optional, tag = "3")]
    pub update_time: ::core::option::Option<::prost_types::Timestamp>,
    /// User-provided key-value pairs.
    #[prost(btree_map = "string, string", tag = "4")]
    pub labels: ::prost::alloc::collections::BTreeMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    /// Immutable. The blockchain type of the node.
    #[prost(enumeration = "blockchain_node::BlockchainType", optional, tag = "5")]
    pub blockchain_type: ::core::option::Option<i32>,
    /// Output only. The connection information used to interact with a blockchain
    /// node.
    #[prost(message, optional, tag = "6")]
    pub connection_info: ::core::option::Option<blockchain_node::ConnectionInfo>,
    /// Output only. A status representing the state of the node.
    #[prost(enumeration = "blockchain_node::State", tag = "8")]
    pub state: i32,
    /// Optional. When true, the node is only accessible via Private Service
    /// Connect; no public endpoints are exposed. Otherwise, the node is only
    /// accessible via public endpoints. Warning: Private Service Connect enabled
    /// nodes may require a manual migration effort to remain compatible with
    /// future versions of the product. If this feature is enabled, you will be
    /// notified of these changes along with any required action to avoid
    /// disruption. See <https://cloud.google.com/vpc/docs/private-service-connect.>
    #[prost(bool, tag = "12")]
    pub private_service_connect_enabled: bool,
    /// Information that is specific to a particular blockchain type.
    #[prost(oneof = "blockchain_node::BlockchainTypeDetails", tags = "7")]
    pub blockchain_type_details: ::core::option::Option<
        blockchain_node::BlockchainTypeDetails,
    >,
}
/// Nested message and enum types in `BlockchainNode`.
pub mod blockchain_node {
    /// The connection information through which to interact with a blockchain
    /// node.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct ConnectionInfo {
        /// Output only. The endpoint information through which to interact with a
        /// blockchain node.
        #[prost(message, optional, tag = "2")]
        pub endpoint_info: ::core::option::Option<connection_info::EndpointInfo>,
        /// Output only. A service attachment that exposes a node, and has the
        /// following format:
        /// projects/{project}/regions/{region}/serviceAttachments/{service_attachment_name}
        #[prost(string, tag = "3")]
        pub service_attachment: ::prost::alloc::string::String,
    }
    /// Nested message and enum types in `ConnectionInfo`.
    pub mod connection_info {
        /// Contains endpoint information through which to interact with a blockchain
        /// node.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct EndpointInfo {
            /// Output only. The assigned URL for the node JSON-RPC API endpoint.
            #[prost(string, tag = "1")]
            pub json_rpc_api_endpoint: ::prost::alloc::string::String,
            /// Output only. The assigned URL for the node WebSockets API endpoint.
            #[prost(string, tag = "2")]
            pub websockets_api_endpoint: ::prost::alloc::string::String,
        }
    }
    /// Ethereum-specific blockchain node details.
    #[derive(Clone, PartialEq, ::prost::Message)]
    pub struct EthereumDetails {
        /// Immutable. The Ethereum environment being accessed.
        #[prost(enumeration = "ethereum_details::Network", optional, tag = "1")]
        pub network: ::core::option::Option<i32>,
        /// Immutable. The type of Ethereum node.
        #[prost(enumeration = "ethereum_details::NodeType", optional, tag = "2")]
        pub node_type: ::core::option::Option<i32>,
        /// Immutable. The execution client
        #[prost(enumeration = "ethereum_details::ExecutionClient", optional, tag = "3")]
        pub execution_client: ::core::option::Option<i32>,
        /// Immutable. The consensus client.
        #[prost(enumeration = "ethereum_details::ConsensusClient", optional, tag = "4")]
        pub consensus_client: ::core::option::Option<i32>,
        /// Immutable. Enables JSON-RPC access to functions in the `admin` namespace.
        /// Defaults to `false`.
        #[prost(bool, optional, tag = "5")]
        pub api_enable_admin: ::core::option::Option<bool>,
        /// Immutable. Enables JSON-RPC access to functions in the `debug` namespace.
        /// Defaults to `false`.
        #[prost(bool, optional, tag = "6")]
        pub api_enable_debug: ::core::option::Option<bool>,
        /// Output only. Ethereum-specific endpoint information.
        #[prost(message, optional, tag = "7")]
        pub additional_endpoints: ::core::option::Option<
            ethereum_details::EthereumEndpoints,
        >,
        /// Configuration for validator-related parameters on the beacon client,
        /// and for any GCP-managed validator client.
        #[prost(message, optional, tag = "10")]
        pub validator_config: ::core::option::Option<ethereum_details::ValidatorConfig>,
        /// Options for the execution client.
        #[prost(oneof = "ethereum_details::ExecutionClientDetails", tags = "8")]
        pub execution_client_details: ::core::option::Option<
            ethereum_details::ExecutionClientDetails,
        >,
    }
    /// Nested message and enum types in `EthereumDetails`.
    pub mod ethereum_details {
        /// Options for the Geth execution client.
        ///
        /// See [Command-line
        /// Options](<https://geth.ethereum.org/docs/fundamentals/command-line-options>)
        /// for more details.
        #[derive(Clone, Copy, PartialEq, ::prost::Message)]
        pub struct GethDetails {
            /// Immutable. Blockchain garbage collection mode.
            #[prost(
                enumeration = "geth_details::GarbageCollectionMode",
                optional,
                tag = "1"
            )]
            pub garbage_collection_mode: ::core::option::Option<i32>,
        }
        /// Nested message and enum types in `GethDetails`.
        pub mod geth_details {
            /// Blockchain garbage collection modes. Only applicable when `NodeType` is
            /// `FULL` or `ARCHIVE`.
            #[derive(
                Clone,
                Copy,
                Debug,
                PartialEq,
                Eq,
                Hash,
                PartialOrd,
                Ord,
                ::prost::Enumeration
            )]
            #[repr(i32)]
            pub enum GarbageCollectionMode {
                /// The garbage collection has not been specified.
                Unspecified = 0,
                /// Configures Geth's garbage collection so that older data not needed
                /// for a full node is deleted. This is the default mode when creating a
                /// full node.
                Full = 1,
                /// Configures Geth's garbage collection so that old data is never
                /// deleted. This is the default mode when creating an archive node. This
                /// value can also be chosen when creating a full node in order to create
                /// a partial/recent archive node. See
                /// [Sync modes](<https://geth.ethereum.org/docs/fundamentals/sync-modes>)
                /// for more details.
                Archive = 2,
            }
            impl GarbageCollectionMode {
                /// 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 {
                        GarbageCollectionMode::Unspecified => {
                            "GARBAGE_COLLECTION_MODE_UNSPECIFIED"
                        }
                        GarbageCollectionMode::Full => "FULL",
                        GarbageCollectionMode::Archive => "ARCHIVE",
                    }
                }
                /// Creates an enum from field names used in the ProtoBuf definition.
                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                    match value {
                        "GARBAGE_COLLECTION_MODE_UNSPECIFIED" => Some(Self::Unspecified),
                        "FULL" => Some(Self::Full),
                        "ARCHIVE" => Some(Self::Archive),
                        _ => None,
                    }
                }
            }
        }
        /// Contains endpoint information specific to Ethereum nodes.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct EthereumEndpoints {
            /// Output only. The assigned URL for the node's Beacon API endpoint.
            #[prost(string, tag = "1")]
            pub beacon_api_endpoint: ::prost::alloc::string::String,
            /// Output only. The assigned URL for the node's Beacon Prometheus metrics
            /// endpoint. See [Prometheus
            /// Metrics](<https://lighthouse-book.sigmaprime.io/advanced_metrics.html>)
            /// for more details.
            #[prost(string, tag = "2")]
            pub beacon_prometheus_metrics_api_endpoint: ::prost::alloc::string::String,
            /// Output only. The assigned URL for the node's execution client's
            /// Prometheus metrics endpoint.
            #[prost(string, tag = "3")]
            pub execution_client_prometheus_metrics_api_endpoint: ::prost::alloc::string::String,
        }
        /// Configuration for validator-related parameters on the beacon client,
        /// and for any GCP-managed validator client.
        #[derive(Clone, PartialEq, ::prost::Message)]
        pub struct ValidatorConfig {
            /// URLs for MEV-relay services to use for block building. When set, a
            /// GCP-managed MEV-boost service is configured on the beacon client.
            #[prost(string, repeated, tag = "1")]
            pub mev_relay_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
            /// Immutable. When true, deploys a GCP-managed validator client alongside
            /// the beacon client.
            #[prost(bool, tag = "2")]
            pub managed_validator_client: bool,
            /// An Ethereum address which the beacon client will send fee rewards to if
            /// no recipient is configured in the validator client.
            ///
            /// See <https://lighthouse-book.sigmaprime.io/suggested-fee-recipient.html>
            /// or <https://docs.prylabs.network/docs/execution-node/fee-recipient> for
            /// examples of how this is used.
            ///
            /// Note that while this is often described as "suggested", as we run the
            /// execution node we can trust the execution node, and therefore this is
            /// considered enforced.
            #[prost(string, optional, tag = "3")]
            pub beacon_fee_recipient: ::core::option::Option<
                ::prost::alloc::string::String,
            >,
        }
        /// The Ethereum environment being accessed.
        ///
        /// See [Networks](<https://ethereum.org/en/developers/docs/networks>)
        /// for more details.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum Network {
            /// The network has not been specified, but should be.
            Unspecified = 0,
            /// The Ethereum Mainnet.
            Mainnet = 1,
            /// Deprecated: The Ethereum Testnet based on Goerli protocol. Please
            /// use another test network.
            TestnetGoerliPrater = 2,
            /// The Ethereum Testnet based on Sepolia/Bepolia protocol.
            /// See <https://github.com/eth-clients/sepolia.>
            TestnetSepolia = 3,
            /// The Ethereum Testnet based on Holesky specification.
            /// See <https://github.com/eth-clients/holesky.>
            TestnetHolesky = 4,
        }
        impl Network {
            /// 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 {
                    Network::Unspecified => "NETWORK_UNSPECIFIED",
                    Network::Mainnet => "MAINNET",
                    Network::TestnetGoerliPrater => "TESTNET_GOERLI_PRATER",
                    Network::TestnetSepolia => "TESTNET_SEPOLIA",
                    Network::TestnetHolesky => "TESTNET_HOLESKY",
                }
            }
            /// 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_UNSPECIFIED" => Some(Self::Unspecified),
                    "MAINNET" => Some(Self::Mainnet),
                    "TESTNET_GOERLI_PRATER" => Some(Self::TestnetGoerliPrater),
                    "TESTNET_SEPOLIA" => Some(Self::TestnetSepolia),
                    "TESTNET_HOLESKY" => Some(Self::TestnetHolesky),
                    _ => None,
                }
            }
        }
        /// The type of Ethereum node.
        ///
        /// See
        /// [Node
        /// Types](<https://ethereum.org/en/developers/docs/nodes-and-clients/#node-types>)
        /// for more details.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum NodeType {
            /// Node type has not been specified, but should be.
            Unspecified = 0,
            /// An Ethereum node that only downloads Ethereum block headers.
            Light = 1,
            /// Keeps a complete copy of the blockchain data, and contributes to the
            /// network by receiving, validating, and forwarding transactions.
            Full = 2,
            /// Holds the same data as full node as well as all of the blockchain's
            /// history state data dating back to the Genesis Block.
            Archive = 3,
        }
        impl NodeType {
            /// 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 {
                    NodeType::Unspecified => "NODE_TYPE_UNSPECIFIED",
                    NodeType::Light => "LIGHT",
                    NodeType::Full => "FULL",
                    NodeType::Archive => "ARCHIVE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "NODE_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                    "LIGHT" => Some(Self::Light),
                    "FULL" => Some(Self::Full),
                    "ARCHIVE" => Some(Self::Archive),
                    _ => None,
                }
            }
        }
        /// The execution client (i.e., Execution Engine or EL client) listens to new
        /// transactions broadcast in the network, executes them in EVM, and holds
        /// the latest state and database of all current Ethereum data.
        ///
        /// See
        /// [What are nodes and
        /// clients?](<https://ethereum.org/en/developers/docs/nodes-and-clients/#what-are-nodes-and-clients>)
        /// for more details.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ExecutionClient {
            /// Execution client has not been specified, but should be.
            Unspecified = 0,
            /// Official Go implementation of the Ethereum protocol.
            /// See [go-ethereum](<https://geth.ethereum.org/>) for details.
            Geth = 1,
            /// An implementation of Ethereum (execution client), on the efficiency
            /// frontier, written in Go. See [Erigon on
            /// GitHub](<https://github.com/ledgerwatch/erigon>) for details.
            Erigon = 2,
        }
        impl ExecutionClient {
            /// 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 {
                    ExecutionClient::Unspecified => "EXECUTION_CLIENT_UNSPECIFIED",
                    ExecutionClient::Geth => "GETH",
                    ExecutionClient::Erigon => "ERIGON",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "EXECUTION_CLIENT_UNSPECIFIED" => Some(Self::Unspecified),
                    "GETH" => Some(Self::Geth),
                    "ERIGON" => Some(Self::Erigon),
                    _ => None,
                }
            }
        }
        /// The consensus client (also referred to as beacon node or CL client)
        /// implements the proof-of-stake consensus algorithm, which enables the
        /// network to achieve agreement based on validated data from the
        /// execution client.
        ///
        /// See
        /// [What are nodes and
        /// clients?](<https://ethereum.org/en/developers/docs/nodes-and-clients/#what-are-nodes-and-clients>)
        /// for more details.
        #[derive(
            Clone,
            Copy,
            Debug,
            PartialEq,
            Eq,
            Hash,
            PartialOrd,
            Ord,
            ::prost::Enumeration
        )]
        #[repr(i32)]
        pub enum ConsensusClient {
            /// Consensus client has not been specified, but should be.
            Unspecified = 0,
            /// Consensus client implementation written in Rust, maintained by Sigma
            /// Prime. See [Lighthouse - Sigma
            /// Prime](<https://lighthouse.sigmaprime.io/>) for details.
            Lighthouse = 1,
        }
        impl ConsensusClient {
            /// 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 {
                    ConsensusClient::Unspecified => "CONSENSUS_CLIENT_UNSPECIFIED",
                    ConsensusClient::Lighthouse => "LIGHTHOUSE",
                }
            }
            /// Creates an enum from field names used in the ProtoBuf definition.
            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
                match value {
                    "CONSENSUS_CLIENT_UNSPECIFIED" => Some(Self::Unspecified),
                    "LIGHTHOUSE" => Some(Self::Lighthouse),
                    _ => None,
                }
            }
        }
        /// Options for the execution client.
        #[derive(Clone, Copy, PartialEq, ::prost::Oneof)]
        pub enum ExecutionClientDetails {
            /// Details for the Geth execution client.
            #[prost(message, tag = "8")]
            GethDetails(GethDetails),
        }
    }
    /// The blockchain type of the node.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum BlockchainType {
        /// Blockchain type has not been specified, but should be.
        Unspecified = 0,
        /// The blockchain type is Ethereum.
        Ethereum = 1,
    }
    impl BlockchainType {
        /// 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 {
                BlockchainType::Unspecified => "BLOCKCHAIN_TYPE_UNSPECIFIED",
                BlockchainType::Ethereum => "ETHEREUM",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "BLOCKCHAIN_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
                "ETHEREUM" => Some(Self::Ethereum),
                _ => None,
            }
        }
    }
    /// All possible states for a given blockchain node.
    #[derive(
        Clone,
        Copy,
        Debug,
        PartialEq,
        Eq,
        Hash,
        PartialOrd,
        Ord,
        ::prost::Enumeration
    )]
    #[repr(i32)]
    pub enum State {
        /// The state has not been specified.
        Unspecified = 0,
        /// The node has been requested and is in the process of being created.
        Creating = 1,
        /// The existing node is undergoing deletion, but is not yet finished.
        Deleting = 2,
        /// The node is running and ready for use.
        Running = 4,
        /// The node is in an unexpected or errored state.
        Error = 5,
        /// The node is currently being updated.
        Updating = 6,
        /// The node is currently being repaired.
        Repairing = 7,
        /// The node is currently being reconciled.
        Reconciling = 8,
        /// The node is syncing, which is the process by which it obtains the latest
        /// block and current global state.
        Syncing = 9,
    }
    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 {
                State::Unspecified => "STATE_UNSPECIFIED",
                State::Creating => "CREATING",
                State::Deleting => "DELETING",
                State::Running => "RUNNING",
                State::Error => "ERROR",
                State::Updating => "UPDATING",
                State::Repairing => "REPAIRING",
                State::Reconciling => "RECONCILING",
                State::Syncing => "SYNCING",
            }
        }
        /// 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),
                "CREATING" => Some(Self::Creating),
                "DELETING" => Some(Self::Deleting),
                "RUNNING" => Some(Self::Running),
                "ERROR" => Some(Self::Error),
                "UPDATING" => Some(Self::Updating),
                "REPAIRING" => Some(Self::Repairing),
                "RECONCILING" => Some(Self::Reconciling),
                "SYNCING" => Some(Self::Syncing),
                _ => None,
            }
        }
    }
    /// Information that is specific to a particular blockchain type.
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum BlockchainTypeDetails {
        /// Ethereum-specific blockchain node details.
        #[prost(message, tag = "7")]
        EthereumDetails(EthereumDetails),
    }
}
/// Message for requesting list of blockchain nodes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBlockchainNodesRequest {
    /// Required. Parent value for `ListNodesRequest`.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Requested page size. Server may return fewer items than requested.
    /// If unspecified, server will pick an appropriate default.
    #[prost(int32, tag = "2")]
    pub page_size: i32,
    /// A token identifying a page of results the server should return.
    #[prost(string, tag = "3")]
    pub page_token: ::prost::alloc::string::String,
    /// Filtering results.
    #[prost(string, tag = "4")]
    pub filter: ::prost::alloc::string::String,
    /// Hint for how to order the results.
    #[prost(string, tag = "5")]
    pub order_by: ::prost::alloc::string::String,
}
/// Message for response to listing blockchain nodes.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListBlockchainNodesResponse {
    /// The list of nodes
    #[prost(message, repeated, tag = "1")]
    pub blockchain_nodes: ::prost::alloc::vec::Vec<BlockchainNode>,
    /// A token identifying a page of results the server should return.
    #[prost(string, tag = "2")]
    pub next_page_token: ::prost::alloc::string::String,
    /// Locations that could not be reached.
    #[prost(string, repeated, tag = "3")]
    pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Message for getting a blockchain node.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetBlockchainNodeRequest {
    /// Required. The fully qualified name of the blockchain node to fetch.
    /// e.g. `projects/my-project/locations/us-central1/blockchainNodes/my-node`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
}
/// Message for creating a blockchain node.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CreateBlockchainNodeRequest {
    /// Required. Value for parent.
    #[prost(string, tag = "1")]
    pub parent: ::prost::alloc::string::String,
    /// Required. ID of the requesting object.
    #[prost(string, tag = "2")]
    pub blockchain_node_id: ::prost::alloc::string::String,
    /// Required. The resource being created.
    #[prost(message, optional, tag = "3")]
    pub blockchain_node: ::core::option::Option<BlockchainNode>,
    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[prost(string, tag = "4")]
    pub request_id: ::prost::alloc::string::String,
}
/// Message for updating a blockchain node.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateBlockchainNodeRequest {
    /// Required. Field mask is used to specify the fields to be overwritten in the
    /// Blockchain node resource by the update.
    /// The fields specified in the `update_mask` are relative to the resource, not
    /// the full request. A field will be overwritten if it is in the mask. If the
    /// user does not provide a mask then all fields will be overwritten.
    #[prost(message, optional, tag = "1")]
    pub update_mask: ::core::option::Option<::prost_types::FieldMask>,
    /// Required. The resource being updated.
    #[prost(message, optional, tag = "2")]
    pub blockchain_node: ::core::option::Option<BlockchainNode>,
    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes since the first request.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[prost(string, tag = "3")]
    pub request_id: ::prost::alloc::string::String,
}
/// Message for deleting a blockchain node.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DeleteBlockchainNodeRequest {
    /// Required. The fully qualified name of the blockchain node to delete.
    /// e.g. `projects/my-project/locations/us-central1/blockchainNodes/my-node`.
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    /// Optional. An optional request ID to identify requests. Specify a unique
    /// request ID so that if you must retry your request, the server will know to
    /// ignore the request if it has already been completed. The server will
    /// guarantee that for at least 60 minutes after the first request.
    ///
    /// For example, consider a situation where you make an initial request and
    /// the request times out. If you make the request again with the same request
    /// ID, the server can check if original operation with the same request ID
    /// was received, and if so, will ignore the second request. This prevents
    /// clients from accidentally creating duplicate commitments.
    ///
    /// The request ID must be a valid UUID with the exception that zero UUID is
    /// not supported (00000000-0000-0000-0000-000000000000).
    #[prost(string, tag = "2")]
    pub request_id: ::prost::alloc::string::String,
}
/// Represents the metadata of the long-running operation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    #[prost(message, optional, tag = "1")]
    pub create_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. The time the operation finished running.
    #[prost(message, optional, tag = "2")]
    pub end_time: ::core::option::Option<::prost_types::Timestamp>,
    /// Output only. Server-defined resource path for the target of the operation.
    #[prost(string, tag = "3")]
    pub target: ::prost::alloc::string::String,
    /// Output only. Name of the verb executed by the operation.
    #[prost(string, tag = "4")]
    pub verb: ::prost::alloc::string::String,
    /// Output only. Human-readable status of the operation, if any.
    #[prost(string, tag = "5")]
    pub status_message: ::prost::alloc::string::String,
    /// Output only. Identifies whether the user has requested cancellation
    /// of the operation. Operations that have been cancelled successfully
    /// have `[Operation.error][]` value with a
    /// `[google.rpc.Status.code][google.rpc.Status.code]` of `1`, corresponding to
    /// `Code.CANCELLED`.
    #[prost(bool, tag = "6")]
    pub requested_cancellation: bool,
    /// Output only. API version used to start the operation.
    #[prost(string, tag = "7")]
    pub api_version: ::prost::alloc::string::String,
}
/// Generated client implementations.
pub mod blockchain_node_engine_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// This service is the control plane API for Blockchain Node Engine,
    /// and can be used to create, read, and delete blockchain nodes.
    #[derive(Debug, Clone)]
    pub struct BlockchainNodeEngineClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> BlockchainNodeEngineClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        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,
        ) -> BlockchainNodeEngineClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            BlockchainNodeEngineClient::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 blockchain nodes in a given project and location.
        pub async fn list_blockchain_nodes(
            &mut self,
            request: impl tonic::IntoRequest<super::ListBlockchainNodesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListBlockchainNodesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine/ListBlockchainNodes",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine",
                        "ListBlockchainNodes",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Gets details of a single blockchain node.
        pub async fn get_blockchain_node(
            &mut self,
            request: impl tonic::IntoRequest<super::GetBlockchainNodeRequest>,
        ) -> std::result::Result<tonic::Response<super::BlockchainNode>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine/GetBlockchainNode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine",
                        "GetBlockchainNode",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Creates a new blockchain node in a given project and location.
        pub async fn create_blockchain_node(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateBlockchainNodeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine/CreateBlockchainNode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine",
                        "CreateBlockchainNode",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Updates the parameters of a single blockchain node.
        pub async fn update_blockchain_node(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateBlockchainNodeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine/UpdateBlockchainNode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine",
                        "UpdateBlockchainNode",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Deletes a single blockchain node.
        pub async fn delete_blockchain_node(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteBlockchainNodeRequest>,
        ) -> std::result::Result<
            tonic::Response<super::super::super::super::longrunning::Operation>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine/DeleteBlockchainNode",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "google.cloud.blockchainnodeengine.v1.BlockchainNodeEngine",
                        "DeleteBlockchainNode",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
    }
}