use milkyway_std_derive::CosmwasmExt;
/// Delegation represents the bond with tokens held by an account with a
/// given target.
#[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.restaking.v1.Delegation")]
pub struct Delegation {
    /// Type is the type of delegation.
    #[prost(enumeration = "DelegationType", tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub r#type: i32,
    /// UserAddress is the encoded address of the user.
    #[prost(string, tag = "2")]
    pub user_address: ::prost::alloc::string::String,
    /// TargetID is the id of the target to which the delegation is associated
    /// (pool, operator, service).
    #[prost(uint32, tag = "3")]
    #[serde(alias = "targetID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub target_id: u32,
    /// Shares define the delegation shares received.
    #[prost(message, repeated, tag = "4")]
    pub shares: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::DecCoin>,
}
/// DelegationResponse is equivalent to Delegation except that it
/// contains a balance in addition to shares which is more suitable for client
/// responses.
#[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.restaking.v1.DelegationResponse")]
pub struct DelegationResponse {
    #[prost(message, optional, tag = "1")]
    pub delegation: ::core::option::Option<Delegation>,
    #[prost(message, repeated, tag = "2")]
    pub balance: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
}
/// UnbondingDelegation stores all of a single delegator's unbonding bonds
/// for a single target in an time-ordered list.
#[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.restaking.v1.UnbondingDelegation")]
pub struct UnbondingDelegation {
    /// Type is the type of the unbonding delegation.
    #[prost(enumeration = "DelegationType", tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub r#type: i32,
    /// DelegatorAddress is the encoded address of the delegator.
    #[prost(string, tag = "2")]
    pub delegator_address: ::prost::alloc::string::String,
    /// TargetID is the ID of the target from which the tokens will be undelegated
    /// (pool, service, operator)
    #[prost(uint32, tag = "3")]
    #[serde(alias = "targetID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub target_id: u32,
    /// Entries are the unbonding delegation entries.
    ///
    /// unbonding delegation entries
    #[prost(message, repeated, tag = "4")]
    pub entries: ::prost::alloc::vec::Vec<UnbondingDelegationEntry>,
}
/// UnbondingDelegationEntry defines an unbonding object with relevant metadata.
#[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.restaking.v1.UnbondingDelegationEntry")]
pub struct UnbondingDelegationEntry {
    /// CreationHeight is the height which the unbonding took place.
    #[prost(int64, tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub creation_height: i64,
    /// CompletionTime is the unix time for unbonding completion.
    #[prost(message, optional, tag = "2")]
    pub completion_time: ::core::option::Option<crate::shim::Timestamp>,
    /// InitialBalance defines the tokens initially scheduled to receive at
    /// completion.
    #[prost(message, repeated, tag = "3")]
    pub initial_balance: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
    /// Balance defines the tokens to receive at completion.
    #[prost(message, repeated, tag = "4")]
    pub balance: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
    /// Incrementing id that uniquely identifies this entry
    #[prost(uint64, tag = "5")]
    #[serde(alias = "unbondingID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub unbonding_id: u64,
}
/// DTData is a struct that contains the basic information about an unbonding
/// delegation. It is intended to be used as a marshalable pointer. For example,
/// a DTData can be used to construct the key to getting an UnbondingDelegation
/// from 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.restaking.v1.DTData")]
pub struct DtData {
    #[prost(enumeration = "DelegationType", tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub unbonding_delegation_type: i32,
    #[prost(string, tag = "2")]
    pub delegator_address: ::prost::alloc::string::String,
    #[prost(uint32, tag = "3")]
    #[serde(alias = "targetID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub target_id: u32,
}
/// DTDataList defines an array of DTData objects.
#[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.restaking.v1.DTDataList")]
pub struct DtDataList {
    #[prost(message, repeated, tag = "1")]
    pub data: ::prost::alloc::vec::Vec<DtData>,
}
/// DelegationType defines the type of delegation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
#[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
pub enum DelegationType {
    Unspecified = 0,
    Pool = 1,
    Operator = 2,
    Service = 3,
}
impl DelegationType {
    /// 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 {
            DelegationType::Unspecified => "DELEGATION_TYPE_UNSPECIFIED",
            DelegationType::Pool => "DELEGATION_TYPE_POOL",
            DelegationType::Operator => "DELEGATION_TYPE_OPERATOR",
            DelegationType::Service => "DELEGATION_TYPE_SERVICE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DELEGATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
            "DELEGATION_TYPE_POOL" => Some(Self::Pool),
            "DELEGATION_TYPE_OPERATOR" => Some(Self::Operator),
            "DELEGATION_TYPE_SERVICE" => Some(Self::Service),
            _ => None,
        }
    }
}
/// Params defines the parameters for the 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.restaking.v1.Params")]
pub struct Params {
    /// UnbondingTime represents the time that will take for assets to be unbonded
    /// after the user initiates an unbonding request. This will be applied to all
    /// types of restaking: pool, operator and service restaking.
    #[prost(int64, tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub unbonding_time: i64,
}
/// OperatorJoinedServicesRecord represents the services joined by a
/// 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.restaking.v1.OperatorJoinedServices")]
pub struct OperatorJoinedServices {
    /// 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,
    /// ServiceIDs represents the list of services joined by the operator.
    #[prost(uint32, repeated, packed = "false", tag = "2")]
    #[serde(alias = "serviceIDs")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub service_ids: ::prost::alloc::vec::Vec<u32>,
}
/// ServiceAllowedOperators represents the operators allowed to secure a
/// a service.
#[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.restaking.v1.ServiceAllowedOperators")]
pub struct ServiceAllowedOperators {
    /// ServiceID is the ID of the service.
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// OperatorIDs defines the allowed operator IDs.
    #[prost(uint32, repeated, packed = "false", tag = "2")]
    #[serde(alias = "operatorIDs")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub operator_ids: ::prost::alloc::vec::Vec<u32>,
}
/// ServiceSecuringPools represents the list pools from which a service can
/// borrow security
#[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.restaking.v1.ServiceSecuringPools")]
pub struct ServiceSecuringPools {
    /// ServiceID is the ID of the service.
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// PoolIDs defines the IDs of the pools from which the service can borrow
    /// security.
    #[prost(uint32, repeated, packed = "false", tag = "2")]
    #[serde(alias = "poolIDs")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub pool_ids: ::prost::alloc::vec::Vec<u32>,
}
/// GenesisState defines the restaking 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.restaking.v1.GenesisState")]
pub struct GenesisState {
    /// Params defines the parameters of the module.
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
    /// OperatorsJoinedServices defines the list of the services that each operator
    /// has joined.
    #[prost(message, repeated, tag = "2")]
    pub operators_joined_services: ::prost::alloc::vec::Vec<OperatorJoinedServices>,
    /// ServiceAllowedOperators defines the operators allowed to secure each
    /// service.
    #[prost(message, repeated, tag = "3")]
    pub services_allowed_operators: ::prost::alloc::vec::Vec<ServiceAllowedOperators>,
    /// ServicesSecuringPools defines the whitelisted pools for each service.
    #[prost(message, repeated, tag = "4")]
    pub services_securing_pools: ::prost::alloc::vec::Vec<ServiceSecuringPools>,
    /// Delegations represents the delegations.
    #[prost(message, repeated, tag = "5")]
    pub delegations: ::prost::alloc::vec::Vec<Delegation>,
    /// UnbondingDelegations represents the unbonding delegations.
    #[prost(message, repeated, tag = "6")]
    pub unbonding_delegations: ::prost::alloc::vec::Vec<UnbondingDelegation>,
}
/// MsgJoinService defines the message structure for the
/// JoinService gRPC service method. It allows the opeator admin to
/// start securing a AVS.
#[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.restaking.v1.MsgJoinService")]
pub struct MsgJoinService {
    #[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(uint32, tag = "3")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
}
/// MsgJoinServiceResponse is the return value of MsgJoinService.
#[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.restaking.v1.MsgJoinServiceResponse")]
pub struct MsgJoinServiceResponse {}
/// MsgLeaveService defines the message structure for the
/// LeaveService gRPC service method. It allows the opeator admin to
/// stop securing a AVS.
#[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.restaking.v1.MsgLeaveService")]
pub struct MsgLeaveService {
    #[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(uint32, tag = "3")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
}
/// MsgLeaveerviceResponse is the return value of MsgLeveService.
#[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.restaking.v1.MsgLeaveServiceResponse")]
pub struct MsgLeaveServiceResponse {}
/// MsgAddOperatorToAllowList defines the message structure for the
/// AddOperatorToAllowList gRPC service method. It allows the service admin
/// to add an operator to the list of allowed operator to secure the service.
#[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.restaking.v1.MsgAddOperatorToAllowList")]
pub struct MsgAddOperatorToAllowList {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    #[prost(uint32, tag = "3")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
}
/// MsgAddOperatorToAllowListResponse is the return value of
/// MsgAddOperatorToAllowList.
#[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.restaking.v1.MsgAddOperatorToAllowListResponse")]
pub struct MsgAddOperatorToAllowListResponse {}
/// MsgRemoveOperatorFromAllowlist defines the message structure for the
/// RemoveOperatorFromAllowlist gRPC service method. It allows the service admin
/// to remove a previously added operator from the list of allowed operators
/// to secure the service.
#[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.restaking.v1.MsgRemoveOperatorFromAllowlist")]
pub struct MsgRemoveOperatorFromAllowlist {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    #[prost(uint32, tag = "3")]
    #[serde(alias = "operatorID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub operator_id: u32,
}
/// MsgRemoveOperatorFromAllowlistResponse is the return value of
/// MsgRemoveOperatorFromAllowlist.
#[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.restaking.v1.MsgRemoveOperatorFromAllowlistResponse")]
pub struct MsgRemoveOperatorFromAllowlistResponse {}
/// MsgBorrowPoolSecurity defines the message structure for the
/// BorrowPoolSecurity gRPC service method. It allows the service admin
/// to add a pool to the list of pools from which the service has chosen
/// to borrow security.
#[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.restaking.v1.MsgBorrowPoolSecurity")]
pub struct MsgBorrowPoolSecurity {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    #[prost(uint32, tag = "3")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u32,
}
/// MsgBorrowPoolSecurityResponse is the return value of MsgBorrowPoolSecurity.
#[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.restaking.v1.MsgBorrowPoolSecurityResponse")]
pub struct MsgBorrowPoolSecurityResponse {}
/// MsgCeasePoolSecurityBorrow defines the message structure for the
/// CeaseBorrowPoolSecurity gRPC service method. It allows the service admin
/// to remove a pool from the list of pools from which the service has chosen
/// to borrow security.
#[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.restaking.v1.MsgCeasePoolSecurityBorrow")]
pub struct MsgCeasePoolSecurityBorrow {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    #[prost(uint32, tag = "3")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u32,
}
/// MsgCeasePoolSecurityBorrowResponse is the return value of
/// MsgCeasePoolSecurityBorrow.
#[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.restaking.v1.MsgCeasePoolSecurityBorrowResponse")]
pub struct MsgCeasePoolSecurityBorrowResponse {}
/// MsgDelegatePool defines the message structure for the DelegatePool gRPC
/// service method. It allows a user to put their assets into a restaking pool
/// that will later be used to provide cryptoeconomic security to services that
/// choose it.
#[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.restaking.v1.MsgDelegatePool")]
pub struct MsgDelegatePool {
    /// Delegator is the address of the user joining the pool
    #[prost(string, tag = "1")]
    pub delegator: ::prost::alloc::string::String,
    /// Amount is the amount of coins to be staked
    #[prost(message, optional, tag = "2")]
    pub amount: ::core::option::Option<super::super::super::cosmos::base::v1beta1::Coin>,
}
/// MsgDelegatePoolResponse defines the return value of MsgDelegatePool.
#[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.restaking.v1.MsgDelegatePoolResponse")]
pub struct MsgDelegatePoolResponse {}
/// MsgDelegateOperator defines the message structure for the DelegateOperator
/// gRPC service method. It allows a user to delegate their assets to 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.restaking.v1.MsgDelegateOperator")]
pub struct MsgDelegateOperator {
    /// Delegator is the address of the user delegating to the operator
    #[prost(string, tag = "1")]
    pub delegator: ::prost::alloc::string::String,
    /// OperatorID is the ID of the operator to delegate to
    #[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,
    /// Amount is the amount of coins to be delegated
    #[prost(message, repeated, tag = "3")]
    pub amount: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
}
/// MsgDelegateOperatorResponse is the return value of MsgDelegateOperator.
#[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.restaking.v1.MsgDelegateOperatorResponse")]
pub struct MsgDelegateOperatorResponse {}
/// MsgDelegateService defines the message structure for the DelegateService gRPC
/// service method. It allows a user to delegate their assets to a service.
#[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.restaking.v1.MsgDelegateService")]
pub struct MsgDelegateService {
    /// Delegator is the address of the user delegating to the service
    #[prost(string, tag = "1")]
    pub delegator: ::prost::alloc::string::String,
    /// ServiceID is the ID of the service to delegate to
    #[prost(uint32, tag = "2")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// Amount is the amount of coins to be delegated
    #[prost(message, repeated, tag = "3")]
    pub amount: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
}
/// MsgDelegateServiceResponse is the return value of MsgDelegateService.
#[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.restaking.v1.MsgDelegateServiceResponse")]
pub struct MsgDelegateServiceResponse {}
/// 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.restaking.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.restaking.v1.MsgUpdateParamsResponse")]
pub struct MsgUpdateParamsResponse {}
/// MsgUndelegatePool the message structure for the UndelegatePool gRPC service
/// method. It allows a user to undelegate their assets from a restaking pool.
#[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.restaking.v1.MsgUndelegatePool")]
pub struct MsgUndelegatePool {
    /// Delegator is the address of the user undelegating from the pool.
    #[prost(string, tag = "1")]
    pub delegator: ::prost::alloc::string::String,
    /// Amount is the amount of coins to be undelegated.
    #[prost(message, optional, tag = "2")]
    pub amount: ::core::option::Option<super::super::super::cosmos::base::v1beta1::Coin>,
}
/// MsgUndelegateOperator the message structure for the UndelegateOperator gRPC
/// service method. It allows a user to undelegate their assets from a restaking
/// 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.restaking.v1.MsgUndelegateOperator")]
pub struct MsgUndelegateOperator {
    /// Delegator is the address of the user undelegating from the operator.
    #[prost(string, tag = "1")]
    pub delegator: ::prost::alloc::string::String,
    /// OperatorID is the ID of the operator to undelegate from.
    #[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,
    /// Amount is the amount of coins to be undelegated.
    #[prost(message, repeated, tag = "3")]
    pub amount: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
}
/// MsgUndelegateService the message structure for the UndelegateService gRPC
/// service method. It allows a user to undelegate their assets from a restaking
/// service.
#[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.restaking.v1.MsgUndelegateService")]
pub struct MsgUndelegateService {
    /// Delegator is the address of the user undelegating from the service.
    #[prost(string, tag = "1")]
    pub delegator: ::prost::alloc::string::String,
    /// ServiceID is the ID of the service to undelegate from.
    #[prost(uint32, tag = "2")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// Amount is the amount of coins to be undelegated.
    #[prost(message, repeated, tag = "3")]
    pub amount: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
}
/// MsgUndelegateResponse defines the response type for the undelegation methods.
#[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.restaking.v1.MsgUndelegateResponse")]
pub struct MsgUndelegateResponse {
    /// CompletionTime represents the time at which the undelegation will be
    /// complete
    #[prost(message, optional, tag = "1")]
    pub completion_time: ::core::option::Option<crate::shim::Timestamp>,
}
/// QueryOperatorJoinedServicesRequest is request type for the
/// Query/OperatorJoinedServices 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.restaking.v1.QueryOperatorJoinedServicesRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/OperatorJoinedServices",
    response_type = QueryOperatorJoinedServicesResponse
)]
pub struct QueryOperatorJoinedServicesRequest {
    /// 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,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryOperatorJoinedServicesResponse is response type for the
/// Query/OperatorJoinedServices 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.restaking.v1.QueryOperatorJoinedServicesResponse")]
pub struct QueryOperatorJoinedServicesResponse {
    /// ServiceIds is the list of services joined by the operator.
    #[prost(uint32, repeated, tag = "1")]
    #[serde(alias = "serviceIDs")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub service_ids: ::prost::alloc::vec::Vec<u32>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryServiceAllowedOperatorsRequest is request type for the
/// Query/ServiceAllowedOperators 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.restaking.v1.QueryServiceAllowedOperatorsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/ServiceAllowedOperators",
    response_type = QueryServiceAllowedOperatorsResponse
)]
pub struct QueryServiceAllowedOperatorsRequest {
    /// ServiceId is the ID of the service to query
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryServiceAllowedOperatorsResponse is response type for the
/// Query/ServiceAllowedOperators 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.restaking.v1.QueryServiceAllowedOperatorsResponse")]
pub struct QueryServiceAllowedOperatorsResponse {
    /// OperatorIds is the list of operators allowed to validate the service
    #[prost(uint32, repeated, tag = "1")]
    #[serde(alias = "operatorIDs")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub operator_ids: ::prost::alloc::vec::Vec<u32>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryServiceSecuringPoolsRequest is request type for the
/// Query/ServiceSecuringPools 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.restaking.v1.QueryServiceSecuringPoolsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/ServiceSecuringPools",
    response_type = QueryServiceSecuringPoolsResponse
)]
pub struct QueryServiceSecuringPoolsRequest {
    /// ServiceId is the ID of the service to query.
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryServiceSecuringPoolsResponse is response type for the
/// Query/ServiceSecuringPools 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.restaking.v1.QueryServiceSecuringPoolsResponse")]
pub struct QueryServiceSecuringPoolsResponse {
    /// PoolIds is the list of pools from which the service is allowed to borrow
    /// security.
    #[prost(uint32, repeated, tag = "1")]
    #[serde(alias = "poolIDs")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub pool_ids: ::prost::alloc::vec::Vec<u32>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryServiceOperatorsRequest is request type for the Query/ServiceOperators
/// 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.restaking.v1.QueryServiceOperatorsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/ServiceOperators",
    response_type = QueryServiceOperatorsResponse
)]
pub struct QueryServiceOperatorsRequest {
    /// ServiceId is the ID of the service to query
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryServiceOperatorsResponse is response type for the Query/ServiceOperators
/// 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.restaking.v1.QueryServiceOperatorsResponse")]
pub struct QueryServiceOperatorsResponse {
    /// Operators is the list of operators
    #[prost(message, repeated, tag = "1")]
    pub operators: ::prost::alloc::vec::Vec<super::super::operators::v1::Operator>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryPoolDelegationsRequest is request type for the Query/PoolDelegations 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.restaking.v1.QueryPoolDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/PoolDelegations",
    response_type = QueryPoolDelegationsResponse
)]
pub struct QueryPoolDelegationsRequest {
    /// PoolId is the ID of the pool to query.
    #[prost(uint32, tag = "1")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u32,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryPoolDelegationsResponse is response type for the Query/PoolDelegations
/// 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.restaking.v1.QueryPoolDelegationsResponse")]
pub struct QueryPoolDelegationsResponse {
    /// Delegations is the list of delegations.
    #[prost(message, repeated, tag = "1")]
    pub delegations: ::prost::alloc::vec::Vec<DelegationResponse>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryPoolDelegationRequest is request type for the Query/PoolDelegation 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.restaking.v1.QueryPoolDelegationRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/PoolDelegation",
    response_type = QueryPoolDelegationResponse
)]
pub struct QueryPoolDelegationRequest {
    /// PoolId is the ID of the pool to query
    #[prost(uint32, tag = "1")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u32,
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "2")]
    pub delegator_address: ::prost::alloc::string::String,
}
/// QueryPoolDelegationResponse is response type for the Query/PoolDelegation 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.restaking.v1.QueryPoolDelegationResponse")]
pub struct QueryPoolDelegationResponse {
    /// Delegation is the delegation
    #[prost(message, optional, tag = "1")]
    pub delegation: ::core::option::Option<DelegationResponse>,
}
/// QueryPoolUnbondingDelegationsRequest is request type for the
/// Query/PoolUnbondingDelegations 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.restaking.v1.QueryPoolUnbondingDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/PoolUnbondingDelegations",
    response_type = QueryPoolUnbondingDelegationsResponse
)]
pub struct QueryPoolUnbondingDelegationsRequest {
    #[prost(uint32, tag = "1")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u32,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryPoolUnbondingDelegationsResponse is response type for the
/// Query/PoolUnbondingDelegations 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.restaking.v1.QueryPoolUnbondingDelegationsResponse")]
pub struct QueryPoolUnbondingDelegationsResponse {
    #[prost(message, repeated, tag = "1")]
    pub unbonding_delegations: ::prost::alloc::vec::Vec<UnbondingDelegation>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryPoolUnbondingDelegationRequest is request type for the
/// Query/PoolUnbondingDelegation 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.restaking.v1.QueryPoolUnbondingDelegationRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/PoolUnbondingDelegation",
    response_type = QueryPoolUnbondingDelegationResponse
)]
pub struct QueryPoolUnbondingDelegationRequest {
    #[prost(uint32, tag = "1")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u32,
    #[prost(string, tag = "2")]
    pub delegator_address: ::prost::alloc::string::String,
}
/// QueryPoolUnbondingDelegationResponse is response type for the
/// Query/PoolUnbondingDelegation 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.restaking.v1.QueryPoolUnbondingDelegationResponse")]
pub struct QueryPoolUnbondingDelegationResponse {
    #[prost(message, optional, tag = "1")]
    pub unbonding_delegation: ::core::option::Option<UnbondingDelegation>,
}
/// QueryOperatorDelegationsRequest is request type for the
/// Query/OperatorDelegations 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.restaking.v1.QueryOperatorDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/OperatorDelegations",
    response_type = QueryOperatorDelegationsResponse
)]
pub struct QueryOperatorDelegationsRequest {
    /// 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,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryOperatorDelegationsResponse is response type for the
/// Query/OperatorDelegations 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.restaking.v1.QueryOperatorDelegationsResponse")]
pub struct QueryOperatorDelegationsResponse {
    /// Delegations is the list of delegations
    #[prost(message, repeated, tag = "1")]
    pub delegations: ::prost::alloc::vec::Vec<DelegationResponse>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryOperatorDelegationRequest is request type for the
/// Query/OperatorDelegation 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.restaking.v1.QueryOperatorDelegationRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/OperatorDelegation",
    response_type = QueryOperatorDelegationResponse
)]
pub struct QueryOperatorDelegationRequest {
    /// 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,
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "2")]
    pub delegator_address: ::prost::alloc::string::String,
}
/// QueryOperatorDelegationResponse is response type for the
/// Query/OperatorDelegation 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.restaking.v1.QueryOperatorDelegationResponse")]
pub struct QueryOperatorDelegationResponse {
    /// Delegation is the delegation
    #[prost(message, optional, tag = "1")]
    pub delegation: ::core::option::Option<DelegationResponse>,
}
/// QueryOperatorUnbondingDelegationsRequest is request type for the
/// Query/OperatorUnbondingDelegations 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.restaking.v1.QueryOperatorUnbondingDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/OperatorUnbondingDelegations",
    response_type = QueryOperatorUnbondingDelegationsResponse
)]
pub struct QueryOperatorUnbondingDelegationsRequest {
    /// 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,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryOperatorUnbondingDelegationsResponse is response type for the
/// Query/OperatorUnbondingDelegations 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.restaking.v1.QueryOperatorUnbondingDelegationsResponse")]
pub struct QueryOperatorUnbondingDelegationsResponse {
    /// UnbondingDelegations is the list of unbonding delegations
    #[prost(message, repeated, tag = "1")]
    pub unbonding_delegations: ::prost::alloc::vec::Vec<UnbondingDelegation>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryOperatorUnbondingDelegationRequest is request type for the
/// Query/OperatorUnbondingDelegation 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.restaking.v1.QueryOperatorUnbondingDelegationRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/OperatorUnbondingDelegation",
    response_type = QueryOperatorUnbondingDelegationResponse
)]
pub struct QueryOperatorUnbondingDelegationRequest {
    /// 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,
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "2")]
    pub delegator_address: ::prost::alloc::string::String,
}
/// QueryOperatorUnbondingDelegationResponse is response type for the
/// Query/OperatorUnbondingDelegation 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.restaking.v1.QueryOperatorUnbondingDelegationResponse")]
pub struct QueryOperatorUnbondingDelegationResponse {
    /// UnbondingDelegation is the unbonding delegation
    #[prost(message, optional, tag = "1")]
    pub unbonding_delegation: ::core::option::Option<UnbondingDelegation>,
}
/// QueryServiceDelegationsRequest is request type for the
/// Query/ServiceDelegations 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.restaking.v1.QueryServiceDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/ServiceDelegations",
    response_type = QueryServiceDelegationsResponse
)]
pub struct QueryServiceDelegationsRequest {
    /// ServiceId is the ID of the service to query
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryServiceDelegationsResponse is response type for the
/// Query/ServiceDelegations 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.restaking.v1.QueryServiceDelegationsResponse")]
pub struct QueryServiceDelegationsResponse {
    /// Delegations is the list of delegations
    #[prost(message, repeated, tag = "1")]
    pub delegations: ::prost::alloc::vec::Vec<DelegationResponse>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryServiceDelegationRequest is request type for the Query/ServiceDelegation
/// 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.restaking.v1.QueryServiceDelegationRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/ServiceDelegation",
    response_type = QueryServiceDelegationResponse
)]
pub struct QueryServiceDelegationRequest {
    /// ServiceId is the ID of the service to query
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "2")]
    pub delegator_address: ::prost::alloc::string::String,
}
/// QueryServiceDelegationResponse is response type for the
/// Query/ServiceDelegation 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.restaking.v1.QueryServiceDelegationResponse")]
pub struct QueryServiceDelegationResponse {
    /// Delegation is the delegation
    #[prost(message, optional, tag = "1")]
    pub delegation: ::core::option::Option<DelegationResponse>,
}
/// QueryServiceUnbondingDelegationsRequest is request type for the
/// Query/ServiceUnbondingDelegations 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.restaking.v1.QueryServiceUnbondingDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/ServiceUnbondingDelegations",
    response_type = QueryServiceUnbondingDelegationsResponse
)]
pub struct QueryServiceUnbondingDelegationsRequest {
    /// ServiceId is the ID of the service to query
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryServiceUnbondingDelegationsResponse is response type for the
/// Query/ServiceUnbondingDelegations 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.restaking.v1.QueryServiceUnbondingDelegationsResponse")]
pub struct QueryServiceUnbondingDelegationsResponse {
    /// UnbondingDelegations is the list of unbonding delegations
    #[prost(message, repeated, tag = "1")]
    pub unbonding_delegations: ::prost::alloc::vec::Vec<UnbondingDelegation>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryServiceUnbondingDelegationRequest is request type for the
/// Query/ServiceUnbondingDelegation 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.restaking.v1.QueryServiceUnbondingDelegationRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/ServiceUnbondingDelegation",
    response_type = QueryServiceUnbondingDelegationResponse
)]
pub struct QueryServiceUnbondingDelegationRequest {
    /// ServiceId is the ID of the service to query
    #[prost(uint32, tag = "1")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "2")]
    pub delegator_address: ::prost::alloc::string::String,
}
/// QueryServiceUnbondingDelegationResponse is response type for the
/// Query/ServiceUnbondingDelegation 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.restaking.v1.QueryServiceUnbondingDelegationResponse")]
pub struct QueryServiceUnbondingDelegationResponse {
    /// UnbondingDelegation is the unbonding delegation
    #[prost(message, optional, tag = "1")]
    pub unbonding_delegation: ::core::option::Option<UnbondingDelegation>,
}
/// QueryDelegatorPoolDelegationsRequest is request type for the
/// Query/DelegatorPoolDelegations 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.restaking.v1.QueryDelegatorPoolDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorPoolDelegations",
    response_type = QueryDelegatorPoolDelegationsResponse
)]
pub struct QueryDelegatorPoolDelegationsRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorPoolDelegationsResponse is response type for the
/// Query/DelegatorPoolDelegations 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.restaking.v1.QueryDelegatorPoolDelegationsResponse")]
pub struct QueryDelegatorPoolDelegationsResponse {
    /// Delegations is the list of delegations
    #[prost(message, repeated, tag = "1")]
    pub delegations: ::prost::alloc::vec::Vec<DelegationResponse>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorPoolUnbondingDelegationsRequest is request type for the
/// Query/DelegatorPoolUnbondingDelegations 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.restaking.v1.QueryDelegatorPoolUnbondingDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorPoolUnbondingDelegations",
    response_type = QueryDelegatorPoolUnbondingDelegationsResponse
)]
pub struct QueryDelegatorPoolUnbondingDelegationsRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorPoolUnbondingDelegationsResponse is response type for the
/// Query/DelegatorPoolUnbondingDelegations 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.restaking.v1.QueryDelegatorPoolUnbondingDelegationsResponse")]
pub struct QueryDelegatorPoolUnbondingDelegationsResponse {
    /// UnbondingDelegations is the list of unbonding delegations
    #[prost(message, repeated, tag = "1")]
    pub unbonding_delegations: ::prost::alloc::vec::Vec<UnbondingDelegation>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorOperatorDelegationsRequest is request type for the
/// Query/DelegatorOperatorDelegations 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.restaking.v1.QueryDelegatorOperatorDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorOperatorDelegations",
    response_type = QueryDelegatorOperatorDelegationsResponse
)]
pub struct QueryDelegatorOperatorDelegationsRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorOperatorDelegationsResponse is response type for the
/// Query/DelegatorOperatorDelegations 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.restaking.v1.QueryDelegatorOperatorDelegationsResponse")]
pub struct QueryDelegatorOperatorDelegationsResponse {
    /// Delegations is the list of delegations
    #[prost(message, repeated, tag = "1")]
    pub delegations: ::prost::alloc::vec::Vec<DelegationResponse>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorOperatorUnbondingDelegationsRequest is request type for the
/// Query/DelegatorOperatorUnbondingDelegations 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.restaking.v1.QueryDelegatorOperatorUnbondingDelegationsRequest"
)]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorOperatorUnbondingDelegations",
    response_type = QueryDelegatorOperatorUnbondingDelegationsResponse
)]
pub struct QueryDelegatorOperatorUnbondingDelegationsRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorOperatorUnbondingDelegationsResponse is response type for the
/// Query/DelegatorOperatorUnbondingDelegations 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.restaking.v1.QueryDelegatorOperatorUnbondingDelegationsResponse"
)]
pub struct QueryDelegatorOperatorUnbondingDelegationsResponse {
    /// UnbondingDelegations is the list of unbonding delegations
    #[prost(message, repeated, tag = "1")]
    pub unbonding_delegations: ::prost::alloc::vec::Vec<UnbondingDelegation>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorServiceDelegationsRequest is request type for the
/// Query/DelegatorServiceDelegations 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.restaking.v1.QueryDelegatorServiceDelegationsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorServiceDelegations",
    response_type = QueryDelegatorServiceDelegationsResponse
)]
pub struct QueryDelegatorServiceDelegationsRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorServiceDelegationsResponse is response type for the
/// Query/DelegatorServiceDelegations 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.restaking.v1.QueryDelegatorServiceDelegationsResponse")]
pub struct QueryDelegatorServiceDelegationsResponse {
    /// Delegations is the list of delegations
    #[prost(message, repeated, tag = "1")]
    pub delegations: ::prost::alloc::vec::Vec<DelegationResponse>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorServiceUnbondingDelegationsRequest is request type for the
/// Query/DelegatorServiceUnbondingDelegations 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.restaking.v1.QueryDelegatorServiceUnbondingDelegationsRequest"
)]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorServiceUnbondingDelegations",
    response_type = QueryDelegatorServiceUnbondingDelegationsResponse
)]
pub struct QueryDelegatorServiceUnbondingDelegationsRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorServiceUnbondingDelegationsResponse is response type for the
/// Query/DelegatorServiceUnbondingDelegations 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.restaking.v1.QueryDelegatorServiceUnbondingDelegationsResponse"
)]
pub struct QueryDelegatorServiceUnbondingDelegationsResponse {
    /// UnbondingDelegations is the list of unbonding delegations
    #[prost(message, repeated, tag = "1")]
    pub unbonding_delegations: ::prost::alloc::vec::Vec<UnbondingDelegation>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorPoolsRequest is request type for the Query/DelegatorPools 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.restaking.v1.QueryDelegatorPoolsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorPools",
    response_type = QueryDelegatorPoolsResponse
)]
pub struct QueryDelegatorPoolsRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorPoolsResponse is response type for the Query/DelegatorPools 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.restaking.v1.QueryDelegatorPoolsResponse")]
pub struct QueryDelegatorPoolsResponse {
    /// Pools is the list of pools
    #[prost(message, repeated, tag = "1")]
    pub pools: ::prost::alloc::vec::Vec<super::super::pools::v1::Pool>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorPoolRequest is request type for the Query/DelegatorPool 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.restaking.v1.QueryDelegatorPoolRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorPool",
    response_type = QueryDelegatorPoolResponse
)]
pub struct QueryDelegatorPoolRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// PoolId is the ID of the pool to query
    #[prost(uint32, tag = "2")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u32,
}
/// QueryDelegatorPoolResponse is response type for the Query/DelegatorPool 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.restaking.v1.QueryDelegatorPoolResponse")]
pub struct QueryDelegatorPoolResponse {
    /// Pool is the pool
    #[prost(message, optional, tag = "1")]
    pub pool: ::core::option::Option<super::super::pools::v1::Pool>,
}
/// QueryDelegatorOperatorsRequest is request type for the
/// Query/DelegatorOperators 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.restaking.v1.QueryDelegatorOperatorsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorOperators",
    response_type = QueryDelegatorOperatorsResponse
)]
pub struct QueryDelegatorOperatorsRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorOperatorsResponse is response type for the
/// Query/DelegatorOperators 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.restaking.v1.QueryDelegatorOperatorsResponse")]
pub struct QueryDelegatorOperatorsResponse {
    /// Operators is the list of operators
    #[prost(message, repeated, tag = "1")]
    pub operators: ::prost::alloc::vec::Vec<super::super::operators::v1::Operator>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorOperatorRequest is request type for the Query/DelegatorOperator
/// 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.restaking.v1.QueryDelegatorOperatorRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorOperator",
    response_type = QueryDelegatorOperatorResponse
)]
pub struct QueryDelegatorOperatorRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// OperatorId is the ID of the operator to query
    #[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,
}
/// QueryDelegatorOperatorResponse is response type for the
/// Query/DelegatorOperator 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.restaking.v1.QueryDelegatorOperatorResponse")]
pub struct QueryDelegatorOperatorResponse {
    /// Operator is the operator
    #[prost(message, optional, tag = "1")]
    pub operator: ::core::option::Option<super::super::operators::v1::Operator>,
}
/// QueryDelegatorServicesRequest is request type for the Query/DelegatorServices
/// 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.restaking.v1.QueryDelegatorServicesRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorServices",
    response_type = QueryDelegatorServicesResponse
)]
pub struct QueryDelegatorServicesRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// Pagination defines an optional pagination for the request.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageRequest>,
}
/// QueryDelegatorServicesResponse is response type for the
/// Query/DelegatorServices 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.restaking.v1.QueryDelegatorServicesResponse")]
pub struct QueryDelegatorServicesResponse {
    /// Services is the list of services
    #[prost(message, repeated, tag = "1")]
    pub services: ::prost::alloc::vec::Vec<super::super::services::v1::Service>,
    /// Pagination defines the pagination in the response.
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// QueryDelegatorServiceRequest is request type for the Query/DelegatorService
/// 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.restaking.v1.QueryDelegatorServiceRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/DelegatorService",
    response_type = QueryDelegatorServiceResponse
)]
pub struct QueryDelegatorServiceRequest {
    /// DelegatorAddress is the address of the delegator to query
    #[prost(string, tag = "1")]
    pub delegator_address: ::prost::alloc::string::String,
    /// ServiceId is the ID of the service to query
    #[prost(uint32, tag = "2")]
    #[serde(alias = "serviceID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub service_id: u32,
}
/// QueryDelegatorServiceResponse is response type for the Query/DelegatorService
/// 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.restaking.v1.QueryDelegatorServiceResponse")]
pub struct QueryDelegatorServiceResponse {
    /// Service is the service
    #[prost(message, optional, tag = "1")]
    pub service: ::core::option::Option<super::super::services::v1::Service>,
}
/// QueryParamsRequest is 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.restaking.v1.QueryParamsRequest")]
#[proto_query(
    path = "/milkyway.restaking.v1.Query/Params",
    response_type = QueryParamsResponse
)]
pub struct QueryParamsRequest {}
/// QueryParamsResponse is 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.restaking.v1.QueryParamsResponse")]
pub struct QueryParamsResponse {
    /// params holds all the parameters of this module.
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
}
pub struct RestakingQuerier<'a, Q: cosmwasm_std::CustomQuery> {
    querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>,
}
impl<'a, Q: cosmwasm_std::CustomQuery> RestakingQuerier<'a, Q> {
    pub fn new(querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>) -> Self {
        Self { querier }
    }
    pub fn operator_joined_services(
        &self,
        operator_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryOperatorJoinedServicesResponse, cosmwasm_std::StdError> {
        QueryOperatorJoinedServicesRequest {
            operator_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn service_allowed_operators(
        &self,
        service_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryServiceAllowedOperatorsResponse, cosmwasm_std::StdError> {
        QueryServiceAllowedOperatorsRequest {
            service_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn service_securing_pools(
        &self,
        service_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryServiceSecuringPoolsResponse, cosmwasm_std::StdError> {
        QueryServiceSecuringPoolsRequest {
            service_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn service_operators(
        &self,
        service_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryServiceOperatorsResponse, cosmwasm_std::StdError> {
        QueryServiceOperatorsRequest {
            service_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn pool_delegations(
        &self,
        pool_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryPoolDelegationsResponse, cosmwasm_std::StdError> {
        QueryPoolDelegationsRequest {
            pool_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn pool_delegation(
        &self,
        pool_id: u32,
        delegator_address: ::prost::alloc::string::String,
    ) -> Result<QueryPoolDelegationResponse, cosmwasm_std::StdError> {
        QueryPoolDelegationRequest {
            pool_id,
            delegator_address,
        }
        .query(self.querier)
    }
    pub fn pool_unbonding_delegations(
        &self,
        pool_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryPoolUnbondingDelegationsResponse, cosmwasm_std::StdError> {
        QueryPoolUnbondingDelegationsRequest {
            pool_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn pool_unbonding_delegation(
        &self,
        pool_id: u32,
        delegator_address: ::prost::alloc::string::String,
    ) -> Result<QueryPoolUnbondingDelegationResponse, cosmwasm_std::StdError> {
        QueryPoolUnbondingDelegationRequest {
            pool_id,
            delegator_address,
        }
        .query(self.querier)
    }
    pub fn operator_delegations(
        &self,
        operator_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryOperatorDelegationsResponse, cosmwasm_std::StdError> {
        QueryOperatorDelegationsRequest {
            operator_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn operator_delegation(
        &self,
        operator_id: u32,
        delegator_address: ::prost::alloc::string::String,
    ) -> Result<QueryOperatorDelegationResponse, cosmwasm_std::StdError> {
        QueryOperatorDelegationRequest {
            operator_id,
            delegator_address,
        }
        .query(self.querier)
    }
    pub fn operator_unbonding_delegations(
        &self,
        operator_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryOperatorUnbondingDelegationsResponse, cosmwasm_std::StdError> {
        QueryOperatorUnbondingDelegationsRequest {
            operator_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn operator_unbonding_delegation(
        &self,
        operator_id: u32,
        delegator_address: ::prost::alloc::string::String,
    ) -> Result<QueryOperatorUnbondingDelegationResponse, cosmwasm_std::StdError> {
        QueryOperatorUnbondingDelegationRequest {
            operator_id,
            delegator_address,
        }
        .query(self.querier)
    }
    pub fn service_delegations(
        &self,
        service_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryServiceDelegationsResponse, cosmwasm_std::StdError> {
        QueryServiceDelegationsRequest {
            service_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn service_delegation(
        &self,
        service_id: u32,
        delegator_address: ::prost::alloc::string::String,
    ) -> Result<QueryServiceDelegationResponse, cosmwasm_std::StdError> {
        QueryServiceDelegationRequest {
            service_id,
            delegator_address,
        }
        .query(self.querier)
    }
    pub fn service_unbonding_delegations(
        &self,
        service_id: u32,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryServiceUnbondingDelegationsResponse, cosmwasm_std::StdError> {
        QueryServiceUnbondingDelegationsRequest {
            service_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn service_unbonding_delegation(
        &self,
        service_id: u32,
        delegator_address: ::prost::alloc::string::String,
    ) -> Result<QueryServiceUnbondingDelegationResponse, cosmwasm_std::StdError> {
        QueryServiceUnbondingDelegationRequest {
            service_id,
            delegator_address,
        }
        .query(self.querier)
    }
    pub fn delegator_pool_delegations(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorPoolDelegationsResponse, cosmwasm_std::StdError> {
        QueryDelegatorPoolDelegationsRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_pool_unbonding_delegations(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorPoolUnbondingDelegationsResponse, cosmwasm_std::StdError> {
        QueryDelegatorPoolUnbondingDelegationsRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_operator_delegations(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorOperatorDelegationsResponse, cosmwasm_std::StdError> {
        QueryDelegatorOperatorDelegationsRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_operator_unbonding_delegations(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorOperatorUnbondingDelegationsResponse, cosmwasm_std::StdError> {
        QueryDelegatorOperatorUnbondingDelegationsRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_service_delegations(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorServiceDelegationsResponse, cosmwasm_std::StdError> {
        QueryDelegatorServiceDelegationsRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_service_unbonding_delegations(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorServiceUnbondingDelegationsResponse, cosmwasm_std::StdError> {
        QueryDelegatorServiceUnbondingDelegationsRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_pools(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorPoolsResponse, cosmwasm_std::StdError> {
        QueryDelegatorPoolsRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_pool(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pool_id: u32,
    ) -> Result<QueryDelegatorPoolResponse, cosmwasm_std::StdError> {
        QueryDelegatorPoolRequest {
            delegator_address,
            pool_id,
        }
        .query(self.querier)
    }
    pub fn delegator_operators(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorOperatorsResponse, cosmwasm_std::StdError> {
        QueryDelegatorOperatorsRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_operator(
        &self,
        delegator_address: ::prost::alloc::string::String,
        operator_id: u32,
    ) -> Result<QueryDelegatorOperatorResponse, cosmwasm_std::StdError> {
        QueryDelegatorOperatorRequest {
            delegator_address,
            operator_id,
        }
        .query(self.querier)
    }
    pub fn delegator_services(
        &self,
        delegator_address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<
            super::super::super::cosmos::base::query::v1beta1::PageRequest,
        >,
    ) -> Result<QueryDelegatorServicesResponse, cosmwasm_std::StdError> {
        QueryDelegatorServicesRequest {
            delegator_address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn delegator_service(
        &self,
        delegator_address: ::prost::alloc::string::String,
        service_id: u32,
    ) -> Result<QueryDelegatorServiceResponse, cosmwasm_std::StdError> {
        QueryDelegatorServiceRequest {
            delegator_address,
            service_id,
        }
        .query(self.querier)
    }
    pub fn params(&self) -> Result<QueryParamsResponse, cosmwasm_std::StdError> {
        QueryParamsRequest {}.query(self.querier)
    }
}
