use milkyway_std_derive::CosmwasmExt;
/// Operator defines the fields of an operator
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.Operator")]
pub struct Operator {
    /// ID is the auto-generated unique identifier for the operator
    #[prost(uint32, tag = "1")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u32,
    /// Status is the status of the operator
    #[prost(enumeration = "OperatorStatus", tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub status: i32,
    /// Admin is the address of the user that can manage the operator
    #[prost(string, tag = "3")]
    pub admin: ::prost::alloc::string::String,
    /// Moniker is the identifier of the operator
    #[prost(string, tag = "4")]
    pub moniker: ::prost::alloc::string::String,
    /// Website is the website of the operator
    #[prost(string, tag = "5")]
    pub website: ::prost::alloc::string::String,
    /// PictureURL is the URL of the picture of the operator
    #[prost(string, tag = "6")]
    pub picture_url: ::prost::alloc::string::String,
    /// Address is the address of the account associated to the operator.
    /// This will be used to store tokens that are delegated to this operator.
    #[prost(string, tag = "7")]
    pub address: ::prost::alloc::string::String,
    /// Tokens define the delegated tokens.
    #[prost(message, repeated, tag = "8")]
    pub tokens: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
    /// DelegatorShares define the total shares issued to an operator's delegators.
    #[prost(message, repeated, tag = "9")]
    pub delegator_shares:
        ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::DecCoin>,
}
/// OperatorParams represent the params that have been set for an individual
/// operator.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.OperatorParams")]
pub struct OperatorParams {
    /// CommissionRate defines the commission rate charged to delegators, as a
    /// fraction.
    #[prost(string, tag = "1")]
    pub commission_rate: ::prost::alloc::string::String,
}
/// OperatorStatus defines the possible statuses of an operator
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
#[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
pub enum OperatorStatus {
    /// OPERATOR_STATUS_UNSPECIFIED defines an unspecified status
    Unspecified = 0,
    /// OPERATOR_STATUS_ACTIVE identifies an active validator which is providing
    /// services
    Active = 1,
    /// OPERATOR_STATUS_INACTIVATING identifies an operator that is in the process
    /// of becoming inactive
    Inactivating = 2,
    /// OPERATOR_STATUS_INACTIVE defines an inactive operator that is not providing
    /// services
    Inactive = 3,
}
impl OperatorStatus {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            OperatorStatus::Unspecified => "OPERATOR_STATUS_UNSPECIFIED",
            OperatorStatus::Active => "OPERATOR_STATUS_ACTIVE",
            OperatorStatus::Inactivating => "OPERATOR_STATUS_INACTIVATING",
            OperatorStatus::Inactive => "OPERATOR_STATUS_INACTIVE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "OPERATOR_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
            "OPERATOR_STATUS_ACTIVE" => Some(Self::Active),
            "OPERATOR_STATUS_INACTIVATING" => Some(Self::Inactivating),
            "OPERATOR_STATUS_INACTIVE" => Some(Self::Inactive),
            _ => None,
        }
    }
}
/// Params defines the parameters for the operators module.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.Params")]
pub struct Params {
    /// OperatorRegistrationFee represents the fee that an operator must pay in
    /// order to register itself with the network.
    /// The fee is drawn from the MsgRegisterOperator sender's account and
    /// transferred to the community pool.
    #[prost(message, repeated, tag = "1")]
    pub operator_registration_fee:
        ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
    /// DeactivationTime represents the amount of time that will pass between
    /// the time that an operator signals its willingness to deactivate and the
    /// time that it actually becomes inactive.
    #[prost(int64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub deactivation_time: i64,
}
/// GenesisState defines the operators module's genesis state.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.GenesisState")]
pub struct GenesisState {
    /// Params defines the parameters of the module.
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
    /// NextOperatorID defines the ID that will be assigned to the
    /// next operator that gets created.
    #[prost(uint32, tag = "2")]
    #[serde(alias = "next_operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub next_operator_id: u32,
    /// Operators defines the list of operators.
    #[prost(message, repeated, tag = "3")]
    pub operators: ::prost::alloc::vec::Vec<Operator>,
    /// UnbondingOperators defines the list of operators that are currently being
    /// unbonded.
    #[prost(message, repeated, tag = "4")]
    pub unbonding_operators: ::prost::alloc::vec::Vec<UnbondingOperator>,
    /// OperatorsParams defines the list of operators params.
    #[prost(message, repeated, tag = "5")]
    pub operators_params: ::prost::alloc::vec::Vec<OperatorParamsRecord>,
}
/// UnbondingOperator contains the data about an operator that is currently being
/// unbonded.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.UnbondingOperator")]
pub struct UnbondingOperator {
    /// OperatorID is the ID of the operator that is being unbonded.
    #[prost(uint32, tag = "1")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
    /// UnbondingCompletionTime is the time at which the unbonding of the operator
    /// will be completed
    #[prost(message, optional, tag = "2")]
    pub unbonding_completion_time: ::core::option::Option<crate::shim::Timestamp>,
}
/// OperatorParamsRecord represents the params that have been set for an
/// individual operator.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.OperatorParamsRecord")]
pub struct OperatorParamsRecord {
    /// OperatorID is the ID of the operator.
    #[prost(uint32, tag = "1")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
    /// Params defines the parameters for the operators module.
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<OperatorParams>,
}
/// MsgRegisterOperator defines the message structure for the RegisterOperator
/// gRPC service method. It allows an account to register a new operator that can
/// opt-in to validate various services. It requires a sender address as well as
/// the details of the operator to be registered.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgRegisterOperator")]
pub struct MsgRegisterOperator {
    /// Sender is the address of the user registering the operator
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    /// Moniker is the moniker of the operator
    #[prost(string, tag = "2")]
    pub moniker: ::prost::alloc::string::String,
    /// Website is the website of the operator (optional)
    #[prost(string, tag = "3")]
    pub website: ::prost::alloc::string::String,
    /// PictureURL is the URL of operator picture (optional)
    #[prost(string, tag = "4")]
    pub picture_url: ::prost::alloc::string::String,
}
/// MsgRegisterOperatorResponse is the return value of MsgRegisterOperator.
/// It returns the newly created operator ID.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgRegisterOperatorResponse")]
pub struct MsgRegisterOperatorResponse {
    /// NewOperatorID is the ID of the newly registered operator
    #[prost(uint32, tag = "1")]
    #[serde(alias = "new_operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub new_operator_id: u32,
}
/// MsgUpdateOperator defines the message structure for the UpdateOperator gRPC
/// service method. It allows the operator owner to update the details of an
/// existing operator.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgUpdateOperator")]
pub struct MsgUpdateOperator {
    /// Sender is the address of the user updating the operator
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    /// OperatorID represents the ID of the operator to be updated
    #[prost(uint32, tag = "2")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
    /// Moniker is the new moniker of the operator.
    /// If it shouldn't be changed, use \[do-not-modify\] instead.
    #[prost(string, tag = "3")]
    pub moniker: ::prost::alloc::string::String,
    /// Website is the new website of the operator.
    /// If it shouldn't be changed, use \[do-not-modify\] instead.
    #[prost(string, tag = "4")]
    pub website: ::prost::alloc::string::String,
    /// PictureURL is the new URL of the operator picture.
    /// If it shouldn't be changed, use \[do-not-modify\] instead.
    #[prost(string, tag = "5")]
    pub picture_url: ::prost::alloc::string::String,
}
/// MsgUpdateOperatorResponse is the return value of MsgUpdateOperator.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgUpdateOperatorResponse")]
pub struct MsgUpdateOperatorResponse {}
/// MsgDeactivateOperator defines the message structure for the
/// DeactivateOperator gRPC service method. It allows the operator owner to
/// signal that the operator will become inactive. This should be used to signal
/// users that the operator is going to stop performing services and they should
/// switch to another operator.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgDeactivateOperator")]
pub struct MsgDeactivateOperator {
    /// Sender is the address of the user deactivating the operator
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    /// OperatorID represents the ID of the operator to be deregistered
    #[prost(uint32, tag = "2")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
}
/// MsgDeactivateOperatorResponse is the return value of MsgDeactivateOperator.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgDeactivateOperatorResponse")]
pub struct MsgDeactivateOperatorResponse {}
/// MsgDeleteOperator defines the message structure for the
/// DeleteOperator gRPC service method. It allows the operator owner to
/// delete a deactivated operator.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgDeleteOperator")]
pub struct MsgDeleteOperator {
    /// Sender is the address of the user deleting the operator
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    /// OperatorID represents the ID of the operator to be deleted
    #[prost(uint32, tag = "2")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
}
/// MsgDeleteOperatorResponse is the return value of MsgDeleteOperator.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgDeleteOperatorResponse")]
pub struct MsgDeleteOperatorResponse {}
/// MsgSetOperatorParams defines the message structure for the
/// SetOperatorParams gRPC service method. It allows the operator admin to
/// update the operator's parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgSetOperatorParams")]
pub struct MsgSetOperatorParams {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
    #[prost(message, optional, tag = "3")]
    pub params: ::core::option::Option<OperatorParams>,
}
/// MsgSetOperatorParamsResponse is the return value of
/// MsgSetOperatorParams.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgSetOperatorParamsResponse")]
pub struct MsgSetOperatorParamsResponse {}
/// MsgTransferOperatorOwnership defines the message structure for the
/// TransferOperatorOwnership gRPC service method. It allows an operator admin to
/// transfer the ownership of the operator to another account.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgTransferOperatorOwnership")]
pub struct MsgTransferOperatorOwnership {
    /// Sender is the address of the user transferring the ownership
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    /// OperatorID represents the ID of the operator to transfer ownership
    #[prost(uint32, tag = "2")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
    /// NewAdmin is the address of the new admin of the operator
    #[prost(string, tag = "3")]
    pub new_admin: ::prost::alloc::string::String,
}
/// MsgTransferOperatorOwnershipResponse is the return value of
/// MsgTransferOperatorOwnership.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgTransferOperatorOwnershipResponse")]
pub struct MsgTransferOperatorOwnershipResponse {}
/// MsgUpdateParams defines the message structure for the UpdateParams gRPC
/// service method. It allows the authority to update the module parameters.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgUpdateParams")]
pub struct MsgUpdateParams {
    /// Authority is the address that controls the module (defaults to x/gov unless
    /// overwritten).
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    /// Params define the parameters to update.
    ///
    /// NOTE: All parameters must be supplied.
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<Params>,
}
/// MsgUpdateParamsResponse is the return value of MsgUpdateParams.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.MsgUpdateParamsResponse")]
pub struct MsgUpdateParamsResponse {}
/// QueryOperatorRequest is the request type for the Query/Operator RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.QueryOperatorRequest")]
#[proto_query(
    path = "/milkyway.operators.v1.Query/Operator",
    response_type = QueryOperatorResponse
)]
pub struct QueryOperatorRequest {
    /// OperatorId is the ID of the operator to query
    #[prost(uint32, tag = "1")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
}
/// QueryOperatorResponse is the response type for the Query/Operator RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.QueryOperatorResponse")]
pub struct QueryOperatorResponse {
    #[prost(message, optional, tag = "1")]
    pub operator: ::core::option::Option<Operator>,
}
/// QueryOperatorParamsRequest is the request type for the Query/OperatorParams
/// RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.QueryOperatorParamsRequest")]
#[proto_query(
    path = "/milkyway.operators.v1.Query/OperatorParams",
    response_type = QueryOperatorParamsResponse
)]
pub struct QueryOperatorParamsRequest {
    /// OperatorID is the ID of the operator for which to query the params
    #[prost(uint32, tag = "1")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
}
/// QueryOperatorParamsResponse is the response type for the Query/OperatorParams
/// RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.QueryOperatorParamsResponse")]
pub struct QueryOperatorParamsResponse {
    #[prost(message, optional, tag = "1")]
    pub operator_params: ::core::option::Option<OperatorParams>,
}
/// QueryOperatorsRequest is the request type for the Query/Operators RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.QueryOperatorsRequest")]
#[proto_query(
    path = "/milkyway.operators.v1.Query/Operators",
    response_type = QueryOperatorsResponse
)]
pub struct QueryOperatorsRequest {
    #[prost(message, optional, tag = "1")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryOperatorsResponse is the response type for the Query/Operators RPC
/// method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.QueryOperatorsResponse")]
pub struct QueryOperatorsResponse {
    /// Operators is the list of operators
    #[prost(message, repeated, tag = "1")]
    pub operators: ::prost::alloc::vec::Vec<Operator>,
    /// Pagination defines the pagination response
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryParamsRequest is the request type for the Query/Params RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.QueryParamsRequest")]
#[proto_query(
    path = "/milkyway.operators.v1.Query/Params",
    response_type = QueryParamsResponse
)]
pub struct QueryParamsRequest {}
/// QueryParamsResponse is the response type for the Query/Params RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/milkyway.operators.v1.QueryParamsResponse")]
pub struct QueryParamsResponse {
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
}
pub struct OperatorsQuerier<'a, Q: cosmwasm_std::CustomQuery> {
    querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>,
}
impl<'a, Q: cosmwasm_std::CustomQuery> OperatorsQuerier<'a, Q> {
    pub fn new(querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>) -> Self {
        Self { querier }
    }
    pub fn operator(
        &self,
        operator_id: u32,
    ) -> Result<QueryOperatorResponse, cosmwasm_std::StdError> {
        QueryOperatorRequest { operator_id }.query(self.querier)
    }
    pub fn operator_params(
        &self,
        operator_id: u32,
    ) -> Result<QueryOperatorParamsResponse, cosmwasm_std::StdError> {
        QueryOperatorParamsRequest { operator_id }.query(self.querier)
    }
    pub fn operators(
        &self,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryOperatorsResponse, cosmwasm_std::StdError> {
        QueryOperatorsRequest { pagination }.query(self.querier)
    }
    pub fn params(&self) -> Result<QueryParamsResponse, cosmwasm_std::StdError> {
        QueryParamsRequest {}.query(self.querier)
    }
}
