use milkyway_std_derive::CosmwasmExt;
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.UserRedemptionRecord")]
pub struct UserRedemptionRecord {
    /// {chain_id}.{epoch}.{receiver}
    #[prost(string, tag = "1")]
    #[serde(alias = "ID")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub receiver: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub native_token_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub denom: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
    #[prost(uint64, tag = "7")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch_number: u64,
    #[prost(bool, tag = "8")]
    pub claim_is_pending: bool,
    #[prost(string, tag = "9")]
    pub st_token_amount: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.DepositRecord")]
pub struct DepositRecord {
    #[prost(uint64, tag = "1")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u64,
    #[prost(string, tag = "2")]
    pub amount: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub denom: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
    #[prost(enumeration = "deposit_record::Status", tag = "6")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub status: i32,
    #[prost(uint64, tag = "7")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub deposit_epoch_number: u64,
    #[prost(enumeration = "deposit_record::Source", tag = "8")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub source: i32,
}
/// Nested message and enum types in `DepositRecord`.
pub mod deposit_record {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    #[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
    pub enum Status {
        /// in transfer queue to be sent to the delegation ICA
        TransferQueue = 0,
        /// transfer in progress (IBC packet sent, ack not received)
        TransferInProgress = 2,
        /// in staking queue on delegation ICA
        DelegationQueue = 1,
        /// staking in progress (ICA packet sent, ack not received)
        DelegationInProgress = 3,
    }
    impl Status {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Status::TransferQueue => "TRANSFER_QUEUE",
                Status::TransferInProgress => "TRANSFER_IN_PROGRESS",
                Status::DelegationQueue => "DELEGATION_QUEUE",
                Status::DelegationInProgress => "DELEGATION_IN_PROGRESS",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "TRANSFER_QUEUE" => Some(Self::TransferQueue),
                "TRANSFER_IN_PROGRESS" => Some(Self::TransferInProgress),
                "DELEGATION_QUEUE" => Some(Self::DelegationQueue),
                "DELEGATION_IN_PROGRESS" => Some(Self::DelegationInProgress),
                _ => None,
            }
        }
    }
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    #[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
    pub enum Source {
        Stride = 0,
        WithdrawalIca = 1,
    }
    impl Source {
        /// 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 {
                Source::Stride => "STRIDE",
                Source::WithdrawalIca => "WITHDRAWAL_ICA",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "STRIDE" => Some(Self::Stride),
                "WITHDRAWAL_ICA" => Some(Self::WithdrawalIca),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.HostZoneUnbonding")]
pub struct HostZoneUnbonding {
    #[prost(string, tag = "1")]
    pub st_token_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub native_token_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub denom: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
    #[prost(uint64, tag = "5")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub unbonding_time: u64,
    #[prost(enumeration = "host_zone_unbonding::Status", tag = "6")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub status: i32,
    #[prost(string, repeated, tag = "7")]
    pub user_redemption_records: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Nested message and enum types in `HostZoneUnbonding`.
pub mod host_zone_unbonding {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    #[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
    pub enum Status {
        /// tokens bonded on delegate account
        UnbondingQueue = 0,
        UnbondingInProgress = 3,
        /// unbonding completed on delegate account
        ExitTransferQueue = 1,
        ExitTransferInProgress = 4,
        /// transfer success
        Claimable = 2,
    }
    impl Status {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Status::UnbondingQueue => "UNBONDING_QUEUE",
                Status::UnbondingInProgress => "UNBONDING_IN_PROGRESS",
                Status::ExitTransferQueue => "EXIT_TRANSFER_QUEUE",
                Status::ExitTransferInProgress => "EXIT_TRANSFER_IN_PROGRESS",
                Status::Claimable => "CLAIMABLE",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "UNBONDING_QUEUE" => Some(Self::UnbondingQueue),
                "UNBONDING_IN_PROGRESS" => Some(Self::UnbondingInProgress),
                "EXIT_TRANSFER_QUEUE" => Some(Self::ExitTransferQueue),
                "EXIT_TRANSFER_IN_PROGRESS" => Some(Self::ExitTransferInProgress),
                "CLAIMABLE" => Some(Self::Claimable),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.EpochUnbondingRecord")]
pub struct EpochUnbondingRecord {
    #[prost(uint64, tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch_number: u64,
    #[prost(message, repeated, tag = "3")]
    pub host_zone_unbondings: ::prost::alloc::vec::Vec<HostZoneUnbonding>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.LSMTokenDeposit")]
pub struct LsmTokenDeposit {
    #[prost(string, tag = "1")]
    #[serde(alias = "depositID")]
    pub deposit_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub denom: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub ibc_denom: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub staker_address: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub validator_address: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub amount: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "8")]
    pub st_token: ::core::option::Option<super::super::cosmos::base::v1beta1::Coin>,
    #[prost(enumeration = "lsm_token_deposit::Status", tag = "9")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub status: i32,
}
/// Nested message and enum types in `LSMTokenDeposit`.
pub mod lsm_token_deposit {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
    #[repr(i32)]
    #[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
    pub enum Status {
        DepositPending = 0,
        TransferQueue = 1,
        TransferInProgress = 2,
        TransferFailed = 3,
        DetokenizationQueue = 4,
        DetokenizationInProgress = 5,
        DetokenizationFailed = 6,
    }
    impl Status {
        /// String value of the enum field names used in the ProtoBuf definition.
        ///
        /// The values are not transformed in any way and thus are considered stable
        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
        pub fn as_str_name(&self) -> &'static str {
            match self {
                Status::DepositPending => "DEPOSIT_PENDING",
                Status::TransferQueue => "TRANSFER_QUEUE",
                Status::TransferInProgress => "TRANSFER_IN_PROGRESS",
                Status::TransferFailed => "TRANSFER_FAILED",
                Status::DetokenizationQueue => "DETOKENIZATION_QUEUE",
                Status::DetokenizationInProgress => "DETOKENIZATION_IN_PROGRESS",
                Status::DetokenizationFailed => "DETOKENIZATION_FAILED",
            }
        }
        /// Creates an enum from field names used in the ProtoBuf definition.
        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
            match value {
                "DEPOSIT_PENDING" => Some(Self::DepositPending),
                "TRANSFER_QUEUE" => Some(Self::TransferQueue),
                "TRANSFER_IN_PROGRESS" => Some(Self::TransferInProgress),
                "TRANSFER_FAILED" => Some(Self::TransferFailed),
                "DETOKENIZATION_QUEUE" => Some(Self::DetokenizationQueue),
                "DETOKENIZATION_IN_PROGRESS" => Some(Self::DetokenizationInProgress),
                "DETOKENIZATION_FAILED" => Some(Self::DetokenizationFailed),
                _ => None,
            }
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.TransferCallback")]
pub struct TransferCallback {
    #[prost(uint64, tag = "1")]
    #[serde(alias = "deposit_recordID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub deposit_record_id: u64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.TransferLSMTokenCallback")]
pub struct TransferLsmTokenCallback {
    #[prost(message, optional, tag = "1")]
    pub deposit: ::core::option::Option<LsmTokenDeposit>,
}
/// 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 = "/stride.records.Params")]
pub struct Params {}
/// GenesisState defines the records 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 = "/stride.records.GenesisState")]
pub struct GenesisState {
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
    #[prost(string, tag = "2")]
    #[serde(alias = "portID")]
    pub port_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub user_redemption_record_list: ::prost::alloc::vec::Vec<UserRedemptionRecord>,
    #[prost(uint64, tag = "4")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub user_redemption_record_count: u64,
    #[prost(message, repeated, tag = "5")]
    pub epoch_unbonding_record_list: ::prost::alloc::vec::Vec<EpochUnbondingRecord>,
    #[prost(message, repeated, tag = "7")]
    pub deposit_record_list: ::prost::alloc::vec::Vec<DepositRecord>,
    #[prost(uint64, tag = "8")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub deposit_record_count: u64,
    #[prost(message, repeated, tag = "9")]
    pub lsm_token_deposit_list: ::prost::alloc::vec::Vec<LsmTokenDeposit>,
}
/// 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 = "/stride.records.QueryParamsRequest")]
#[proto_query(
    path = "/stride.records.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 = "/stride.records.QueryParamsResponse")]
pub struct QueryParamsResponse {
    /// params holds all the parameters of this module.
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryGetDepositRecordRequest")]
#[proto_query(
    path = "/stride.records.Query/DepositRecord",
    response_type = QueryGetDepositRecordResponse
)]
pub struct QueryGetDepositRecordRequest {
    #[prost(uint64, tag = "1")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryGetDepositRecordResponse")]
pub struct QueryGetDepositRecordResponse {
    #[prost(message, optional, tag = "1")]
    pub deposit_record: ::core::option::Option<DepositRecord>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryAllDepositRecordRequest")]
#[proto_query(
    path = "/stride.records.Query/DepositRecordAll",
    response_type = QueryAllDepositRecordResponse
)]
pub struct QueryAllDepositRecordRequest {
    #[prost(message, optional, tag = "1")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryAllDepositRecordResponse")]
pub struct QueryAllDepositRecordResponse {
    #[prost(message, repeated, tag = "1")]
    pub deposit_record: ::prost::alloc::vec::Vec<DepositRecord>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryDepositRecordByHostRequest")]
#[proto_query(
    path = "/stride.records.Query/DepositRecordByHost",
    response_type = QueryDepositRecordByHostResponse
)]
pub struct QueryDepositRecordByHostRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryDepositRecordByHostResponse")]
pub struct QueryDepositRecordByHostResponse {
    #[prost(message, repeated, tag = "1")]
    pub deposit_record: ::prost::alloc::vec::Vec<DepositRecord>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryGetUserRedemptionRecordRequest")]
#[proto_query(
    path = "/stride.records.Query/UserRedemptionRecord",
    response_type = QueryGetUserRedemptionRecordResponse
)]
pub struct QueryGetUserRedemptionRecordRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "ID")]
    pub id: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryGetUserRedemptionRecordResponse")]
pub struct QueryGetUserRedemptionRecordResponse {
    #[prost(message, optional, tag = "1")]
    pub user_redemption_record: ::core::option::Option<UserRedemptionRecord>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryAllUserRedemptionRecordRequest")]
#[proto_query(
    path = "/stride.records.Query/UserRedemptionRecordAll",
    response_type = QueryAllUserRedemptionRecordResponse
)]
pub struct QueryAllUserRedemptionRecordRequest {
    #[prost(message, optional, tag = "1")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryAllUserRedemptionRecordResponse")]
pub struct QueryAllUserRedemptionRecordResponse {
    #[prost(message, repeated, tag = "1")]
    pub user_redemption_record: ::prost::alloc::vec::Vec<UserRedemptionRecord>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
/// Query UserRedemptionRecords by chainId / userId pair
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryAllUserRedemptionRecordForUserRequest")]
#[proto_query(
    path = "/stride.records.Query/UserRedemptionRecordForUser",
    response_type = QueryAllUserRedemptionRecordForUserResponse
)]
pub struct QueryAllUserRedemptionRecordForUserRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub day: u64,
    #[prost(string, tag = "3")]
    pub address: ::prost::alloc::string::String,
    #[prost(uint64, tag = "4")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub limit: u64,
    #[prost(message, optional, tag = "5")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryAllUserRedemptionRecordForUserResponse")]
pub struct QueryAllUserRedemptionRecordForUserResponse {
    #[prost(message, repeated, tag = "1")]
    pub user_redemption_record: ::prost::alloc::vec::Vec<UserRedemptionRecord>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryGetEpochUnbondingRecordRequest")]
#[proto_query(
    path = "/stride.records.Query/EpochUnbondingRecord",
    response_type = QueryGetEpochUnbondingRecordResponse
)]
pub struct QueryGetEpochUnbondingRecordRequest {
    #[prost(uint64, tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch_number: u64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryGetEpochUnbondingRecordResponse")]
pub struct QueryGetEpochUnbondingRecordResponse {
    #[prost(message, optional, tag = "1")]
    pub epoch_unbonding_record: ::core::option::Option<EpochUnbondingRecord>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryAllEpochUnbondingRecordRequest")]
#[proto_query(
    path = "/stride.records.Query/EpochUnbondingRecordAll",
    response_type = QueryAllEpochUnbondingRecordResponse
)]
pub struct QueryAllEpochUnbondingRecordRequest {
    #[prost(message, optional, tag = "1")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryAllEpochUnbondingRecordResponse")]
pub struct QueryAllEpochUnbondingRecordResponse {
    #[prost(message, repeated, tag = "1")]
    pub epoch_unbonding_record: ::prost::alloc::vec::Vec<EpochUnbondingRecord>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryLSMDepositRequest")]
#[proto_query(
    path = "/stride.records.Query/LSMDeposit",
    response_type = QueryLsmDepositResponse
)]
pub struct QueryLsmDepositRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub denom: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryLSMDepositResponse")]
pub struct QueryLsmDepositResponse {
    #[prost(message, optional, tag = "1")]
    pub deposit: ::core::option::Option<LsmTokenDeposit>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryLSMDepositsRequest")]
#[proto_query(
    path = "/stride.records.Query/LSMDeposits",
    response_type = QueryLsmDepositsResponse
)]
pub struct QueryLsmDepositsRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub validator_address: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub status: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.records.QueryLSMDepositsResponse")]
pub struct QueryLsmDepositsResponse {
    #[prost(message, repeated, tag = "1")]
    pub deposits: ::prost::alloc::vec::Vec<LsmTokenDeposit>,
}
pub struct RecordsQuerier<'a, Q: cosmwasm_std::CustomQuery> {
    querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>,
}
impl<'a, Q: cosmwasm_std::CustomQuery> RecordsQuerier<'a, Q> {
    pub fn new(querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>) -> Self {
        Self { querier }
    }
    pub fn params(&self) -> Result<QueryParamsResponse, cosmwasm_std::StdError> {
        QueryParamsRequest {}.query(self.querier)
    }
    pub fn user_redemption_record(
        &self,
        id: ::prost::alloc::string::String,
    ) -> Result<QueryGetUserRedemptionRecordResponse, cosmwasm_std::StdError> {
        QueryGetUserRedemptionRecordRequest { id }.query(self.querier)
    }
    pub fn user_redemption_record_all(
        &self,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<QueryAllUserRedemptionRecordResponse, cosmwasm_std::StdError> {
        QueryAllUserRedemptionRecordRequest { pagination }.query(self.querier)
    }
    pub fn user_redemption_record_for_user(
        &self,
        chain_id: ::prost::alloc::string::String,
        day: u64,
        address: ::prost::alloc::string::String,
        limit: u64,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<QueryAllUserRedemptionRecordForUserResponse, cosmwasm_std::StdError> {
        QueryAllUserRedemptionRecordForUserRequest {
            chain_id,
            day,
            address,
            limit,
            pagination,
        }
        .query(self.querier)
    }
    pub fn epoch_unbonding_record(
        &self,
        epoch_number: u64,
    ) -> Result<QueryGetEpochUnbondingRecordResponse, cosmwasm_std::StdError> {
        QueryGetEpochUnbondingRecordRequest { epoch_number }.query(self.querier)
    }
    pub fn epoch_unbonding_record_all(
        &self,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<QueryAllEpochUnbondingRecordResponse, cosmwasm_std::StdError> {
        QueryAllEpochUnbondingRecordRequest { pagination }.query(self.querier)
    }
    pub fn deposit_record(
        &self,
        id: u64,
    ) -> Result<QueryGetDepositRecordResponse, cosmwasm_std::StdError> {
        QueryGetDepositRecordRequest { id }.query(self.querier)
    }
    pub fn deposit_record_all(
        &self,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<QueryAllDepositRecordResponse, cosmwasm_std::StdError> {
        QueryAllDepositRecordRequest { pagination }.query(self.querier)
    }
    pub fn deposit_record_by_host(
        &self,
        host_zone_id: ::prost::alloc::string::String,
    ) -> Result<QueryDepositRecordByHostResponse, cosmwasm_std::StdError> {
        QueryDepositRecordByHostRequest { host_zone_id }.query(self.querier)
    }
    pub fn lsm_deposit(
        &self,
        chain_id: ::prost::alloc::string::String,
        denom: ::prost::alloc::string::String,
    ) -> Result<QueryLsmDepositResponse, cosmwasm_std::StdError> {
        QueryLsmDepositRequest { chain_id, denom }.query(self.querier)
    }
    pub fn lsm_deposits(
        &self,
        chain_id: ::prost::alloc::string::String,
        validator_address: ::prost::alloc::string::String,
        status: ::prost::alloc::string::String,
    ) -> Result<QueryLsmDepositsResponse, cosmwasm_std::StdError> {
        QueryLsmDepositsRequest {
            chain_id,
            validator_address,
            status,
        }
        .query(self.querier)
    }
}
