google_cloud_blockchainnodeengine_v1/

model.rs

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#![allow(rustdoc::bare_urls)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::invalid_html_tags)]
#![allow(rustdoc::redundant_explicit_links)]
#![no_implicit_prelude]
extern crate async_trait;
extern crate bytes;
extern crate gaxi;
extern crate google_cloud_gax;
extern crate google_cloud_location;
extern crate google_cloud_longrunning;
extern crate google_cloud_lro;
extern crate serde;
extern crate serde_json;
extern crate serde_with;
extern crate std;
extern crate tracing;
extern crate wkt;

mod debug;
mod deserialize;
mod serialize;

/// A representation of a blockchain node.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct BlockchainNode {
    /// Output only. The fully qualified name of the blockchain node.
    /// e.g. `projects/my-project/locations/us-central1/blockchainNodes/my-node`.
    pub name: std::string::String,

    /// Output only. The timestamp at which the blockchain node was first created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The timestamp at which the blockchain node was last updated.
    pub update_time: std::option::Option<wkt::Timestamp>,

    /// User-provided key-value pairs.
    pub labels: std::collections::HashMap<std::string::String, std::string::String>,

    /// Immutable. The blockchain type of the node.
    pub blockchain_type: std::option::Option<crate::model::blockchain_node::BlockchainType>,

    /// Output only. The connection information used to interact with a blockchain
    /// node.
    pub connection_info: std::option::Option<crate::model::blockchain_node::ConnectionInfo>,

    /// Output only. A status representing the state of the node.
    pub state: crate::model::blockchain_node::State,

    /// 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: These nodes are deprecated,
    /// please use public endpoints instead.
    #[deprecated]
    pub private_service_connect_enabled: bool,

    /// Information that is specific to a particular blockchain type.
    pub blockchain_type_details:
        std::option::Option<crate::model::blockchain_node::BlockchainTypeDetails>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl BlockchainNode {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::BlockchainNode::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let blockchain_node_id = "blockchain_node_id";
    /// let x = BlockchainNode::new().set_name(format!("projects/{project_id}/locations/{location_id}/blockchainNodes/{blockchain_node_id}"));
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [create_time][crate::model::BlockchainNode::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use wkt::Timestamp;
    /// let x = BlockchainNode::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::BlockchainNode::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use wkt::Timestamp;
    /// let x = BlockchainNode::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = BlockchainNode::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [update_time][crate::model::BlockchainNode::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use wkt::Timestamp;
    /// let x = BlockchainNode::new().set_update_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_update_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_time][crate::model::BlockchainNode::update_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use wkt::Timestamp;
    /// let x = BlockchainNode::new().set_or_clear_update_time(Some(Timestamp::default()/* use setters */));
    /// let x = BlockchainNode::new().set_or_clear_update_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_update_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.update_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [labels][crate::model::BlockchainNode::labels].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// let x = BlockchainNode::new().set_labels([
    ///     ("key0", "abc"),
    ///     ("key1", "xyz"),
    /// ]);
    /// ```
    pub fn set_labels<T, K, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = (K, V)>,
        K: std::convert::Into<std::string::String>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.labels = v.into_iter().map(|(k, v)| (k.into(), v.into())).collect();
        self
    }

    /// Sets the value of [blockchain_type][crate::model::BlockchainNode::blockchain_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::BlockchainType;
    /// let x0 = BlockchainNode::new().set_blockchain_type(BlockchainType::Ethereum);
    /// ```
    pub fn set_blockchain_type<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::blockchain_node::BlockchainType>,
    {
        self.blockchain_type = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [blockchain_type][crate::model::BlockchainNode::blockchain_type].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::BlockchainType;
    /// let x0 = BlockchainNode::new().set_or_clear_blockchain_type(Some(BlockchainType::Ethereum));
    /// let x_none = BlockchainNode::new().set_or_clear_blockchain_type(None::<BlockchainType>);
    /// ```
    pub fn set_or_clear_blockchain_type<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::blockchain_node::BlockchainType>,
    {
        self.blockchain_type = v.map(|x| x.into());
        self
    }

    /// Sets the value of [connection_info][crate::model::BlockchainNode::connection_info].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ConnectionInfo;
    /// let x = BlockchainNode::new().set_connection_info(ConnectionInfo::default()/* use setters */);
    /// ```
    pub fn set_connection_info<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::blockchain_node::ConnectionInfo>,
    {
        self.connection_info = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [connection_info][crate::model::BlockchainNode::connection_info].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ConnectionInfo;
    /// let x = BlockchainNode::new().set_or_clear_connection_info(Some(ConnectionInfo::default()/* use setters */));
    /// let x = BlockchainNode::new().set_or_clear_connection_info(None::<ConnectionInfo>);
    /// ```
    pub fn set_or_clear_connection_info<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::blockchain_node::ConnectionInfo>,
    {
        self.connection_info = v.map(|x| x.into());
        self
    }

    /// Sets the value of [state][crate::model::BlockchainNode::state].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::State;
    /// let x0 = BlockchainNode::new().set_state(State::Creating);
    /// let x1 = BlockchainNode::new().set_state(State::Deleting);
    /// let x2 = BlockchainNode::new().set_state(State::Running);
    /// ```
    pub fn set_state<T: std::convert::Into<crate::model::blockchain_node::State>>(
        mut self,
        v: T,
    ) -> Self {
        self.state = v.into();
        self
    }

    /// Sets the value of [private_service_connect_enabled][crate::model::BlockchainNode::private_service_connect_enabled].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// let x = BlockchainNode::new().set_private_service_connect_enabled(true);
    /// ```
    #[deprecated]
    pub fn set_private_service_connect_enabled<T: std::convert::Into<bool>>(
        mut self,
        v: T,
    ) -> Self {
        self.private_service_connect_enabled = v.into();
        self
    }

    /// Sets the value of [blockchain_type_details][crate::model::BlockchainNode::blockchain_type_details].
    ///
    /// Note that all the setters affecting `blockchain_type_details` are mutually
    /// exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
    /// let x = BlockchainNode::new().set_blockchain_type_details(Some(
    ///     google_cloud_blockchainnodeengine_v1::model::blockchain_node::BlockchainTypeDetails::EthereumDetails(EthereumDetails::default().into())));
    /// ```
    pub fn set_blockchain_type_details<
        T: std::convert::Into<
                std::option::Option<crate::model::blockchain_node::BlockchainTypeDetails>,
            >,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.blockchain_type_details = v.into();
        self
    }

    /// The value of [blockchain_type_details][crate::model::BlockchainNode::blockchain_type_details]
    /// if it holds a `EthereumDetails`, `None` if the field is not set or
    /// holds a different branch.
    pub fn ethereum_details(
        &self,
    ) -> std::option::Option<&std::boxed::Box<crate::model::blockchain_node::EthereumDetails>> {
        #[allow(unreachable_patterns)]
        self.blockchain_type_details.as_ref().and_then(|v| match v {
            crate::model::blockchain_node::BlockchainTypeDetails::EthereumDetails(v) => {
                std::option::Option::Some(v)
            }
            _ => std::option::Option::None,
        })
    }

    /// Sets the value of [blockchain_type_details][crate::model::BlockchainNode::blockchain_type_details]
    /// to hold a `EthereumDetails`.
    ///
    /// Note that all the setters affecting `blockchain_type_details` are
    /// mutually exclusive.
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
    /// let x = BlockchainNode::new().set_ethereum_details(EthereumDetails::default()/* use setters */);
    /// assert!(x.ethereum_details().is_some());
    /// ```
    pub fn set_ethereum_details<
        T: std::convert::Into<std::boxed::Box<crate::model::blockchain_node::EthereumDetails>>,
    >(
        mut self,
        v: T,
    ) -> Self {
        self.blockchain_type_details = std::option::Option::Some(
            crate::model::blockchain_node::BlockchainTypeDetails::EthereumDetails(v.into()),
        );
        self
    }
}

impl wkt::message::Message for BlockchainNode {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.blockchainnodeengine.v1.BlockchainNode"
    }
}

/// Defines additional types related to [BlockchainNode].
pub mod blockchain_node {
    #[allow(unused_imports)]
    use super::*;

    /// The connection information through which to interact with a blockchain
    /// node.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct ConnectionInfo {
        /// Output only. The endpoint information through which to interact with a
        /// blockchain node.
        pub endpoint_info:
            std::option::Option<crate::model::blockchain_node::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}
        pub service_attachment: std::string::String,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl ConnectionInfo {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [endpoint_info][crate::model::blockchain_node::ConnectionInfo::endpoint_info].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ConnectionInfo;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::connection_info::EndpointInfo;
        /// let x = ConnectionInfo::new().set_endpoint_info(EndpointInfo::default()/* use setters */);
        /// ```
        pub fn set_endpoint_info<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::connection_info::EndpointInfo>,
        {
            self.endpoint_info = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [endpoint_info][crate::model::blockchain_node::ConnectionInfo::endpoint_info].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ConnectionInfo;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::connection_info::EndpointInfo;
        /// let x = ConnectionInfo::new().set_or_clear_endpoint_info(Some(EndpointInfo::default()/* use setters */));
        /// let x = ConnectionInfo::new().set_or_clear_endpoint_info(None::<EndpointInfo>);
        /// ```
        pub fn set_or_clear_endpoint_info<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::connection_info::EndpointInfo>,
        {
            self.endpoint_info = v.map(|x| x.into());
            self
        }

        /// Sets the value of [service_attachment][crate::model::blockchain_node::ConnectionInfo::service_attachment].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ConnectionInfo;
        /// let x = ConnectionInfo::new().set_service_attachment("example");
        /// ```
        pub fn set_service_attachment<T: std::convert::Into<std::string::String>>(
            mut self,
            v: T,
        ) -> Self {
            self.service_attachment = v.into();
            self
        }
    }

    impl wkt::message::Message for ConnectionInfo {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.blockchainnodeengine.v1.BlockchainNode.ConnectionInfo"
        }
    }

    /// Defines additional types related to [ConnectionInfo].
    pub mod connection_info {
        #[allow(unused_imports)]
        use super::*;

        /// Contains endpoint information through which to interact with a blockchain
        /// node.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct EndpointInfo {
            /// Output only. The assigned URL for the node JSON-RPC API endpoint.
            pub json_rpc_api_endpoint: std::string::String,

            /// Output only. The assigned URL for the node WebSockets API endpoint.
            pub websockets_api_endpoint: std::string::String,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl EndpointInfo {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [json_rpc_api_endpoint][crate::model::blockchain_node::connection_info::EndpointInfo::json_rpc_api_endpoint].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::connection_info::EndpointInfo;
            /// let x = EndpointInfo::new().set_json_rpc_api_endpoint("example");
            /// ```
            pub fn set_json_rpc_api_endpoint<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.json_rpc_api_endpoint = v.into();
                self
            }

            /// Sets the value of [websockets_api_endpoint][crate::model::blockchain_node::connection_info::EndpointInfo::websockets_api_endpoint].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::connection_info::EndpointInfo;
            /// let x = EndpointInfo::new().set_websockets_api_endpoint("example");
            /// ```
            pub fn set_websockets_api_endpoint<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.websockets_api_endpoint = v.into();
                self
            }
        }

        impl wkt::message::Message for EndpointInfo {
            fn typename() -> &'static str {
                "type.googleapis.com/google.cloud.blockchainnodeengine.v1.BlockchainNode.ConnectionInfo.EndpointInfo"
            }
        }
    }

    /// Ethereum-specific blockchain node details.
    #[derive(Clone, Default, PartialEq)]
    #[non_exhaustive]
    pub struct EthereumDetails {
        /// Immutable. The Ethereum environment being accessed.
        pub network: std::option::Option<crate::model::blockchain_node::ethereum_details::Network>,

        /// Immutable. The type of Ethereum node.
        pub node_type:
            std::option::Option<crate::model::blockchain_node::ethereum_details::NodeType>,

        /// Immutable. The execution client
        pub execution_client:
            std::option::Option<crate::model::blockchain_node::ethereum_details::ExecutionClient>,

        /// Immutable. The consensus client.
        pub consensus_client:
            std::option::Option<crate::model::blockchain_node::ethereum_details::ConsensusClient>,

        /// Immutable. Enables JSON-RPC access to functions in the `admin` namespace.
        /// Defaults to `false`.
        pub api_enable_admin: std::option::Option<bool>,

        /// Immutable. Enables JSON-RPC access to functions in the `debug` namespace.
        /// Defaults to `false`.
        pub api_enable_debug: std::option::Option<bool>,

        /// Output only. Ethereum-specific endpoint information.
        pub additional_endpoints:
            std::option::Option<crate::model::blockchain_node::ethereum_details::EthereumEndpoints>,

        /// Configuration for validator-related parameters on the beacon client,
        /// and for any GCP-managed validator client.
        pub validator_config:
            std::option::Option<crate::model::blockchain_node::ethereum_details::ValidatorConfig>,

        /// Options for the execution client.
        pub execution_client_details: std::option::Option<
            crate::model::blockchain_node::ethereum_details::ExecutionClientDetails,
        >,

        pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
    }

    impl EthereumDetails {
        /// Creates a new default instance.
        pub fn new() -> Self {
            std::default::Default::default()
        }

        /// Sets the value of [network][crate::model::blockchain_node::EthereumDetails::network].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::Network;
        /// let x0 = EthereumDetails::new().set_network(Network::Mainnet);
        /// let x1 = EthereumDetails::new().set_network(Network::TestnetSepolia);
        /// let x2 = EthereumDetails::new().set_network(Network::TestnetHolesky);
        /// ```
        pub fn set_network<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::Network>,
        {
            self.network = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [network][crate::model::blockchain_node::EthereumDetails::network].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::Network;
        /// let x0 = EthereumDetails::new().set_or_clear_network(Some(Network::Mainnet));
        /// let x1 = EthereumDetails::new().set_or_clear_network(Some(Network::TestnetSepolia));
        /// let x2 = EthereumDetails::new().set_or_clear_network(Some(Network::TestnetHolesky));
        /// let x_none = EthereumDetails::new().set_or_clear_network(None::<Network>);
        /// ```
        pub fn set_or_clear_network<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::Network>,
        {
            self.network = v.map(|x| x.into());
            self
        }

        /// Sets the value of [node_type][crate::model::blockchain_node::EthereumDetails::node_type].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::NodeType;
        /// let x0 = EthereumDetails::new().set_node_type(NodeType::Light);
        /// let x1 = EthereumDetails::new().set_node_type(NodeType::Full);
        /// let x2 = EthereumDetails::new().set_node_type(NodeType::Archive);
        /// ```
        pub fn set_node_type<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::NodeType>,
        {
            self.node_type = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [node_type][crate::model::blockchain_node::EthereumDetails::node_type].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::NodeType;
        /// let x0 = EthereumDetails::new().set_or_clear_node_type(Some(NodeType::Light));
        /// let x1 = EthereumDetails::new().set_or_clear_node_type(Some(NodeType::Full));
        /// let x2 = EthereumDetails::new().set_or_clear_node_type(Some(NodeType::Archive));
        /// let x_none = EthereumDetails::new().set_or_clear_node_type(None::<NodeType>);
        /// ```
        pub fn set_or_clear_node_type<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::NodeType>,
        {
            self.node_type = v.map(|x| x.into());
            self
        }

        /// Sets the value of [execution_client][crate::model::blockchain_node::EthereumDetails::execution_client].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ExecutionClient;
        /// let x0 = EthereumDetails::new().set_execution_client(ExecutionClient::Geth);
        /// let x1 = EthereumDetails::new().set_execution_client(ExecutionClient::Erigon);
        /// ```
        pub fn set_execution_client<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::ExecutionClient>,
        {
            self.execution_client = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [execution_client][crate::model::blockchain_node::EthereumDetails::execution_client].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ExecutionClient;
        /// let x0 = EthereumDetails::new().set_or_clear_execution_client(Some(ExecutionClient::Geth));
        /// let x1 = EthereumDetails::new().set_or_clear_execution_client(Some(ExecutionClient::Erigon));
        /// let x_none = EthereumDetails::new().set_or_clear_execution_client(None::<ExecutionClient>);
        /// ```
        pub fn set_or_clear_execution_client<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::ExecutionClient>,
        {
            self.execution_client = v.map(|x| x.into());
            self
        }

        /// Sets the value of [consensus_client][crate::model::blockchain_node::EthereumDetails::consensus_client].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ConsensusClient;
        /// let x0 = EthereumDetails::new().set_consensus_client(ConsensusClient::Lighthouse);
        /// ```
        pub fn set_consensus_client<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::ConsensusClient>,
        {
            self.consensus_client = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [consensus_client][crate::model::blockchain_node::EthereumDetails::consensus_client].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ConsensusClient;
        /// let x0 = EthereumDetails::new().set_or_clear_consensus_client(Some(ConsensusClient::Lighthouse));
        /// let x_none = EthereumDetails::new().set_or_clear_consensus_client(None::<ConsensusClient>);
        /// ```
        pub fn set_or_clear_consensus_client<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::ConsensusClient>,
        {
            self.consensus_client = v.map(|x| x.into());
            self
        }

        /// Sets the value of [api_enable_admin][crate::model::blockchain_node::EthereumDetails::api_enable_admin].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// let x = EthereumDetails::new().set_api_enable_admin(true);
        /// ```
        pub fn set_api_enable_admin<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.api_enable_admin = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [api_enable_admin][crate::model::blockchain_node::EthereumDetails::api_enable_admin].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// let x = EthereumDetails::new().set_or_clear_api_enable_admin(Some(false));
        /// let x = EthereumDetails::new().set_or_clear_api_enable_admin(None::<bool>);
        /// ```
        pub fn set_or_clear_api_enable_admin<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.api_enable_admin = v.map(|x| x.into());
            self
        }

        /// Sets the value of [api_enable_debug][crate::model::blockchain_node::EthereumDetails::api_enable_debug].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// let x = EthereumDetails::new().set_api_enable_debug(true);
        /// ```
        pub fn set_api_enable_debug<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.api_enable_debug = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [api_enable_debug][crate::model::blockchain_node::EthereumDetails::api_enable_debug].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// let x = EthereumDetails::new().set_or_clear_api_enable_debug(Some(false));
        /// let x = EthereumDetails::new().set_or_clear_api_enable_debug(None::<bool>);
        /// ```
        pub fn set_or_clear_api_enable_debug<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<bool>,
        {
            self.api_enable_debug = v.map(|x| x.into());
            self
        }

        /// Sets the value of [additional_endpoints][crate::model::blockchain_node::EthereumDetails::additional_endpoints].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::EthereumEndpoints;
        /// let x = EthereumDetails::new().set_additional_endpoints(EthereumEndpoints::default()/* use setters */);
        /// ```
        pub fn set_additional_endpoints<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<
                    crate::model::blockchain_node::ethereum_details::EthereumEndpoints,
                >,
        {
            self.additional_endpoints = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [additional_endpoints][crate::model::blockchain_node::EthereumDetails::additional_endpoints].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::EthereumEndpoints;
        /// let x = EthereumDetails::new().set_or_clear_additional_endpoints(Some(EthereumEndpoints::default()/* use setters */));
        /// let x = EthereumDetails::new().set_or_clear_additional_endpoints(None::<EthereumEndpoints>);
        /// ```
        pub fn set_or_clear_additional_endpoints<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<
                    crate::model::blockchain_node::ethereum_details::EthereumEndpoints,
                >,
        {
            self.additional_endpoints = v.map(|x| x.into());
            self
        }

        /// Sets the value of [validator_config][crate::model::blockchain_node::EthereumDetails::validator_config].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ValidatorConfig;
        /// let x = EthereumDetails::new().set_validator_config(ValidatorConfig::default()/* use setters */);
        /// ```
        pub fn set_validator_config<T>(mut self, v: T) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::ValidatorConfig>,
        {
            self.validator_config = std::option::Option::Some(v.into());
            self
        }

        /// Sets or clears the value of [validator_config][crate::model::blockchain_node::EthereumDetails::validator_config].
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ValidatorConfig;
        /// let x = EthereumDetails::new().set_or_clear_validator_config(Some(ValidatorConfig::default()/* use setters */));
        /// let x = EthereumDetails::new().set_or_clear_validator_config(None::<ValidatorConfig>);
        /// ```
        pub fn set_or_clear_validator_config<T>(mut self, v: std::option::Option<T>) -> Self
        where
            T: std::convert::Into<crate::model::blockchain_node::ethereum_details::ValidatorConfig>,
        {
            self.validator_config = v.map(|x| x.into());
            self
        }

        /// Sets the value of [execution_client_details][crate::model::blockchain_node::EthereumDetails::execution_client_details].
        ///
        /// Note that all the setters affecting `execution_client_details` are mutually
        /// exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::GethDetails;
        /// let x = EthereumDetails::new().set_execution_client_details(Some(
        ///     google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ExecutionClientDetails::GethDetails(GethDetails::default().into())));
        /// ```
        pub fn set_execution_client_details<
            T: std::convert::Into<
                    std::option::Option<
                        crate::model::blockchain_node::ethereum_details::ExecutionClientDetails,
                    >,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.execution_client_details = v.into();
            self
        }

        /// The value of [execution_client_details][crate::model::blockchain_node::EthereumDetails::execution_client_details]
        /// if it holds a `GethDetails`, `None` if the field is not set or
        /// holds a different branch.
        pub fn geth_details(
            &self,
        ) -> std::option::Option<
            &std::boxed::Box<crate::model::blockchain_node::ethereum_details::GethDetails>,
        > {
            #[allow(unreachable_patterns)]
            self.execution_client_details.as_ref().and_then(|v| match v {
                crate::model::blockchain_node::ethereum_details::ExecutionClientDetails::GethDetails(v) => std::option::Option::Some(v),
                _ => std::option::Option::None,
            })
        }

        /// Sets the value of [execution_client_details][crate::model::blockchain_node::EthereumDetails::execution_client_details]
        /// to hold a `GethDetails`.
        ///
        /// Note that all the setters affecting `execution_client_details` are
        /// mutually exclusive.
        ///
        /// # Example
        /// ```ignore,no_run
        /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::EthereumDetails;
        /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::GethDetails;
        /// let x = EthereumDetails::new().set_geth_details(GethDetails::default()/* use setters */);
        /// assert!(x.geth_details().is_some());
        /// ```
        pub fn set_geth_details<
            T: std::convert::Into<
                    std::boxed::Box<crate::model::blockchain_node::ethereum_details::GethDetails>,
                >,
        >(
            mut self,
            v: T,
        ) -> Self {
            self.execution_client_details = std::option::Option::Some(
                crate::model::blockchain_node::ethereum_details::ExecutionClientDetails::GethDetails(
                    v.into()
                )
            );
            self
        }
    }

    impl wkt::message::Message for EthereumDetails {
        fn typename() -> &'static str {
            "type.googleapis.com/google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails"
        }
    }

    /// Defines additional types related to [EthereumDetails].
    pub mod ethereum_details {
        #[allow(unused_imports)]
        use super::*;

        /// Options for the Geth execution client.
        ///
        /// See [Command-line
        /// Options](https://geth.ethereum.org/docs/fundamentals/command-line-options)
        /// for more details.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct GethDetails {

            /// Immutable. Blockchain garbage collection mode.
            pub garbage_collection_mode: std::option::Option<crate::model::blockchain_node::ethereum_details::geth_details::GarbageCollectionMode>,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl GethDetails {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [garbage_collection_mode][crate::model::blockchain_node::ethereum_details::GethDetails::garbage_collection_mode].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::GethDetails;
            /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::geth_details::GarbageCollectionMode;
            /// let x0 = GethDetails::new().set_garbage_collection_mode(GarbageCollectionMode::Full);
            /// let x1 = GethDetails::new().set_garbage_collection_mode(GarbageCollectionMode::Archive);
            /// ```
            pub fn set_garbage_collection_mode<T>(mut self, v: T) -> Self
            where T: std::convert::Into<crate::model::blockchain_node::ethereum_details::geth_details::GarbageCollectionMode>
            {
                self.garbage_collection_mode = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [garbage_collection_mode][crate::model::blockchain_node::ethereum_details::GethDetails::garbage_collection_mode].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::GethDetails;
            /// use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::geth_details::GarbageCollectionMode;
            /// let x0 = GethDetails::new().set_or_clear_garbage_collection_mode(Some(GarbageCollectionMode::Full));
            /// let x1 = GethDetails::new().set_or_clear_garbage_collection_mode(Some(GarbageCollectionMode::Archive));
            /// let x_none = GethDetails::new().set_or_clear_garbage_collection_mode(None::<GarbageCollectionMode>);
            /// ```
            pub fn set_or_clear_garbage_collection_mode<T>(mut self, v: std::option::Option<T>) -> Self
            where T: std::convert::Into<crate::model::blockchain_node::ethereum_details::geth_details::GarbageCollectionMode>
            {
                self.garbage_collection_mode = v.map(|x| x.into());
                self
            }
        }

        impl wkt::message::Message for GethDetails {
            fn typename() -> &'static str {
                "type.googleapis.com/google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails.GethDetails"
            }
        }

        /// Defines additional types related to [GethDetails].
        pub mod geth_details {
            #[allow(unused_imports)]
            use super::*;

            /// Blockchain garbage collection modes. Only applicable when `NodeType` is
            /// `FULL` or `ARCHIVE`.
            ///
            /// # Working with unknown values
            ///
            /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
            /// additional enum variants at any time. Adding new variants is not considered
            /// a breaking change. Applications should write their code in anticipation of:
            ///
            /// - New values appearing in future releases of the client library, **and**
            /// - New values received dynamically, without application changes.
            ///
            /// Please consult the [Working with enums] section in the user guide for some
            /// guidelines.
            ///
            /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
            #[derive(Clone, Debug, PartialEq)]
            #[non_exhaustive]
            pub enum GarbageCollectionMode {
                /// The garbage collection has not been specified.
                Unspecified,
                /// 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,
                /// 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,
                /// If set, the enum was initialized with an unknown value.
                ///
                /// Applications can examine the value using [GarbageCollectionMode::value] or
                /// [GarbageCollectionMode::name].
                UnknownValue(garbage_collection_mode::UnknownValue),
            }

            #[doc(hidden)]
            pub mod garbage_collection_mode {
                #[allow(unused_imports)]
                use super::*;
                #[derive(Clone, Debug, PartialEq)]
                pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
            }

            impl GarbageCollectionMode {
                /// Gets the enum value.
                ///
                /// Returns `None` if the enum contains an unknown value deserialized from
                /// the string representation of enums.
                pub fn value(&self) -> std::option::Option<i32> {
                    match self {
                        Self::Unspecified => std::option::Option::Some(0),
                        Self::Full => std::option::Option::Some(1),
                        Self::Archive => std::option::Option::Some(2),
                        Self::UnknownValue(u) => u.0.value(),
                    }
                }

                /// Gets the enum value as a string.
                ///
                /// Returns `None` if the enum contains an unknown value deserialized from
                /// the integer representation of enums.
                pub fn name(&self) -> std::option::Option<&str> {
                    match self {
                        Self::Unspecified => {
                            std::option::Option::Some("GARBAGE_COLLECTION_MODE_UNSPECIFIED")
                        }
                        Self::Full => std::option::Option::Some("FULL"),
                        Self::Archive => std::option::Option::Some("ARCHIVE"),
                        Self::UnknownValue(u) => u.0.name(),
                    }
                }
            }

            impl std::default::Default for GarbageCollectionMode {
                fn default() -> Self {
                    use std::convert::From;
                    Self::from(0)
                }
            }

            impl std::fmt::Display for GarbageCollectionMode {
                fn fmt(
                    &self,
                    f: &mut std::fmt::Formatter<'_>,
                ) -> std::result::Result<(), std::fmt::Error> {
                    wkt::internal::display_enum(f, self.name(), self.value())
                }
            }

            impl std::convert::From<i32> for GarbageCollectionMode {
                fn from(value: i32) -> Self {
                    match value {
                        0 => Self::Unspecified,
                        1 => Self::Full,
                        2 => Self::Archive,
                        _ => Self::UnknownValue(garbage_collection_mode::UnknownValue(
                            wkt::internal::UnknownEnumValue::Integer(value),
                        )),
                    }
                }
            }

            impl std::convert::From<&str> for GarbageCollectionMode {
                fn from(value: &str) -> Self {
                    use std::string::ToString;
                    match value {
                        "GARBAGE_COLLECTION_MODE_UNSPECIFIED" => Self::Unspecified,
                        "FULL" => Self::Full,
                        "ARCHIVE" => Self::Archive,
                        _ => Self::UnknownValue(garbage_collection_mode::UnknownValue(
                            wkt::internal::UnknownEnumValue::String(value.to_string()),
                        )),
                    }
                }
            }

            impl serde::ser::Serialize for GarbageCollectionMode {
                fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
                where
                    S: serde::Serializer,
                {
                    match self {
                        Self::Unspecified => serializer.serialize_i32(0),
                        Self::Full => serializer.serialize_i32(1),
                        Self::Archive => serializer.serialize_i32(2),
                        Self::UnknownValue(u) => u.0.serialize(serializer),
                    }
                }
            }

            impl<'de> serde::de::Deserialize<'de> for GarbageCollectionMode {
                fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
                where
                    D: serde::Deserializer<'de>,
                {
                    deserializer.deserialize_any(wkt::internal::EnumVisitor::<GarbageCollectionMode>::new(
                        ".google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails.GethDetails.GarbageCollectionMode"))
                }
            }
        }

        /// Contains endpoint information specific to Ethereum nodes.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        pub struct EthereumEndpoints {
            /// Output only. The assigned URL for the node's Beacon API endpoint.
            pub beacon_api_endpoint: std::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.
            pub beacon_prometheus_metrics_api_endpoint: std::string::String,

            /// Output only. The assigned URL for the node's execution client's
            /// Prometheus metrics endpoint.
            pub execution_client_prometheus_metrics_api_endpoint: std::string::String,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl EthereumEndpoints {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [beacon_api_endpoint][crate::model::blockchain_node::ethereum_details::EthereumEndpoints::beacon_api_endpoint].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::EthereumEndpoints;
            /// let x = EthereumEndpoints::new().set_beacon_api_endpoint("example");
            /// ```
            pub fn set_beacon_api_endpoint<T: std::convert::Into<std::string::String>>(
                mut self,
                v: T,
            ) -> Self {
                self.beacon_api_endpoint = v.into();
                self
            }

            /// Sets the value of [beacon_prometheus_metrics_api_endpoint][crate::model::blockchain_node::ethereum_details::EthereumEndpoints::beacon_prometheus_metrics_api_endpoint].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::EthereumEndpoints;
            /// let x = EthereumEndpoints::new().set_beacon_prometheus_metrics_api_endpoint("example");
            /// ```
            pub fn set_beacon_prometheus_metrics_api_endpoint<
                T: std::convert::Into<std::string::String>,
            >(
                mut self,
                v: T,
            ) -> Self {
                self.beacon_prometheus_metrics_api_endpoint = v.into();
                self
            }

            /// Sets the value of [execution_client_prometheus_metrics_api_endpoint][crate::model::blockchain_node::ethereum_details::EthereumEndpoints::execution_client_prometheus_metrics_api_endpoint].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::EthereumEndpoints;
            /// let x = EthereumEndpoints::new().set_execution_client_prometheus_metrics_api_endpoint("example");
            /// ```
            pub fn set_execution_client_prometheus_metrics_api_endpoint<
                T: std::convert::Into<std::string::String>,
            >(
                mut self,
                v: T,
            ) -> Self {
                self.execution_client_prometheus_metrics_api_endpoint = v.into();
                self
            }
        }

        impl wkt::message::Message for EthereumEndpoints {
            fn typename() -> &'static str {
                "type.googleapis.com/google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails.EthereumEndpoints"
            }
        }

        /// Configuration for validator-related parameters on the beacon client,
        /// and for any GCP-managed validator client.
        #[derive(Clone, Default, PartialEq)]
        #[non_exhaustive]
        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.
            pub mev_relay_urls: std::vec::Vec<std::string::String>,

            /// Immutable. When true, deploys a GCP-managed validator client alongside
            /// the beacon client.
            #[deprecated]
            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.
            pub beacon_fee_recipient: std::option::Option<std::string::String>,

            pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
        }

        impl ValidatorConfig {
            /// Creates a new default instance.
            pub fn new() -> Self {
                std::default::Default::default()
            }

            /// Sets the value of [mev_relay_urls][crate::model::blockchain_node::ethereum_details::ValidatorConfig::mev_relay_urls].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ValidatorConfig;
            /// let x = ValidatorConfig::new().set_mev_relay_urls(["a", "b", "c"]);
            /// ```
            pub fn set_mev_relay_urls<T, V>(mut self, v: T) -> Self
            where
                T: std::iter::IntoIterator<Item = V>,
                V: std::convert::Into<std::string::String>,
            {
                use std::iter::Iterator;
                self.mev_relay_urls = v.into_iter().map(|i| i.into()).collect();
                self
            }

            /// Sets the value of [managed_validator_client][crate::model::blockchain_node::ethereum_details::ValidatorConfig::managed_validator_client].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ValidatorConfig;
            /// let x = ValidatorConfig::new().set_managed_validator_client(true);
            /// ```
            #[deprecated]
            pub fn set_managed_validator_client<T: std::convert::Into<bool>>(
                mut self,
                v: T,
            ) -> Self {
                self.managed_validator_client = v.into();
                self
            }

            /// Sets the value of [beacon_fee_recipient][crate::model::blockchain_node::ethereum_details::ValidatorConfig::beacon_fee_recipient].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ValidatorConfig;
            /// let x = ValidatorConfig::new().set_beacon_fee_recipient("example");
            /// ```
            pub fn set_beacon_fee_recipient<T>(mut self, v: T) -> Self
            where
                T: std::convert::Into<std::string::String>,
            {
                self.beacon_fee_recipient = std::option::Option::Some(v.into());
                self
            }

            /// Sets or clears the value of [beacon_fee_recipient][crate::model::blockchain_node::ethereum_details::ValidatorConfig::beacon_fee_recipient].
            ///
            /// # Example
            /// ```ignore,no_run
            /// # use google_cloud_blockchainnodeengine_v1::model::blockchain_node::ethereum_details::ValidatorConfig;
            /// let x = ValidatorConfig::new().set_or_clear_beacon_fee_recipient(Some("example"));
            /// let x = ValidatorConfig::new().set_or_clear_beacon_fee_recipient(None::<String>);
            /// ```
            pub fn set_or_clear_beacon_fee_recipient<T>(mut self, v: std::option::Option<T>) -> Self
            where
                T: std::convert::Into<std::string::String>,
            {
                self.beacon_fee_recipient = v.map(|x| x.into());
                self
            }
        }

        impl wkt::message::Message for ValidatorConfig {
            fn typename() -> &'static str {
                "type.googleapis.com/google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails.ValidatorConfig"
            }
        }

        /// The Ethereum environment being accessed.
        ///
        /// See [Networks](https://ethereum.org/en/developers/docs/networks)
        /// for more details.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum Network {
            /// The network has not been specified, but should be.
            Unspecified,
            /// The Ethereum Mainnet.
            Mainnet,
            /// Deprecated: The Ethereum Testnet based on Goerli protocol. Please
            /// use another test network.
            #[deprecated]
            TestnetGoerliPrater,
            /// The Ethereum Testnet based on Sepolia/Bepolia protocol.
            /// See <https://github.com/eth-clients/sepolia>.
            TestnetSepolia,
            /// The Ethereum Testnet based on Holesky specification.
            /// See <https://github.com/eth-clients/holesky>.
            TestnetHolesky,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [Network::value] or
            /// [Network::name].
            UnknownValue(network::UnknownValue),
        }

        #[doc(hidden)]
        pub mod network {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl Network {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Mainnet => std::option::Option::Some(1),
                    Self::TestnetGoerliPrater => std::option::Option::Some(2),
                    Self::TestnetSepolia => std::option::Option::Some(3),
                    Self::TestnetHolesky => std::option::Option::Some(4),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("NETWORK_UNSPECIFIED"),
                    Self::Mainnet => std::option::Option::Some("MAINNET"),
                    Self::TestnetGoerliPrater => std::option::Option::Some("TESTNET_GOERLI_PRATER"),
                    Self::TestnetSepolia => std::option::Option::Some("TESTNET_SEPOLIA"),
                    Self::TestnetHolesky => std::option::Option::Some("TESTNET_HOLESKY"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for Network {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for Network {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for Network {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Mainnet,
                    2 => Self::TestnetGoerliPrater,
                    3 => Self::TestnetSepolia,
                    4 => Self::TestnetHolesky,
                    _ => Self::UnknownValue(network::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for Network {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "NETWORK_UNSPECIFIED" => Self::Unspecified,
                    "MAINNET" => Self::Mainnet,
                    "TESTNET_GOERLI_PRATER" => Self::TestnetGoerliPrater,
                    "TESTNET_SEPOLIA" => Self::TestnetSepolia,
                    "TESTNET_HOLESKY" => Self::TestnetHolesky,
                    _ => Self::UnknownValue(network::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for Network {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Mainnet => serializer.serialize_i32(1),
                    Self::TestnetGoerliPrater => serializer.serialize_i32(2),
                    Self::TestnetSepolia => serializer.serialize_i32(3),
                    Self::TestnetHolesky => serializer.serialize_i32(4),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for Network {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<Network>::new(
                    ".google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails.Network",
                ))
            }
        }

        /// The type of Ethereum node.
        ///
        /// See
        /// [Node
        /// Types](https://ethereum.org/en/developers/docs/nodes-and-clients/#node-types)
        /// for more details.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum NodeType {
            /// Node type has not been specified, but should be.
            Unspecified,
            /// An Ethereum node that only downloads Ethereum block headers.
            Light,
            /// Keeps a complete copy of the blockchain data, and contributes to the
            /// network by receiving, validating, and forwarding transactions.
            Full,
            /// 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,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [NodeType::value] or
            /// [NodeType::name].
            UnknownValue(node_type::UnknownValue),
        }

        #[doc(hidden)]
        pub mod node_type {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl NodeType {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Light => std::option::Option::Some(1),
                    Self::Full => std::option::Option::Some(2),
                    Self::Archive => std::option::Option::Some(3),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("NODE_TYPE_UNSPECIFIED"),
                    Self::Light => std::option::Option::Some("LIGHT"),
                    Self::Full => std::option::Option::Some("FULL"),
                    Self::Archive => std::option::Option::Some("ARCHIVE"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for NodeType {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for NodeType {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for NodeType {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Light,
                    2 => Self::Full,
                    3 => Self::Archive,
                    _ => Self::UnknownValue(node_type::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for NodeType {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "NODE_TYPE_UNSPECIFIED" => Self::Unspecified,
                    "LIGHT" => Self::Light,
                    "FULL" => Self::Full,
                    "ARCHIVE" => Self::Archive,
                    _ => Self::UnknownValue(node_type::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for NodeType {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Light => serializer.serialize_i32(1),
                    Self::Full => serializer.serialize_i32(2),
                    Self::Archive => serializer.serialize_i32(3),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for NodeType {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<NodeType>::new(
                    ".google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails.NodeType",
                ))
            }
        }

        /// 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.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ExecutionClient {
            /// Execution client has not been specified, but should be.
            Unspecified,
            /// Official Go implementation of the Ethereum protocol.
            /// See [go-ethereum](https://geth.ethereum.org/) for details.
            Geth,
            /// 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,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [ExecutionClient::value] or
            /// [ExecutionClient::name].
            UnknownValue(execution_client::UnknownValue),
        }

        #[doc(hidden)]
        pub mod execution_client {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl ExecutionClient {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Geth => std::option::Option::Some(1),
                    Self::Erigon => std::option::Option::Some(2),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("EXECUTION_CLIENT_UNSPECIFIED"),
                    Self::Geth => std::option::Option::Some("GETH"),
                    Self::Erigon => std::option::Option::Some("ERIGON"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for ExecutionClient {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for ExecutionClient {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for ExecutionClient {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Geth,
                    2 => Self::Erigon,
                    _ => Self::UnknownValue(execution_client::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for ExecutionClient {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "EXECUTION_CLIENT_UNSPECIFIED" => Self::Unspecified,
                    "GETH" => Self::Geth,
                    "ERIGON" => Self::Erigon,
                    _ => Self::UnknownValue(execution_client::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for ExecutionClient {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Geth => serializer.serialize_i32(1),
                    Self::Erigon => serializer.serialize_i32(2),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for ExecutionClient {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<ExecutionClient>::new(
                    ".google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails.ExecutionClient"))
            }
        }

        /// 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.
        ///
        /// # Working with unknown values
        ///
        /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
        /// additional enum variants at any time. Adding new variants is not considered
        /// a breaking change. Applications should write their code in anticipation of:
        ///
        /// - New values appearing in future releases of the client library, **and**
        /// - New values received dynamically, without application changes.
        ///
        /// Please consult the [Working with enums] section in the user guide for some
        /// guidelines.
        ///
        /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ConsensusClient {
            /// Consensus client has not been specified, but should be.
            Unspecified,
            /// Consensus client implementation written in Rust, maintained by Sigma
            /// Prime. See [Lighthouse - Sigma
            /// Prime](https://lighthouse.sigmaprime.io/) for details.
            Lighthouse,
            /// If set, the enum was initialized with an unknown value.
            ///
            /// Applications can examine the value using [ConsensusClient::value] or
            /// [ConsensusClient::name].
            UnknownValue(consensus_client::UnknownValue),
        }

        #[doc(hidden)]
        pub mod consensus_client {
            #[allow(unused_imports)]
            use super::*;
            #[derive(Clone, Debug, PartialEq)]
            pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
        }

        impl ConsensusClient {
            /// Gets the enum value.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the string representation of enums.
            pub fn value(&self) -> std::option::Option<i32> {
                match self {
                    Self::Unspecified => std::option::Option::Some(0),
                    Self::Lighthouse => std::option::Option::Some(1),
                    Self::UnknownValue(u) => u.0.value(),
                }
            }

            /// Gets the enum value as a string.
            ///
            /// Returns `None` if the enum contains an unknown value deserialized from
            /// the integer representation of enums.
            pub fn name(&self) -> std::option::Option<&str> {
                match self {
                    Self::Unspecified => std::option::Option::Some("CONSENSUS_CLIENT_UNSPECIFIED"),
                    Self::Lighthouse => std::option::Option::Some("LIGHTHOUSE"),
                    Self::UnknownValue(u) => u.0.name(),
                }
            }
        }

        impl std::default::Default for ConsensusClient {
            fn default() -> Self {
                use std::convert::From;
                Self::from(0)
            }
        }

        impl std::fmt::Display for ConsensusClient {
            fn fmt(
                &self,
                f: &mut std::fmt::Formatter<'_>,
            ) -> std::result::Result<(), std::fmt::Error> {
                wkt::internal::display_enum(f, self.name(), self.value())
            }
        }

        impl std::convert::From<i32> for ConsensusClient {
            fn from(value: i32) -> Self {
                match value {
                    0 => Self::Unspecified,
                    1 => Self::Lighthouse,
                    _ => Self::UnknownValue(consensus_client::UnknownValue(
                        wkt::internal::UnknownEnumValue::Integer(value),
                    )),
                }
            }
        }

        impl std::convert::From<&str> for ConsensusClient {
            fn from(value: &str) -> Self {
                use std::string::ToString;
                match value {
                    "CONSENSUS_CLIENT_UNSPECIFIED" => Self::Unspecified,
                    "LIGHTHOUSE" => Self::Lighthouse,
                    _ => Self::UnknownValue(consensus_client::UnknownValue(
                        wkt::internal::UnknownEnumValue::String(value.to_string()),
                    )),
                }
            }
        }

        impl serde::ser::Serialize for ConsensusClient {
            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                match self {
                    Self::Unspecified => serializer.serialize_i32(0),
                    Self::Lighthouse => serializer.serialize_i32(1),
                    Self::UnknownValue(u) => u.0.serialize(serializer),
                }
            }
        }

        impl<'de> serde::de::Deserialize<'de> for ConsensusClient {
            fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                deserializer.deserialize_any(wkt::internal::EnumVisitor::<ConsensusClient>::new(
                    ".google.cloud.blockchainnodeengine.v1.BlockchainNode.EthereumDetails.ConsensusClient"))
            }
        }

        /// Options for the execution client.
        #[derive(Clone, Debug, PartialEq)]
        #[non_exhaustive]
        pub enum ExecutionClientDetails {
            /// Details for the Geth execution client.
            GethDetails(
                std::boxed::Box<crate::model::blockchain_node::ethereum_details::GethDetails>,
            ),
        }
    }

    /// The blockchain type of the node.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum BlockchainType {
        /// Blockchain type has not been specified, but should be.
        Unspecified,
        /// The blockchain type is Ethereum.
        Ethereum,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [BlockchainType::value] or
        /// [BlockchainType::name].
        UnknownValue(blockchain_type::UnknownValue),
    }

    #[doc(hidden)]
    pub mod blockchain_type {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl BlockchainType {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Ethereum => std::option::Option::Some(1),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("BLOCKCHAIN_TYPE_UNSPECIFIED"),
                Self::Ethereum => std::option::Option::Some("ETHEREUM"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for BlockchainType {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for BlockchainType {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for BlockchainType {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Ethereum,
                _ => Self::UnknownValue(blockchain_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for BlockchainType {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "BLOCKCHAIN_TYPE_UNSPECIFIED" => Self::Unspecified,
                "ETHEREUM" => Self::Ethereum,
                _ => Self::UnknownValue(blockchain_type::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for BlockchainType {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Ethereum => serializer.serialize_i32(1),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for BlockchainType {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<BlockchainType>::new(
                ".google.cloud.blockchainnodeengine.v1.BlockchainNode.BlockchainType",
            ))
        }
    }

    /// All possible states for a given blockchain node.
    ///
    /// # Working with unknown values
    ///
    /// This enum is defined as `#[non_exhaustive]` because Google Cloud may add
    /// additional enum variants at any time. Adding new variants is not considered
    /// a breaking change. Applications should write their code in anticipation of:
    ///
    /// - New values appearing in future releases of the client library, **and**
    /// - New values received dynamically, without application changes.
    ///
    /// Please consult the [Working with enums] section in the user guide for some
    /// guidelines.
    ///
    /// [Working with enums]: https://googleapis.github.io/google-cloud-rust/working_with_enums.html
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum State {
        /// The state has not been specified.
        Unspecified,
        /// The node has been requested and is in the process of being created.
        Creating,
        /// The existing node is undergoing deletion, but is not yet finished.
        Deleting,
        /// The node is running and ready for use.
        Running,
        /// The node is in an unexpected or errored state.
        Error,
        /// The node is currently being updated.
        Updating,
        /// The node is currently being repaired.
        Repairing,
        /// The node is currently being reconciled.
        Reconciling,
        /// The node is syncing, which is the process by which it obtains the latest
        /// block and current global state.
        Syncing,
        /// If set, the enum was initialized with an unknown value.
        ///
        /// Applications can examine the value using [State::value] or
        /// [State::name].
        UnknownValue(state::UnknownValue),
    }

    #[doc(hidden)]
    pub mod state {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Debug, PartialEq)]
        pub struct UnknownValue(pub(crate) wkt::internal::UnknownEnumValue);
    }

    impl State {
        /// Gets the enum value.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the string representation of enums.
        pub fn value(&self) -> std::option::Option<i32> {
            match self {
                Self::Unspecified => std::option::Option::Some(0),
                Self::Creating => std::option::Option::Some(1),
                Self::Deleting => std::option::Option::Some(2),
                Self::Running => std::option::Option::Some(4),
                Self::Error => std::option::Option::Some(5),
                Self::Updating => std::option::Option::Some(6),
                Self::Repairing => std::option::Option::Some(7),
                Self::Reconciling => std::option::Option::Some(8),
                Self::Syncing => std::option::Option::Some(9),
                Self::UnknownValue(u) => u.0.value(),
            }
        }

        /// Gets the enum value as a string.
        ///
        /// Returns `None` if the enum contains an unknown value deserialized from
        /// the integer representation of enums.
        pub fn name(&self) -> std::option::Option<&str> {
            match self {
                Self::Unspecified => std::option::Option::Some("STATE_UNSPECIFIED"),
                Self::Creating => std::option::Option::Some("CREATING"),
                Self::Deleting => std::option::Option::Some("DELETING"),
                Self::Running => std::option::Option::Some("RUNNING"),
                Self::Error => std::option::Option::Some("ERROR"),
                Self::Updating => std::option::Option::Some("UPDATING"),
                Self::Repairing => std::option::Option::Some("REPAIRING"),
                Self::Reconciling => std::option::Option::Some("RECONCILING"),
                Self::Syncing => std::option::Option::Some("SYNCING"),
                Self::UnknownValue(u) => u.0.name(),
            }
        }
    }

    impl std::default::Default for State {
        fn default() -> Self {
            use std::convert::From;
            Self::from(0)
        }
    }

    impl std::fmt::Display for State {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
            wkt::internal::display_enum(f, self.name(), self.value())
        }
    }

    impl std::convert::From<i32> for State {
        fn from(value: i32) -> Self {
            match value {
                0 => Self::Unspecified,
                1 => Self::Creating,
                2 => Self::Deleting,
                4 => Self::Running,
                5 => Self::Error,
                6 => Self::Updating,
                7 => Self::Repairing,
                8 => Self::Reconciling,
                9 => Self::Syncing,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::Integer(value),
                )),
            }
        }
    }

    impl std::convert::From<&str> for State {
        fn from(value: &str) -> Self {
            use std::string::ToString;
            match value {
                "STATE_UNSPECIFIED" => Self::Unspecified,
                "CREATING" => Self::Creating,
                "DELETING" => Self::Deleting,
                "RUNNING" => Self::Running,
                "ERROR" => Self::Error,
                "UPDATING" => Self::Updating,
                "REPAIRING" => Self::Repairing,
                "RECONCILING" => Self::Reconciling,
                "SYNCING" => Self::Syncing,
                _ => Self::UnknownValue(state::UnknownValue(
                    wkt::internal::UnknownEnumValue::String(value.to_string()),
                )),
            }
        }
    }

    impl serde::ser::Serialize for State {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: serde::Serializer,
        {
            match self {
                Self::Unspecified => serializer.serialize_i32(0),
                Self::Creating => serializer.serialize_i32(1),
                Self::Deleting => serializer.serialize_i32(2),
                Self::Running => serializer.serialize_i32(4),
                Self::Error => serializer.serialize_i32(5),
                Self::Updating => serializer.serialize_i32(6),
                Self::Repairing => serializer.serialize_i32(7),
                Self::Reconciling => serializer.serialize_i32(8),
                Self::Syncing => serializer.serialize_i32(9),
                Self::UnknownValue(u) => u.0.serialize(serializer),
            }
        }
    }

    impl<'de> serde::de::Deserialize<'de> for State {
        fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
        where
            D: serde::Deserializer<'de>,
        {
            deserializer.deserialize_any(wkt::internal::EnumVisitor::<State>::new(
                ".google.cloud.blockchainnodeengine.v1.BlockchainNode.State",
            ))
        }
    }

    /// Information that is specific to a particular blockchain type.
    #[derive(Clone, Debug, PartialEq)]
    #[non_exhaustive]
    pub enum BlockchainTypeDetails {
        /// Ethereum-specific blockchain node details.
        EthereumDetails(std::boxed::Box<crate::model::blockchain_node::EthereumDetails>),
    }
}

/// Message for requesting list of blockchain nodes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListBlockchainNodesRequest {
    /// Required. Parent value for `ListNodesRequest`.
    pub parent: std::string::String,

    /// Requested page size. Server may return fewer items than requested.
    /// If unspecified, server will pick an appropriate default.
    pub page_size: i32,

    /// A token identifying a page of results the server should return.
    pub page_token: std::string::String,

    /// Filtering results.
    pub filter: std::string::String,

    /// Hint for how to order the results.
    pub order_by: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListBlockchainNodesRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::ListBlockchainNodesRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::ListBlockchainNodesRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// let x = ListBlockchainNodesRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}"));
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [page_size][crate::model::ListBlockchainNodesRequest::page_size].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::ListBlockchainNodesRequest;
    /// let x = ListBlockchainNodesRequest::new().set_page_size(42);
    /// ```
    pub fn set_page_size<T: std::convert::Into<i32>>(mut self, v: T) -> Self {
        self.page_size = v.into();
        self
    }

    /// Sets the value of [page_token][crate::model::ListBlockchainNodesRequest::page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::ListBlockchainNodesRequest;
    /// let x = ListBlockchainNodesRequest::new().set_page_token("example");
    /// ```
    pub fn set_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.page_token = v.into();
        self
    }

    /// Sets the value of [filter][crate::model::ListBlockchainNodesRequest::filter].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::ListBlockchainNodesRequest;
    /// let x = ListBlockchainNodesRequest::new().set_filter("example");
    /// ```
    pub fn set_filter<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.filter = v.into();
        self
    }

    /// Sets the value of [order_by][crate::model::ListBlockchainNodesRequest::order_by].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::ListBlockchainNodesRequest;
    /// let x = ListBlockchainNodesRequest::new().set_order_by("example");
    /// ```
    pub fn set_order_by<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.order_by = v.into();
        self
    }
}

impl wkt::message::Message for ListBlockchainNodesRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.blockchainnodeengine.v1.ListBlockchainNodesRequest"
    }
}

/// Message for response to listing blockchain nodes.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct ListBlockchainNodesResponse {
    /// The list of nodes
    pub blockchain_nodes: std::vec::Vec<crate::model::BlockchainNode>,

    /// A token identifying a page of results the server should return.
    pub next_page_token: std::string::String,

    /// Locations that could not be reached.
    pub unreachable: std::vec::Vec<std::string::String>,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl ListBlockchainNodesResponse {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [blockchain_nodes][crate::model::ListBlockchainNodesResponse::blockchain_nodes].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::ListBlockchainNodesResponse;
    /// use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// let x = ListBlockchainNodesResponse::new()
    ///     .set_blockchain_nodes([
    ///         BlockchainNode::default()/* use setters */,
    ///         BlockchainNode::default()/* use (different) setters */,
    ///     ]);
    /// ```
    pub fn set_blockchain_nodes<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<crate::model::BlockchainNode>,
    {
        use std::iter::Iterator;
        self.blockchain_nodes = v.into_iter().map(|i| i.into()).collect();
        self
    }

    /// Sets the value of [next_page_token][crate::model::ListBlockchainNodesResponse::next_page_token].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::ListBlockchainNodesResponse;
    /// let x = ListBlockchainNodesResponse::new().set_next_page_token("example");
    /// ```
    pub fn set_next_page_token<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.next_page_token = v.into();
        self
    }

    /// Sets the value of [unreachable][crate::model::ListBlockchainNodesResponse::unreachable].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::ListBlockchainNodesResponse;
    /// let x = ListBlockchainNodesResponse::new().set_unreachable(["a", "b", "c"]);
    /// ```
    pub fn set_unreachable<T, V>(mut self, v: T) -> Self
    where
        T: std::iter::IntoIterator<Item = V>,
        V: std::convert::Into<std::string::String>,
    {
        use std::iter::Iterator;
        self.unreachable = v.into_iter().map(|i| i.into()).collect();
        self
    }
}

impl wkt::message::Message for ListBlockchainNodesResponse {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.blockchainnodeengine.v1.ListBlockchainNodesResponse"
    }
}

#[doc(hidden)]
impl google_cloud_gax::paginator::internal::PageableResponse for ListBlockchainNodesResponse {
    type PageItem = crate::model::BlockchainNode;

    fn items(self) -> std::vec::Vec<Self::PageItem> {
        self.blockchain_nodes
    }

    fn next_page_token(&self) -> std::string::String {
        use std::clone::Clone;
        self.next_page_token.clone()
    }
}

/// Message for getting a blockchain node.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
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`.
    pub name: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl GetBlockchainNodeRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::GetBlockchainNodeRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::GetBlockchainNodeRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let blockchain_node_id = "blockchain_node_id";
    /// let x = GetBlockchainNodeRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/blockchainNodes/{blockchain_node_id}"));
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }
}

impl wkt::message::Message for GetBlockchainNodeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.blockchainnodeengine.v1.GetBlockchainNodeRequest"
    }
}

/// Message for creating a blockchain node.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct CreateBlockchainNodeRequest {
    /// Required. Value for parent.
    pub parent: std::string::String,

    /// Required. ID of the requesting object.
    pub blockchain_node_id: std::string::String,

    /// Required. The resource being created.
    pub blockchain_node: std::option::Option<crate::model::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).
    pub request_id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl CreateBlockchainNodeRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [parent][crate::model::CreateBlockchainNodeRequest::parent].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::CreateBlockchainNodeRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// let x = CreateBlockchainNodeRequest::new().set_parent(format!("projects/{project_id}/locations/{location_id}"));
    /// ```
    pub fn set_parent<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.parent = v.into();
        self
    }

    /// Sets the value of [blockchain_node_id][crate::model::CreateBlockchainNodeRequest::blockchain_node_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::CreateBlockchainNodeRequest;
    /// let x = CreateBlockchainNodeRequest::new().set_blockchain_node_id("example");
    /// ```
    pub fn set_blockchain_node_id<T: std::convert::Into<std::string::String>>(
        mut self,
        v: T,
    ) -> Self {
        self.blockchain_node_id = v.into();
        self
    }

    /// Sets the value of [blockchain_node][crate::model::CreateBlockchainNodeRequest::blockchain_node].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::CreateBlockchainNodeRequest;
    /// use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// let x = CreateBlockchainNodeRequest::new().set_blockchain_node(BlockchainNode::default()/* use setters */);
    /// ```
    pub fn set_blockchain_node<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::BlockchainNode>,
    {
        self.blockchain_node = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [blockchain_node][crate::model::CreateBlockchainNodeRequest::blockchain_node].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::CreateBlockchainNodeRequest;
    /// use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// let x = CreateBlockchainNodeRequest::new().set_or_clear_blockchain_node(Some(BlockchainNode::default()/* use setters */));
    /// let x = CreateBlockchainNodeRequest::new().set_or_clear_blockchain_node(None::<BlockchainNode>);
    /// ```
    pub fn set_or_clear_blockchain_node<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::BlockchainNode>,
    {
        self.blockchain_node = v.map(|x| x.into());
        self
    }

    /// Sets the value of [request_id][crate::model::CreateBlockchainNodeRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::CreateBlockchainNodeRequest;
    /// let x = CreateBlockchainNodeRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for CreateBlockchainNodeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.blockchainnodeengine.v1.CreateBlockchainNodeRequest"
    }
}

/// Message for updating a blockchain node.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
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.
    pub update_mask: std::option::Option<wkt::FieldMask>,

    /// Required. The resource being updated.
    pub blockchain_node: std::option::Option<crate::model::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).
    pub request_id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl UpdateBlockchainNodeRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [update_mask][crate::model::UpdateBlockchainNodeRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::UpdateBlockchainNodeRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateBlockchainNodeRequest::new().set_update_mask(FieldMask::default()/* use setters */);
    /// ```
    pub fn set_update_mask<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [update_mask][crate::model::UpdateBlockchainNodeRequest::update_mask].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::UpdateBlockchainNodeRequest;
    /// use wkt::FieldMask;
    /// let x = UpdateBlockchainNodeRequest::new().set_or_clear_update_mask(Some(FieldMask::default()/* use setters */));
    /// let x = UpdateBlockchainNodeRequest::new().set_or_clear_update_mask(None::<FieldMask>);
    /// ```
    pub fn set_or_clear_update_mask<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::FieldMask>,
    {
        self.update_mask = v.map(|x| x.into());
        self
    }

    /// Sets the value of [blockchain_node][crate::model::UpdateBlockchainNodeRequest::blockchain_node].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::UpdateBlockchainNodeRequest;
    /// use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// let x = UpdateBlockchainNodeRequest::new().set_blockchain_node(BlockchainNode::default()/* use setters */);
    /// ```
    pub fn set_blockchain_node<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<crate::model::BlockchainNode>,
    {
        self.blockchain_node = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [blockchain_node][crate::model::UpdateBlockchainNodeRequest::blockchain_node].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::UpdateBlockchainNodeRequest;
    /// use google_cloud_blockchainnodeengine_v1::model::BlockchainNode;
    /// let x = UpdateBlockchainNodeRequest::new().set_or_clear_blockchain_node(Some(BlockchainNode::default()/* use setters */));
    /// let x = UpdateBlockchainNodeRequest::new().set_or_clear_blockchain_node(None::<BlockchainNode>);
    /// ```
    pub fn set_or_clear_blockchain_node<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<crate::model::BlockchainNode>,
    {
        self.blockchain_node = v.map(|x| x.into());
        self
    }

    /// Sets the value of [request_id][crate::model::UpdateBlockchainNodeRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::UpdateBlockchainNodeRequest;
    /// let x = UpdateBlockchainNodeRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for UpdateBlockchainNodeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.blockchainnodeengine.v1.UpdateBlockchainNodeRequest"
    }
}

/// Message for deleting a blockchain node.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
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`.
    pub name: std::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).
    pub request_id: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl DeleteBlockchainNodeRequest {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [name][crate::model::DeleteBlockchainNodeRequest::name].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::DeleteBlockchainNodeRequest;
    /// # let project_id = "project_id";
    /// # let location_id = "location_id";
    /// # let blockchain_node_id = "blockchain_node_id";
    /// let x = DeleteBlockchainNodeRequest::new().set_name(format!("projects/{project_id}/locations/{location_id}/blockchainNodes/{blockchain_node_id}"));
    /// ```
    pub fn set_name<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.name = v.into();
        self
    }

    /// Sets the value of [request_id][crate::model::DeleteBlockchainNodeRequest::request_id].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::DeleteBlockchainNodeRequest;
    /// let x = DeleteBlockchainNodeRequest::new().set_request_id("example");
    /// ```
    pub fn set_request_id<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.request_id = v.into();
        self
    }
}

impl wkt::message::Message for DeleteBlockchainNodeRequest {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.blockchainnodeengine.v1.DeleteBlockchainNodeRequest"
    }
}

/// Represents the metadata of the long-running operation.
#[derive(Clone, Default, PartialEq)]
#[non_exhaustive]
pub struct OperationMetadata {
    /// Output only. The time the operation was created.
    pub create_time: std::option::Option<wkt::Timestamp>,

    /// Output only. The time the operation finished running.
    pub end_time: std::option::Option<wkt::Timestamp>,

    /// Output only. Server-defined resource path for the target of the operation.
    pub target: std::string::String,

    /// Output only. Name of the verb executed by the operation.
    pub verb: std::string::String,

    /// Output only. Human-readable status of the operation, if any.
    pub status_message: std::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`.
    pub requested_cancellation: bool,

    /// Output only. API version used to start the operation.
    pub api_version: std::string::String,

    pub(crate) _unknown_fields: serde_json::Map<std::string::String, serde_json::Value>,
}

impl OperationMetadata {
    /// Creates a new default instance.
    pub fn new() -> Self {
        std::default::Default::default()
    }

    /// Sets the value of [create_time][crate::model::OperationMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_create_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_create_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [create_time][crate::model::OperationMetadata::create_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_or_clear_create_time(Some(Timestamp::default()/* use setters */));
    /// let x = OperationMetadata::new().set_or_clear_create_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_create_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.create_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [end_time][crate::model::OperationMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_end_time(Timestamp::default()/* use setters */);
    /// ```
    pub fn set_end_time<T>(mut self, v: T) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = std::option::Option::Some(v.into());
        self
    }

    /// Sets or clears the value of [end_time][crate::model::OperationMetadata::end_time].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// use wkt::Timestamp;
    /// let x = OperationMetadata::new().set_or_clear_end_time(Some(Timestamp::default()/* use setters */));
    /// let x = OperationMetadata::new().set_or_clear_end_time(None::<Timestamp>);
    /// ```
    pub fn set_or_clear_end_time<T>(mut self, v: std::option::Option<T>) -> Self
    where
        T: std::convert::Into<wkt::Timestamp>,
    {
        self.end_time = v.map(|x| x.into());
        self
    }

    /// Sets the value of [target][crate::model::OperationMetadata::target].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_target("example");
    /// ```
    pub fn set_target<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.target = v.into();
        self
    }

    /// Sets the value of [verb][crate::model::OperationMetadata::verb].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_verb("example");
    /// ```
    pub fn set_verb<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.verb = v.into();
        self
    }

    /// Sets the value of [status_message][crate::model::OperationMetadata::status_message].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_status_message("example");
    /// ```
    pub fn set_status_message<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.status_message = v.into();
        self
    }

    /// Sets the value of [requested_cancellation][crate::model::OperationMetadata::requested_cancellation].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_requested_cancellation(true);
    /// ```
    pub fn set_requested_cancellation<T: std::convert::Into<bool>>(mut self, v: T) -> Self {
        self.requested_cancellation = v.into();
        self
    }

    /// Sets the value of [api_version][crate::model::OperationMetadata::api_version].
    ///
    /// # Example
    /// ```ignore,no_run
    /// # use google_cloud_blockchainnodeengine_v1::model::OperationMetadata;
    /// let x = OperationMetadata::new().set_api_version("example");
    /// ```
    pub fn set_api_version<T: std::convert::Into<std::string::String>>(mut self, v: T) -> Self {
        self.api_version = v.into();
        self
    }
}

impl wkt::message::Message for OperationMetadata {
    fn typename() -> &'static str {
        "type.googleapis.com/google.cloud.blockchainnodeengine.v1.OperationMetadata"
    }
}