Variable v1beta1Const

v1beta1: {
    AuthorizationType: any;
    BondStatus: any;
    LCDQueryClient: any;
    MsgClientImpl: any;
    QueryClientImpl: any;
    AminoConverter: {
        /cosmos.staking.v1beta1.MsgBeginRedelegate: {
            aminoType: string;
            fromAmino: ((object: MsgBeginRedelegateAmino) => MsgBeginRedelegate);
            toAmino: ((message: MsgBeginRedelegate) => MsgBeginRedelegateAmino);
        };
        /cosmos.staking.v1beta1.MsgCreateValidator: {
            aminoType: string;
            fromAmino: ((object: MsgCreateValidatorAmino) => MsgCreateValidator);
            toAmino: ((message: MsgCreateValidator) => MsgCreateValidatorAmino);
        };
        /cosmos.staking.v1beta1.MsgDelegate: {
            aminoType: string;
            fromAmino: ((object: MsgDelegateAmino) => MsgDelegate);
            toAmino: ((message: MsgDelegate) => MsgDelegateAmino);
        };
        /cosmos.staking.v1beta1.MsgEditValidator: {
            aminoType: string;
            fromAmino: ((object: MsgEditValidatorAmino) => MsgEditValidator);
            toAmino: ((message: MsgEditValidator) => MsgEditValidatorAmino);
        };
        /cosmos.staking.v1beta1.MsgUndelegate: {
            aminoType: string;
            fromAmino: ((object: MsgUndelegateAmino) => MsgUndelegate);
            toAmino: ((message: MsgUndelegate) => MsgUndelegateAmino);
        };
    };
    AuthorizationTypeAmino: typeof AuthorizationType;
    AuthorizationTypeSDKType: typeof AuthorizationType;
    BondStatusAmino: typeof BondStatus;
    BondStatusSDKType: typeof BondStatus;
    Commission: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Commission;
        encode(message: Commission, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CommissionAmino): Commission;
        fromAminoMsg(object: CommissionAminoMsg): Commission;
        fromPartial(object: {
            commissionRates?: {
                maxChangeRate?: string;
                maxRate?: string;
                rate?: string;
            };
            updateTime?: Date;
        }): Commission;
        fromProtoMsg(message: CommissionProtoMsg): Commission;
        toAmino(message: Commission): CommissionAmino;
        toAminoMsg(message: Commission): CommissionAminoMsg;
        toProto(message: Commission): Uint8Array;
        toProtoMsg(message: Commission): CommissionProtoMsg;
    };
    CommissionRates: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): CommissionRates;
        encode(message: CommissionRates, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CommissionRatesAmino): CommissionRates;
        fromAminoMsg(object: CommissionRatesAminoMsg): CommissionRates;
        fromPartial(object: {
            maxChangeRate?: string;
            maxRate?: string;
            rate?: string;
        }): CommissionRates;
        fromProtoMsg(message: CommissionRatesProtoMsg): CommissionRates;
        toAmino(message: CommissionRates): CommissionRatesAmino;
        toAminoMsg(message: CommissionRates): CommissionRatesAminoMsg;
        toProto(message: CommissionRates): Uint8Array;
        toProtoMsg(message: CommissionRates): CommissionRatesProtoMsg;
    };
    Cosmos_cryptoPubKey_FromAmino: ((content: AnyAmino) => Any);
    Cosmos_cryptoPubKey_InterfaceDecoder: ((input: Uint8Array | BinaryReader) => Any);
    Cosmos_cryptoPubKey_ToAmino: ((content: Any) => null | Pubkey);
    DVPair: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DVPair;
        encode(message: DVPair, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DVPairAmino): DVPair;
        fromAminoMsg(object: DVPairAminoMsg): DVPair;
        fromPartial(object: {
            delegatorAddress?: string;
            validatorAddress?: string;
        }): DVPair;
        fromProtoMsg(message: DVPairProtoMsg): DVPair;
        toAmino(message: DVPair): DVPairAmino;
        toAminoMsg(message: DVPair): DVPairAminoMsg;
        toProto(message: DVPair): Uint8Array;
        toProtoMsg(message: DVPair): DVPairProtoMsg;
    };
    DVPairs: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DVPairs;
        encode(message: DVPairs, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DVPairsAmino): DVPairs;
        fromAminoMsg(object: DVPairsAminoMsg): DVPairs;
        fromPartial(object: {
            pairs?: {
                delegatorAddress?: string;
                validatorAddress?: string;
            }[];
        }): DVPairs;
        fromProtoMsg(message: DVPairsProtoMsg): DVPairs;
        toAmino(message: DVPairs): DVPairsAmino;
        toAminoMsg(message: DVPairs): DVPairsAminoMsg;
        toProto(message: DVPairs): Uint8Array;
        toProtoMsg(message: DVPairs): DVPairsProtoMsg;
    };
    DVVTriplet: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DVVTriplet;
        encode(message: DVVTriplet, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DVVTripletAmino): DVVTriplet;
        fromAminoMsg(object: DVVTripletAminoMsg): DVVTriplet;
        fromPartial(object: {
            delegatorAddress?: string;
            validatorDstAddress?: string;
            validatorSrcAddress?: string;
        }): DVVTriplet;
        fromProtoMsg(message: DVVTripletProtoMsg): DVVTriplet;
        toAmino(message: DVVTriplet): DVVTripletAmino;
        toAminoMsg(message: DVVTriplet): DVVTripletAminoMsg;
        toProto(message: DVVTriplet): Uint8Array;
        toProtoMsg(message: DVVTriplet): DVVTripletProtoMsg;
    };
    DVVTriplets: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DVVTriplets;
        encode(message: DVVTriplets, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DVVTripletsAmino): DVVTriplets;
        fromAminoMsg(object: DVVTripletsAminoMsg): DVVTriplets;
        fromPartial(object: {
            triplets?: {
                delegatorAddress?: string;
                validatorDstAddress?: string;
                validatorSrcAddress?: string;
            }[];
        }): DVVTriplets;
        fromProtoMsg(message: DVVTripletsProtoMsg): DVVTriplets;
        toAmino(message: DVVTriplets): DVVTripletsAmino;
        toAminoMsg(message: DVVTriplets): DVVTripletsAminoMsg;
        toProto(message: DVVTriplets): Uint8Array;
        toProtoMsg(message: DVVTriplets): DVVTripletsProtoMsg;
    };
    Delegation: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Delegation;
        encode(message: Delegation, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DelegationAmino): Delegation;
        fromAminoMsg(object: DelegationAminoMsg): Delegation;
        fromPartial(object: {
            delegatorAddress?: string;
            shares?: string;
            validatorAddress?: string;
        }): Delegation;
        fromProtoMsg(message: DelegationProtoMsg): Delegation;
        toAmino(message: Delegation): DelegationAmino;
        toAminoMsg(message: Delegation): DelegationAminoMsg;
        toProto(message: Delegation): Uint8Array;
        toProtoMsg(message: Delegation): DelegationProtoMsg;
    };
    DelegationResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DelegationResponse;
        encode(message: DelegationResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DelegationResponseAmino): DelegationResponse;
        fromAminoMsg(object: DelegationResponseAminoMsg): DelegationResponse;
        fromPartial(object: {
            balance?: {
                amount?: string;
                denom?: string;
            };
            delegation?: {
                delegatorAddress?: string;
                shares?: string;
                validatorAddress?: string;
            };
        }): DelegationResponse;
        fromProtoMsg(message: DelegationResponseProtoMsg): DelegationResponse;
        toAmino(message: DelegationResponse): DelegationResponseAmino;
        toAminoMsg(message: DelegationResponse): DelegationResponseAminoMsg;
        toProto(message: DelegationResponse): Uint8Array;
        toProtoMsg(message: DelegationResponse): DelegationResponseProtoMsg;
    };
    Description: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Description;
        encode(message: Description, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DescriptionAmino): Description;
        fromAminoMsg(object: DescriptionAminoMsg): Description;
        fromPartial(object: {
            details?: string;
            identity?: string;
            moniker?: string;
            securityContact?: string;
            website?: string;
        }): Description;
        fromProtoMsg(message: DescriptionProtoMsg): Description;
        toAmino(message: Description): DescriptionAmino;
        toAminoMsg(message: Description): DescriptionAminoMsg;
        toProto(message: Description): Uint8Array;
        toProtoMsg(message: Description): DescriptionProtoMsg;
    };
    GenesisState: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): GenesisState;
        encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: GenesisStateAmino): GenesisState;
        fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
        fromPartial(object: {
            delegations?: {
                delegatorAddress?: string;
                shares?: string;
                validatorAddress?: string;
            }[];
            exported?: boolean;
            lastTotalPower?: Uint8Array;
            lastValidatorPowers?: {
                address?: string;
                power?: bigint;
            }[];
            params?: {
                bondDenom?: string;
                historicalEntries?: number;
                maxEntries?: number;
                maxValidators?: number;
                maxVotingPowerEnforcementThreshold?: string;
                maxVotingPowerRatio?: string;
                minCommissionRate?: string;
                unbondingTime?: {
                    nanos?: number;
                    seconds?: bigint;
                };
            };
            redelegations?: {
                delegatorAddress?: string;
                entries?: {
                    completionTime?: Date;
                    creationHeight?: bigint;
                    initialBalance?: string;
                    sharesDst?: string;
                }[];
                validatorDstAddress?: string;
                validatorSrcAddress?: string;
            }[];
            unbondingDelegations?: {
                delegatorAddress?: string;
                entries?: {
                    balance?: string;
                    completionTime?: Date;
                    creationHeight?: bigint;
                    initialBalance?: string;
                }[];
                validatorAddress?: string;
            }[];
            validators?: {
                commission?: {
                    commissionRates?: {
                        maxChangeRate?: (...) | (...);
                        maxRate?: (...) | (...);
                        rate?: (...) | (...);
                    };
                    updateTime?: Date;
                };
                consensusPubkey?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                delegatorShares?: string;
                description?: {
                    details?: string;
                    identity?: string;
                    moniker?: string;
                    securityContact?: string;
                    website?: string;
                };
                jailed?: boolean;
                minSelfDelegation?: string;
                operatorAddress?: string;
                status?: BondStatus;
                tokens?: string;
                unbondingHeight?: bigint;
                unbondingTime?: Date;
            }[];
        }): GenesisState;
        fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
        toAmino(message: GenesisState): GenesisStateAmino;
        toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
        toProto(message: GenesisState): Uint8Array;
        toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
    };
    HistoricalInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): HistoricalInfo;
        encode(message: HistoricalInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: HistoricalInfoAmino): HistoricalInfo;
        fromAminoMsg(object: HistoricalInfoAminoMsg): HistoricalInfo;
        fromPartial(object: {
            header?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            };
            valset?: {
                commission?: {
                    commissionRates?: {
                        maxChangeRate?: (...) | (...);
                        maxRate?: (...) | (...);
                        rate?: (...) | (...);
                    };
                    updateTime?: Date;
                };
                consensusPubkey?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                delegatorShares?: string;
                description?: {
                    details?: string;
                    identity?: string;
                    moniker?: string;
                    securityContact?: string;
                    website?: string;
                };
                jailed?: boolean;
                minSelfDelegation?: string;
                operatorAddress?: string;
                status?: BondStatus;
                tokens?: string;
                unbondingHeight?: bigint;
                unbondingTime?: Date;
            }[];
        }): HistoricalInfo;
        fromProtoMsg(message: HistoricalInfoProtoMsg): HistoricalInfo;
        toAmino(message: HistoricalInfo): HistoricalInfoAmino;
        toAminoMsg(message: HistoricalInfo): HistoricalInfoAminoMsg;
        toProto(message: HistoricalInfo): Uint8Array;
        toProtoMsg(message: HistoricalInfo): HistoricalInfoProtoMsg;
    };
    LastValidatorPower: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): LastValidatorPower;
        encode(message: LastValidatorPower, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: LastValidatorPowerAmino): LastValidatorPower;
        fromAminoMsg(object: LastValidatorPowerAminoMsg): LastValidatorPower;
        fromPartial(object: {
            address?: string;
            power?: bigint;
        }): LastValidatorPower;
        fromProtoMsg(message: LastValidatorPowerProtoMsg): LastValidatorPower;
        toAmino(message: LastValidatorPower): LastValidatorPowerAmino;
        toAminoMsg(message: LastValidatorPower): LastValidatorPowerAminoMsg;
        toProto(message: LastValidatorPower): Uint8Array;
        toProtoMsg(message: LastValidatorPower): LastValidatorPowerProtoMsg;
    };
    MessageComposer: {
        encoded: {
            beginRedelegate(value: MsgBeginRedelegate): {
                typeUrl: string;
                value: Uint8Array;
            };
            createValidator(value: MsgCreateValidator): {
                typeUrl: string;
                value: Uint8Array;
            };
            delegate(value: MsgDelegate): {
                typeUrl: string;
                value: Uint8Array;
            };
            editValidator(value: MsgEditValidator): {
                typeUrl: string;
                value: Uint8Array;
            };
            undelegate(value: MsgUndelegate): {
                typeUrl: string;
                value: Uint8Array;
            };
        };
        fromPartial: {
            beginRedelegate(value: MsgBeginRedelegate): {
                typeUrl: string;
                value: MsgBeginRedelegate;
            };
            createValidator(value: MsgCreateValidator): {
                typeUrl: string;
                value: MsgCreateValidator;
            };
            delegate(value: MsgDelegate): {
                typeUrl: string;
                value: MsgDelegate;
            };
            editValidator(value: MsgEditValidator): {
                typeUrl: string;
                value: MsgEditValidator;
            };
            undelegate(value: MsgUndelegate): {
                typeUrl: string;
                value: MsgUndelegate;
            };
        };
        withTypeUrl: {
            beginRedelegate(value: MsgBeginRedelegate): {
                typeUrl: string;
                value: MsgBeginRedelegate;
            };
            createValidator(value: MsgCreateValidator): {
                typeUrl: string;
                value: MsgCreateValidator;
            };
            delegate(value: MsgDelegate): {
                typeUrl: string;
                value: MsgDelegate;
            };
            editValidator(value: MsgEditValidator): {
                typeUrl: string;
                value: MsgEditValidator;
            };
            undelegate(value: MsgUndelegate): {
                typeUrl: string;
                value: MsgUndelegate;
            };
        };
    };
    MsgBeginRedelegate: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgBeginRedelegate;
        encode(message: MsgBeginRedelegate, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgBeginRedelegateAmino): MsgBeginRedelegate;
        fromAminoMsg(object: MsgBeginRedelegateAminoMsg): MsgBeginRedelegate;
        fromPartial(object: {
            amount?: {
                amount?: string;
                denom?: string;
            };
            delegatorAddress?: string;
            validatorDstAddress?: string;
            validatorSrcAddress?: string;
        }): MsgBeginRedelegate;
        fromProtoMsg(message: MsgBeginRedelegateProtoMsg): MsgBeginRedelegate;
        toAmino(message: MsgBeginRedelegate): MsgBeginRedelegateAmino;
        toAminoMsg(message: MsgBeginRedelegate): MsgBeginRedelegateAminoMsg;
        toProto(message: MsgBeginRedelegate): Uint8Array;
        toProtoMsg(message: MsgBeginRedelegate): MsgBeginRedelegateProtoMsg;
    };
    MsgBeginRedelegateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgBeginRedelegateResponse;
        encode(message: MsgBeginRedelegateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgBeginRedelegateResponseAmino): MsgBeginRedelegateResponse;
        fromAminoMsg(object: MsgBeginRedelegateResponseAminoMsg): MsgBeginRedelegateResponse;
        fromPartial(object: {
            completionTime?: Date;
        }): MsgBeginRedelegateResponse;
        fromProtoMsg(message: MsgBeginRedelegateResponseProtoMsg): MsgBeginRedelegateResponse;
        toAmino(message: MsgBeginRedelegateResponse): MsgBeginRedelegateResponseAmino;
        toAminoMsg(message: MsgBeginRedelegateResponse): MsgBeginRedelegateResponseAminoMsg;
        toProto(message: MsgBeginRedelegateResponse): Uint8Array;
        toProtoMsg(message: MsgBeginRedelegateResponse): MsgBeginRedelegateResponseProtoMsg;
    };
    MsgCreateValidator: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgCreateValidator;
        encode(message: MsgCreateValidator, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgCreateValidatorAmino): MsgCreateValidator;
        fromAminoMsg(object: MsgCreateValidatorAminoMsg): MsgCreateValidator;
        fromPartial(object: {
            commission?: {
                maxChangeRate?: string;
                maxRate?: string;
                rate?: string;
            };
            delegatorAddress?: string;
            description?: {
                details?: string;
                identity?: string;
                moniker?: string;
                securityContact?: string;
                website?: string;
            };
            minSelfDelegation?: string;
            pubkey?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            validatorAddress?: string;
            value?: {
                amount?: string;
                denom?: string;
            };
        }): MsgCreateValidator;
        fromProtoMsg(message: MsgCreateValidatorProtoMsg): MsgCreateValidator;
        toAmino(message: MsgCreateValidator): MsgCreateValidatorAmino;
        toAminoMsg(message: MsgCreateValidator): MsgCreateValidatorAminoMsg;
        toProto(message: MsgCreateValidator): Uint8Array;
        toProtoMsg(message: MsgCreateValidator): MsgCreateValidatorProtoMsg;
    };
    MsgCreateValidatorResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgCreateValidatorResponse;
        encode(_: MsgCreateValidatorResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgCreateValidatorResponseAmino): MsgCreateValidatorResponse;
        fromAminoMsg(object: MsgCreateValidatorResponseAminoMsg): MsgCreateValidatorResponse;
        fromPartial(_: {}): MsgCreateValidatorResponse;
        fromProtoMsg(message: MsgCreateValidatorResponseProtoMsg): MsgCreateValidatorResponse;
        toAmino(_: MsgCreateValidatorResponse): MsgCreateValidatorResponseAmino;
        toAminoMsg(message: MsgCreateValidatorResponse): MsgCreateValidatorResponseAminoMsg;
        toProto(message: MsgCreateValidatorResponse): Uint8Array;
        toProtoMsg(message: MsgCreateValidatorResponse): MsgCreateValidatorResponseProtoMsg;
    };
    MsgDelegate: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgDelegate;
        encode(message: MsgDelegate, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgDelegateAmino): MsgDelegate;
        fromAminoMsg(object: MsgDelegateAminoMsg): MsgDelegate;
        fromPartial(object: {
            amount?: {
                amount?: string;
                denom?: string;
            };
            delegatorAddress?: string;
            validatorAddress?: string;
        }): MsgDelegate;
        fromProtoMsg(message: MsgDelegateProtoMsg): MsgDelegate;
        toAmino(message: MsgDelegate): MsgDelegateAmino;
        toAminoMsg(message: MsgDelegate): MsgDelegateAminoMsg;
        toProto(message: MsgDelegate): Uint8Array;
        toProtoMsg(message: MsgDelegate): MsgDelegateProtoMsg;
    };
    MsgDelegateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgDelegateResponse;
        encode(_: MsgDelegateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgDelegateResponseAmino): MsgDelegateResponse;
        fromAminoMsg(object: MsgDelegateResponseAminoMsg): MsgDelegateResponse;
        fromPartial(_: {}): MsgDelegateResponse;
        fromProtoMsg(message: MsgDelegateResponseProtoMsg): MsgDelegateResponse;
        toAmino(_: MsgDelegateResponse): MsgDelegateResponseAmino;
        toAminoMsg(message: MsgDelegateResponse): MsgDelegateResponseAminoMsg;
        toProto(message: MsgDelegateResponse): Uint8Array;
        toProtoMsg(message: MsgDelegateResponse): MsgDelegateResponseProtoMsg;
    };
    MsgEditValidator: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgEditValidator;
        encode(message: MsgEditValidator, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgEditValidatorAmino): MsgEditValidator;
        fromAminoMsg(object: MsgEditValidatorAminoMsg): MsgEditValidator;
        fromPartial(object: {
            commissionRate?: string;
            description?: {
                details?: string;
                identity?: string;
                moniker?: string;
                securityContact?: string;
                website?: string;
            };
            minSelfDelegation?: string;
            validatorAddress?: string;
        }): MsgEditValidator;
        fromProtoMsg(message: MsgEditValidatorProtoMsg): MsgEditValidator;
        toAmino(message: MsgEditValidator): MsgEditValidatorAmino;
        toAminoMsg(message: MsgEditValidator): MsgEditValidatorAminoMsg;
        toProto(message: MsgEditValidator): Uint8Array;
        toProtoMsg(message: MsgEditValidator): MsgEditValidatorProtoMsg;
    };
    MsgEditValidatorResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgEditValidatorResponse;
        encode(_: MsgEditValidatorResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgEditValidatorResponseAmino): MsgEditValidatorResponse;
        fromAminoMsg(object: MsgEditValidatorResponseAminoMsg): MsgEditValidatorResponse;
        fromPartial(_: {}): MsgEditValidatorResponse;
        fromProtoMsg(message: MsgEditValidatorResponseProtoMsg): MsgEditValidatorResponse;
        toAmino(_: MsgEditValidatorResponse): MsgEditValidatorResponseAmino;
        toAminoMsg(message: MsgEditValidatorResponse): MsgEditValidatorResponseAminoMsg;
        toProto(message: MsgEditValidatorResponse): Uint8Array;
        toProtoMsg(message: MsgEditValidatorResponse): MsgEditValidatorResponseProtoMsg;
    };
    MsgUndelegate: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUndelegate;
        encode(message: MsgUndelegate, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUndelegateAmino): MsgUndelegate;
        fromAminoMsg(object: MsgUndelegateAminoMsg): MsgUndelegate;
        fromPartial(object: {
            amount?: {
                amount?: string;
                denom?: string;
            };
            delegatorAddress?: string;
            validatorAddress?: string;
        }): MsgUndelegate;
        fromProtoMsg(message: MsgUndelegateProtoMsg): MsgUndelegate;
        toAmino(message: MsgUndelegate): MsgUndelegateAmino;
        toAminoMsg(message: MsgUndelegate): MsgUndelegateAminoMsg;
        toProto(message: MsgUndelegate): Uint8Array;
        toProtoMsg(message: MsgUndelegate): MsgUndelegateProtoMsg;
    };
    MsgUndelegateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUndelegateResponse;
        encode(message: MsgUndelegateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUndelegateResponseAmino): MsgUndelegateResponse;
        fromAminoMsg(object: MsgUndelegateResponseAminoMsg): MsgUndelegateResponse;
        fromPartial(object: {
            completionTime?: Date;
        }): MsgUndelegateResponse;
        fromProtoMsg(message: MsgUndelegateResponseProtoMsg): MsgUndelegateResponse;
        toAmino(message: MsgUndelegateResponse): MsgUndelegateResponseAmino;
        toAminoMsg(message: MsgUndelegateResponse): MsgUndelegateResponseAminoMsg;
        toProto(message: MsgUndelegateResponse): Uint8Array;
        toProtoMsg(message: MsgUndelegateResponse): MsgUndelegateResponseProtoMsg;
    };
    Params: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Params;
        encode(message: Params, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ParamsAmino): Params;
        fromAminoMsg(object: ParamsAminoMsg): Params;
        fromPartial(object: {
            bondDenom?: string;
            historicalEntries?: number;
            maxEntries?: number;
            maxValidators?: number;
            maxVotingPowerEnforcementThreshold?: string;
            maxVotingPowerRatio?: string;
            minCommissionRate?: string;
            unbondingTime?: {
                nanos?: number;
                seconds?: bigint;
            };
        }): Params;
        fromProtoMsg(message: ParamsProtoMsg): Params;
        toAmino(message: Params): ParamsAmino;
        toAminoMsg(message: Params): ParamsAminoMsg;
        toProto(message: Params): Uint8Array;
        toProtoMsg(message: Params): ParamsProtoMsg;
    };
    Pool: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Pool;
        encode(message: Pool, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PoolAmino): Pool;
        fromAminoMsg(object: PoolAminoMsg): Pool;
        fromPartial(object: {
            bondedTokens?: string;
            notBondedTokens?: string;
        }): Pool;
        fromProtoMsg(message: PoolProtoMsg): Pool;
        toAmino(message: Pool): PoolAmino;
        toAminoMsg(message: Pool): PoolAminoMsg;
        toProto(message: Pool): Uint8Array;
        toProtoMsg(message: Pool): PoolProtoMsg;
    };
    QueryDelegationRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegationRequest;
        encode(message: QueryDelegationRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegationRequestAmino): QueryDelegationRequest;
        fromAminoMsg(object: QueryDelegationRequestAminoMsg): QueryDelegationRequest;
        fromPartial(object: {
            delegatorAddr?: string;
            validatorAddr?: string;
        }): QueryDelegationRequest;
        fromProtoMsg(message: QueryDelegationRequestProtoMsg): QueryDelegationRequest;
        toAmino(message: QueryDelegationRequest): QueryDelegationRequestAmino;
        toAminoMsg(message: QueryDelegationRequest): QueryDelegationRequestAminoMsg;
        toProto(message: QueryDelegationRequest): Uint8Array;
        toProtoMsg(message: QueryDelegationRequest): QueryDelegationRequestProtoMsg;
    };
    QueryDelegationResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegationResponse;
        encode(message: QueryDelegationResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegationResponseAmino): QueryDelegationResponse;
        fromAminoMsg(object: QueryDelegationResponseAminoMsg): QueryDelegationResponse;
        fromPartial(object: {
            delegationResponse?: {
                balance?: {
                    amount?: string;
                    denom?: string;
                };
                delegation?: {
                    delegatorAddress?: string;
                    shares?: string;
                    validatorAddress?: string;
                };
            };
        }): QueryDelegationResponse;
        fromProtoMsg(message: QueryDelegationResponseProtoMsg): QueryDelegationResponse;
        toAmino(message: QueryDelegationResponse): QueryDelegationResponseAmino;
        toAminoMsg(message: QueryDelegationResponse): QueryDelegationResponseAminoMsg;
        toProto(message: QueryDelegationResponse): Uint8Array;
        toProtoMsg(message: QueryDelegationResponse): QueryDelegationResponseProtoMsg;
    };
    QueryDelegatorDelegationsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegatorDelegationsRequest;
        encode(message: QueryDelegatorDelegationsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegatorDelegationsRequestAmino): QueryDelegatorDelegationsRequest;
        fromAminoMsg(object: QueryDelegatorDelegationsRequestAminoMsg): QueryDelegatorDelegationsRequest;
        fromPartial(object: {
            delegatorAddr?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryDelegatorDelegationsRequest;
        fromProtoMsg(message: QueryDelegatorDelegationsRequestProtoMsg): QueryDelegatorDelegationsRequest;
        toAmino(message: QueryDelegatorDelegationsRequest): QueryDelegatorDelegationsRequestAmino;
        toAminoMsg(message: QueryDelegatorDelegationsRequest): QueryDelegatorDelegationsRequestAminoMsg;
        toProto(message: QueryDelegatorDelegationsRequest): Uint8Array;
        toProtoMsg(message: QueryDelegatorDelegationsRequest): QueryDelegatorDelegationsRequestProtoMsg;
    };
    QueryDelegatorDelegationsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegatorDelegationsResponse;
        encode(message: QueryDelegatorDelegationsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegatorDelegationsResponseAmino): QueryDelegatorDelegationsResponse;
        fromAminoMsg(object: QueryDelegatorDelegationsResponseAminoMsg): QueryDelegatorDelegationsResponse;
        fromPartial(object: {
            delegationResponses?: {
                balance?: {
                    amount?: string;
                    denom?: string;
                };
                delegation?: {
                    delegatorAddress?: string;
                    shares?: string;
                    validatorAddress?: string;
                };
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryDelegatorDelegationsResponse;
        fromProtoMsg(message: QueryDelegatorDelegationsResponseProtoMsg): QueryDelegatorDelegationsResponse;
        toAmino(message: QueryDelegatorDelegationsResponse): QueryDelegatorDelegationsResponseAmino;
        toAminoMsg(message: QueryDelegatorDelegationsResponse): QueryDelegatorDelegationsResponseAminoMsg;
        toProto(message: QueryDelegatorDelegationsResponse): Uint8Array;
        toProtoMsg(message: QueryDelegatorDelegationsResponse): QueryDelegatorDelegationsResponseProtoMsg;
    };
    QueryDelegatorUnbondingDelegationsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegatorUnbondingDelegationsRequest;
        encode(message: QueryDelegatorUnbondingDelegationsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegatorUnbondingDelegationsRequestAmino): QueryDelegatorUnbondingDelegationsRequest;
        fromAminoMsg(object: QueryDelegatorUnbondingDelegationsRequestAminoMsg): QueryDelegatorUnbondingDelegationsRequest;
        fromPartial(object: {
            delegatorAddr?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryDelegatorUnbondingDelegationsRequest;
        fromProtoMsg(message: QueryDelegatorUnbondingDelegationsRequestProtoMsg): QueryDelegatorUnbondingDelegationsRequest;
        toAmino(message: QueryDelegatorUnbondingDelegationsRequest): QueryDelegatorUnbondingDelegationsRequestAmino;
        toAminoMsg(message: QueryDelegatorUnbondingDelegationsRequest): QueryDelegatorUnbondingDelegationsRequestAminoMsg;
        toProto(message: QueryDelegatorUnbondingDelegationsRequest): Uint8Array;
        toProtoMsg(message: QueryDelegatorUnbondingDelegationsRequest): QueryDelegatorUnbondingDelegationsRequestProtoMsg;
    };
    QueryDelegatorUnbondingDelegationsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegatorUnbondingDelegationsResponse;
        encode(message: QueryDelegatorUnbondingDelegationsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegatorUnbondingDelegationsResponseAmino): QueryDelegatorUnbondingDelegationsResponse;
        fromAminoMsg(object: QueryDelegatorUnbondingDelegationsResponseAminoMsg): QueryDelegatorUnbondingDelegationsResponse;
        fromPartial(object: {
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
            unbondingResponses?: {
                delegatorAddress?: string;
                entries?: {
                    balance?: string;
                    completionTime?: Date;
                    creationHeight?: bigint;
                    initialBalance?: string;
                }[];
                validatorAddress?: string;
            }[];
        }): QueryDelegatorUnbondingDelegationsResponse;
        fromProtoMsg(message: QueryDelegatorUnbondingDelegationsResponseProtoMsg): QueryDelegatorUnbondingDelegationsResponse;
        toAmino(message: QueryDelegatorUnbondingDelegationsResponse): QueryDelegatorUnbondingDelegationsResponseAmino;
        toAminoMsg(message: QueryDelegatorUnbondingDelegationsResponse): QueryDelegatorUnbondingDelegationsResponseAminoMsg;
        toProto(message: QueryDelegatorUnbondingDelegationsResponse): Uint8Array;
        toProtoMsg(message: QueryDelegatorUnbondingDelegationsResponse): QueryDelegatorUnbondingDelegationsResponseProtoMsg;
    };
    QueryDelegatorValidatorRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegatorValidatorRequest;
        encode(message: QueryDelegatorValidatorRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegatorValidatorRequestAmino): QueryDelegatorValidatorRequest;
        fromAminoMsg(object: QueryDelegatorValidatorRequestAminoMsg): QueryDelegatorValidatorRequest;
        fromPartial(object: {
            delegatorAddr?: string;
            validatorAddr?: string;
        }): QueryDelegatorValidatorRequest;
        fromProtoMsg(message: QueryDelegatorValidatorRequestProtoMsg): QueryDelegatorValidatorRequest;
        toAmino(message: QueryDelegatorValidatorRequest): QueryDelegatorValidatorRequestAmino;
        toAminoMsg(message: QueryDelegatorValidatorRequest): QueryDelegatorValidatorRequestAminoMsg;
        toProto(message: QueryDelegatorValidatorRequest): Uint8Array;
        toProtoMsg(message: QueryDelegatorValidatorRequest): QueryDelegatorValidatorRequestProtoMsg;
    };
    QueryDelegatorValidatorResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegatorValidatorResponse;
        encode(message: QueryDelegatorValidatorResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegatorValidatorResponseAmino): QueryDelegatorValidatorResponse;
        fromAminoMsg(object: QueryDelegatorValidatorResponseAminoMsg): QueryDelegatorValidatorResponse;
        fromPartial(object: {
            validator?: {
                commission?: {
                    commissionRates?: {
                        maxChangeRate?: string;
                        maxRate?: string;
                        rate?: string;
                    };
                    updateTime?: Date;
                };
                consensusPubkey?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                delegatorShares?: string;
                description?: {
                    details?: string;
                    identity?: string;
                    moniker?: string;
                    securityContact?: string;
                    website?: string;
                };
                jailed?: boolean;
                minSelfDelegation?: string;
                operatorAddress?: string;
                status?: BondStatus;
                tokens?: string;
                unbondingHeight?: bigint;
                unbondingTime?: Date;
            };
        }): QueryDelegatorValidatorResponse;
        fromProtoMsg(message: QueryDelegatorValidatorResponseProtoMsg): QueryDelegatorValidatorResponse;
        toAmino(message: QueryDelegatorValidatorResponse): QueryDelegatorValidatorResponseAmino;
        toAminoMsg(message: QueryDelegatorValidatorResponse): QueryDelegatorValidatorResponseAminoMsg;
        toProto(message: QueryDelegatorValidatorResponse): Uint8Array;
        toProtoMsg(message: QueryDelegatorValidatorResponse): QueryDelegatorValidatorResponseProtoMsg;
    };
    QueryDelegatorValidatorsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegatorValidatorsRequest;
        encode(message: QueryDelegatorValidatorsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegatorValidatorsRequestAmino): QueryDelegatorValidatorsRequest;
        fromAminoMsg(object: QueryDelegatorValidatorsRequestAminoMsg): QueryDelegatorValidatorsRequest;
        fromPartial(object: {
            delegatorAddr?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryDelegatorValidatorsRequest;
        fromProtoMsg(message: QueryDelegatorValidatorsRequestProtoMsg): QueryDelegatorValidatorsRequest;
        toAmino(message: QueryDelegatorValidatorsRequest): QueryDelegatorValidatorsRequestAmino;
        toAminoMsg(message: QueryDelegatorValidatorsRequest): QueryDelegatorValidatorsRequestAminoMsg;
        toProto(message: QueryDelegatorValidatorsRequest): Uint8Array;
        toProtoMsg(message: QueryDelegatorValidatorsRequest): QueryDelegatorValidatorsRequestProtoMsg;
    };
    QueryDelegatorValidatorsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDelegatorValidatorsResponse;
        encode(message: QueryDelegatorValidatorsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDelegatorValidatorsResponseAmino): QueryDelegatorValidatorsResponse;
        fromAminoMsg(object: QueryDelegatorValidatorsResponseAminoMsg): QueryDelegatorValidatorsResponse;
        fromPartial(object: {
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
            validators?: {
                commission?: {
                    commissionRates?: {
                        maxChangeRate?: (...) | (...);
                        maxRate?: (...) | (...);
                        rate?: (...) | (...);
                    };
                    updateTime?: Date;
                };
                consensusPubkey?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                delegatorShares?: string;
                description?: {
                    details?: string;
                    identity?: string;
                    moniker?: string;
                    securityContact?: string;
                    website?: string;
                };
                jailed?: boolean;
                minSelfDelegation?: string;
                operatorAddress?: string;
                status?: BondStatus;
                tokens?: string;
                unbondingHeight?: bigint;
                unbondingTime?: Date;
            }[];
        }): QueryDelegatorValidatorsResponse;
        fromProtoMsg(message: QueryDelegatorValidatorsResponseProtoMsg): QueryDelegatorValidatorsResponse;
        toAmino(message: QueryDelegatorValidatorsResponse): QueryDelegatorValidatorsResponseAmino;
        toAminoMsg(message: QueryDelegatorValidatorsResponse): QueryDelegatorValidatorsResponseAminoMsg;
        toProto(message: QueryDelegatorValidatorsResponse): Uint8Array;
        toProtoMsg(message: QueryDelegatorValidatorsResponse): QueryDelegatorValidatorsResponseProtoMsg;
    };
    QueryHistoricalInfoRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryHistoricalInfoRequest;
        encode(message: QueryHistoricalInfoRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryHistoricalInfoRequestAmino): QueryHistoricalInfoRequest;
        fromAminoMsg(object: QueryHistoricalInfoRequestAminoMsg): QueryHistoricalInfoRequest;
        fromPartial(object: {
            height?: bigint;
        }): QueryHistoricalInfoRequest;
        fromProtoMsg(message: QueryHistoricalInfoRequestProtoMsg): QueryHistoricalInfoRequest;
        toAmino(message: QueryHistoricalInfoRequest): QueryHistoricalInfoRequestAmino;
        toAminoMsg(message: QueryHistoricalInfoRequest): QueryHistoricalInfoRequestAminoMsg;
        toProto(message: QueryHistoricalInfoRequest): Uint8Array;
        toProtoMsg(message: QueryHistoricalInfoRequest): QueryHistoricalInfoRequestProtoMsg;
    };
    QueryHistoricalInfoResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryHistoricalInfoResponse;
        encode(message: QueryHistoricalInfoResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryHistoricalInfoResponseAmino): QueryHistoricalInfoResponse;
        fromAminoMsg(object: QueryHistoricalInfoResponseAminoMsg): QueryHistoricalInfoResponse;
        fromPartial(object: {
            hist?: {
                header?: {
                    appHash?: Uint8Array;
                    chainId?: string;
                    consensusHash?: Uint8Array;
                    dataHash?: Uint8Array;
                    evidenceHash?: Uint8Array;
                    height?: bigint;
                    lastBlockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    lastCommitHash?: Uint8Array;
                    lastResultsHash?: Uint8Array;
                    nextValidatorsHash?: Uint8Array;
                    proposerAddress?: Uint8Array;
                    time?: Date;
                    validatorsHash?: Uint8Array;
                    version?: {
                        app?: bigint;
                        block?: bigint;
                    };
                };
                valset?: {
                    commission?: {
                        commissionRates?: (...) | (...);
                        updateTime?: (...) | (...);
                    };
                    consensusPubkey?: {
                        $typeUrl?: (...) | (...);
                        typeUrl?: (...) | (...);
                        value?: (...) | (...);
                    };
                    delegatorShares?: string;
                    description?: {
                        details?: (...) | (...);
                        identity?: (...) | (...);
                        moniker?: (...) | (...);
                        securityContact?: (...) | (...);
                        website?: (...) | (...);
                    };
                    jailed?: boolean;
                    minSelfDelegation?: string;
                    operatorAddress?: string;
                    status?: BondStatus;
                    tokens?: string;
                    unbondingHeight?: bigint;
                    unbondingTime?: Date;
                }[];
            };
        }): QueryHistoricalInfoResponse;
        fromProtoMsg(message: QueryHistoricalInfoResponseProtoMsg): QueryHistoricalInfoResponse;
        toAmino(message: QueryHistoricalInfoResponse): QueryHistoricalInfoResponseAmino;
        toAminoMsg(message: QueryHistoricalInfoResponse): QueryHistoricalInfoResponseAminoMsg;
        toProto(message: QueryHistoricalInfoResponse): Uint8Array;
        toProtoMsg(message: QueryHistoricalInfoResponse): QueryHistoricalInfoResponseProtoMsg;
    };
    QueryParamsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsRequest;
        encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
        fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
        fromPartial(_: {}): QueryParamsRequest;
        fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
        toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
        toAminoMsg(message: QueryParamsRequest): QueryParamsRequestAminoMsg;
        toProto(message: QueryParamsRequest): Uint8Array;
        toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
    };
    QueryParamsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsResponse;
        encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
        fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
        fromPartial(object: {
            params?: {
                bondDenom?: string;
                historicalEntries?: number;
                maxEntries?: number;
                maxValidators?: number;
                maxVotingPowerEnforcementThreshold?: string;
                maxVotingPowerRatio?: string;
                minCommissionRate?: string;
                unbondingTime?: {
                    nanos?: number;
                    seconds?: bigint;
                };
            };
        }): QueryParamsResponse;
        fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
        toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
        toAminoMsg(message: QueryParamsResponse): QueryParamsResponseAminoMsg;
        toProto(message: QueryParamsResponse): Uint8Array;
        toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
    };
    QueryPoolRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPoolRequest;
        encode(_: QueryPoolRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: QueryPoolRequestAmino): QueryPoolRequest;
        fromAminoMsg(object: QueryPoolRequestAminoMsg): QueryPoolRequest;
        fromPartial(_: {}): QueryPoolRequest;
        fromProtoMsg(message: QueryPoolRequestProtoMsg): QueryPoolRequest;
        toAmino(_: QueryPoolRequest): QueryPoolRequestAmino;
        toAminoMsg(message: QueryPoolRequest): QueryPoolRequestAminoMsg;
        toProto(message: QueryPoolRequest): Uint8Array;
        toProtoMsg(message: QueryPoolRequest): QueryPoolRequestProtoMsg;
    };
    QueryPoolResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPoolResponse;
        encode(message: QueryPoolResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPoolResponseAmino): QueryPoolResponse;
        fromAminoMsg(object: QueryPoolResponseAminoMsg): QueryPoolResponse;
        fromPartial(object: {
            pool?: {
                bondedTokens?: string;
                notBondedTokens?: string;
            };
        }): QueryPoolResponse;
        fromProtoMsg(message: QueryPoolResponseProtoMsg): QueryPoolResponse;
        toAmino(message: QueryPoolResponse): QueryPoolResponseAmino;
        toAminoMsg(message: QueryPoolResponse): QueryPoolResponseAminoMsg;
        toProto(message: QueryPoolResponse): Uint8Array;
        toProtoMsg(message: QueryPoolResponse): QueryPoolResponseProtoMsg;
    };
    QueryRedelegationsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryRedelegationsRequest;
        encode(message: QueryRedelegationsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryRedelegationsRequestAmino): QueryRedelegationsRequest;
        fromAminoMsg(object: QueryRedelegationsRequestAminoMsg): QueryRedelegationsRequest;
        fromPartial(object: {
            delegatorAddr?: string;
            dstValidatorAddr?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            srcValidatorAddr?: string;
        }): QueryRedelegationsRequest;
        fromProtoMsg(message: QueryRedelegationsRequestProtoMsg): QueryRedelegationsRequest;
        toAmino(message: QueryRedelegationsRequest): QueryRedelegationsRequestAmino;
        toAminoMsg(message: QueryRedelegationsRequest): QueryRedelegationsRequestAminoMsg;
        toProto(message: QueryRedelegationsRequest): Uint8Array;
        toProtoMsg(message: QueryRedelegationsRequest): QueryRedelegationsRequestProtoMsg;
    };
    QueryRedelegationsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryRedelegationsResponse;
        encode(message: QueryRedelegationsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryRedelegationsResponseAmino): QueryRedelegationsResponse;
        fromAminoMsg(object: QueryRedelegationsResponseAminoMsg): QueryRedelegationsResponse;
        fromPartial(object: {
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
            redelegationResponses?: {
                entries?: {
                    balance?: string;
                    redelegationEntry?: {
                        completionTime?: ...;
                        creationHeight?: ...;
                        initialBalance?: ...;
                        sharesDst?: ...;
                    };
                }[];
                redelegation?: {
                    delegatorAddress?: string;
                    entries?: {
                        completionTime?: ...;
                        creationHeight?: ...;
                        initialBalance?: ...;
                        sharesDst?: ...;
                    }[];
                    validatorDstAddress?: string;
                    validatorSrcAddress?: string;
                };
            }[];
        }): QueryRedelegationsResponse;
        fromProtoMsg(message: QueryRedelegationsResponseProtoMsg): QueryRedelegationsResponse;
        toAmino(message: QueryRedelegationsResponse): QueryRedelegationsResponseAmino;
        toAminoMsg(message: QueryRedelegationsResponse): QueryRedelegationsResponseAminoMsg;
        toProto(message: QueryRedelegationsResponse): Uint8Array;
        toProtoMsg(message: QueryRedelegationsResponse): QueryRedelegationsResponseProtoMsg;
    };
    QueryUnbondingDelegationRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUnbondingDelegationRequest;
        encode(message: QueryUnbondingDelegationRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryUnbondingDelegationRequestAmino): QueryUnbondingDelegationRequest;
        fromAminoMsg(object: QueryUnbondingDelegationRequestAminoMsg): QueryUnbondingDelegationRequest;
        fromPartial(object: {
            delegatorAddr?: string;
            validatorAddr?: string;
        }): QueryUnbondingDelegationRequest;
        fromProtoMsg(message: QueryUnbondingDelegationRequestProtoMsg): QueryUnbondingDelegationRequest;
        toAmino(message: QueryUnbondingDelegationRequest): QueryUnbondingDelegationRequestAmino;
        toAminoMsg(message: QueryUnbondingDelegationRequest): QueryUnbondingDelegationRequestAminoMsg;
        toProto(message: QueryUnbondingDelegationRequest): Uint8Array;
        toProtoMsg(message: QueryUnbondingDelegationRequest): QueryUnbondingDelegationRequestProtoMsg;
    };
    QueryUnbondingDelegationResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUnbondingDelegationResponse;
        encode(message: QueryUnbondingDelegationResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryUnbondingDelegationResponseAmino): QueryUnbondingDelegationResponse;
        fromAminoMsg(object: QueryUnbondingDelegationResponseAminoMsg): QueryUnbondingDelegationResponse;
        fromPartial(object: {
            unbond?: {
                delegatorAddress?: string;
                entries?: {
                    balance?: string;
                    completionTime?: Date;
                    creationHeight?: bigint;
                    initialBalance?: string;
                }[];
                validatorAddress?: string;
            };
        }): QueryUnbondingDelegationResponse;
        fromProtoMsg(message: QueryUnbondingDelegationResponseProtoMsg): QueryUnbondingDelegationResponse;
        toAmino(message: QueryUnbondingDelegationResponse): QueryUnbondingDelegationResponseAmino;
        toAminoMsg(message: QueryUnbondingDelegationResponse): QueryUnbondingDelegationResponseAminoMsg;
        toProto(message: QueryUnbondingDelegationResponse): Uint8Array;
        toProtoMsg(message: QueryUnbondingDelegationResponse): QueryUnbondingDelegationResponseProtoMsg;
    };
    QueryValidatorDelegationsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryValidatorDelegationsRequest;
        encode(message: QueryValidatorDelegationsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryValidatorDelegationsRequestAmino): QueryValidatorDelegationsRequest;
        fromAminoMsg(object: QueryValidatorDelegationsRequestAminoMsg): QueryValidatorDelegationsRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            validatorAddr?: string;
        }): QueryValidatorDelegationsRequest;
        fromProtoMsg(message: QueryValidatorDelegationsRequestProtoMsg): QueryValidatorDelegationsRequest;
        toAmino(message: QueryValidatorDelegationsRequest): QueryValidatorDelegationsRequestAmino;
        toAminoMsg(message: QueryValidatorDelegationsRequest): QueryValidatorDelegationsRequestAminoMsg;
        toProto(message: QueryValidatorDelegationsRequest): Uint8Array;
        toProtoMsg(message: QueryValidatorDelegationsRequest): QueryValidatorDelegationsRequestProtoMsg;
    };
    QueryValidatorDelegationsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryValidatorDelegationsResponse;
        encode(message: QueryValidatorDelegationsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryValidatorDelegationsResponseAmino): QueryValidatorDelegationsResponse;
        fromAminoMsg(object: QueryValidatorDelegationsResponseAminoMsg): QueryValidatorDelegationsResponse;
        fromPartial(object: {
            delegationResponses?: {
                balance?: {
                    amount?: string;
                    denom?: string;
                };
                delegation?: {
                    delegatorAddress?: string;
                    shares?: string;
                    validatorAddress?: string;
                };
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryValidatorDelegationsResponse;
        fromProtoMsg(message: QueryValidatorDelegationsResponseProtoMsg): QueryValidatorDelegationsResponse;
        toAmino(message: QueryValidatorDelegationsResponse): QueryValidatorDelegationsResponseAmino;
        toAminoMsg(message: QueryValidatorDelegationsResponse): QueryValidatorDelegationsResponseAminoMsg;
        toProto(message: QueryValidatorDelegationsResponse): Uint8Array;
        toProtoMsg(message: QueryValidatorDelegationsResponse): QueryValidatorDelegationsResponseProtoMsg;
    };
    QueryValidatorRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryValidatorRequest;
        encode(message: QueryValidatorRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryValidatorRequestAmino): QueryValidatorRequest;
        fromAminoMsg(object: QueryValidatorRequestAminoMsg): QueryValidatorRequest;
        fromPartial(object: {
            validatorAddr?: string;
        }): QueryValidatorRequest;
        fromProtoMsg(message: QueryValidatorRequestProtoMsg): QueryValidatorRequest;
        toAmino(message: QueryValidatorRequest): QueryValidatorRequestAmino;
        toAminoMsg(message: QueryValidatorRequest): QueryValidatorRequestAminoMsg;
        toProto(message: QueryValidatorRequest): Uint8Array;
        toProtoMsg(message: QueryValidatorRequest): QueryValidatorRequestProtoMsg;
    };
    QueryValidatorResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryValidatorResponse;
        encode(message: QueryValidatorResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryValidatorResponseAmino): QueryValidatorResponse;
        fromAminoMsg(object: QueryValidatorResponseAminoMsg): QueryValidatorResponse;
        fromPartial(object: {
            validator?: {
                commission?: {
                    commissionRates?: {
                        maxChangeRate?: string;
                        maxRate?: string;
                        rate?: string;
                    };
                    updateTime?: Date;
                };
                consensusPubkey?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                delegatorShares?: string;
                description?: {
                    details?: string;
                    identity?: string;
                    moniker?: string;
                    securityContact?: string;
                    website?: string;
                };
                jailed?: boolean;
                minSelfDelegation?: string;
                operatorAddress?: string;
                status?: BondStatus;
                tokens?: string;
                unbondingHeight?: bigint;
                unbondingTime?: Date;
            };
        }): QueryValidatorResponse;
        fromProtoMsg(message: QueryValidatorResponseProtoMsg): QueryValidatorResponse;
        toAmino(message: QueryValidatorResponse): QueryValidatorResponseAmino;
        toAminoMsg(message: QueryValidatorResponse): QueryValidatorResponseAminoMsg;
        toProto(message: QueryValidatorResponse): Uint8Array;
        toProtoMsg(message: QueryValidatorResponse): QueryValidatorResponseProtoMsg;
    };
    QueryValidatorUnbondingDelegationsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryValidatorUnbondingDelegationsRequest;
        encode(message: QueryValidatorUnbondingDelegationsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryValidatorUnbondingDelegationsRequestAmino): QueryValidatorUnbondingDelegationsRequest;
        fromAminoMsg(object: QueryValidatorUnbondingDelegationsRequestAminoMsg): QueryValidatorUnbondingDelegationsRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            validatorAddr?: string;
        }): QueryValidatorUnbondingDelegationsRequest;
        fromProtoMsg(message: QueryValidatorUnbondingDelegationsRequestProtoMsg): QueryValidatorUnbondingDelegationsRequest;
        toAmino(message: QueryValidatorUnbondingDelegationsRequest): QueryValidatorUnbondingDelegationsRequestAmino;
        toAminoMsg(message: QueryValidatorUnbondingDelegationsRequest): QueryValidatorUnbondingDelegationsRequestAminoMsg;
        toProto(message: QueryValidatorUnbondingDelegationsRequest): Uint8Array;
        toProtoMsg(message: QueryValidatorUnbondingDelegationsRequest): QueryValidatorUnbondingDelegationsRequestProtoMsg;
    };
    QueryValidatorUnbondingDelegationsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryValidatorUnbondingDelegationsResponse;
        encode(message: QueryValidatorUnbondingDelegationsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryValidatorUnbondingDelegationsResponseAmino): QueryValidatorUnbondingDelegationsResponse;
        fromAminoMsg(object: QueryValidatorUnbondingDelegationsResponseAminoMsg): QueryValidatorUnbondingDelegationsResponse;
        fromPartial(object: {
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
            unbondingResponses?: {
                delegatorAddress?: string;
                entries?: {
                    balance?: string;
                    completionTime?: Date;
                    creationHeight?: bigint;
                    initialBalance?: string;
                }[];
                validatorAddress?: string;
            }[];
        }): QueryValidatorUnbondingDelegationsResponse;
        fromProtoMsg(message: QueryValidatorUnbondingDelegationsResponseProtoMsg): QueryValidatorUnbondingDelegationsResponse;
        toAmino(message: QueryValidatorUnbondingDelegationsResponse): QueryValidatorUnbondingDelegationsResponseAmino;
        toAminoMsg(message: QueryValidatorUnbondingDelegationsResponse): QueryValidatorUnbondingDelegationsResponseAminoMsg;
        toProto(message: QueryValidatorUnbondingDelegationsResponse): Uint8Array;
        toProtoMsg(message: QueryValidatorUnbondingDelegationsResponse): QueryValidatorUnbondingDelegationsResponseProtoMsg;
    };
    QueryValidatorsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryValidatorsRequest;
        encode(message: QueryValidatorsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryValidatorsRequestAmino): QueryValidatorsRequest;
        fromAminoMsg(object: QueryValidatorsRequestAminoMsg): QueryValidatorsRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            status?: string;
        }): QueryValidatorsRequest;
        fromProtoMsg(message: QueryValidatorsRequestProtoMsg): QueryValidatorsRequest;
        toAmino(message: QueryValidatorsRequest): QueryValidatorsRequestAmino;
        toAminoMsg(message: QueryValidatorsRequest): QueryValidatorsRequestAminoMsg;
        toProto(message: QueryValidatorsRequest): Uint8Array;
        toProtoMsg(message: QueryValidatorsRequest): QueryValidatorsRequestProtoMsg;
    };
    QueryValidatorsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryValidatorsResponse;
        encode(message: QueryValidatorsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryValidatorsResponseAmino): QueryValidatorsResponse;
        fromAminoMsg(object: QueryValidatorsResponseAminoMsg): QueryValidatorsResponse;
        fromPartial(object: {
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
            validators?: {
                commission?: {
                    commissionRates?: {
                        maxChangeRate?: (...) | (...);
                        maxRate?: (...) | (...);
                        rate?: (...) | (...);
                    };
                    updateTime?: Date;
                };
                consensusPubkey?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                delegatorShares?: string;
                description?: {
                    details?: string;
                    identity?: string;
                    moniker?: string;
                    securityContact?: string;
                    website?: string;
                };
                jailed?: boolean;
                minSelfDelegation?: string;
                operatorAddress?: string;
                status?: BondStatus;
                tokens?: string;
                unbondingHeight?: bigint;
                unbondingTime?: Date;
            }[];
        }): QueryValidatorsResponse;
        fromProtoMsg(message: QueryValidatorsResponseProtoMsg): QueryValidatorsResponse;
        toAmino(message: QueryValidatorsResponse): QueryValidatorsResponseAmino;
        toAminoMsg(message: QueryValidatorsResponse): QueryValidatorsResponseAminoMsg;
        toProto(message: QueryValidatorsResponse): Uint8Array;
        toProtoMsg(message: QueryValidatorsResponse): QueryValidatorsResponseProtoMsg;
    };
    Redelegation: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Redelegation;
        encode(message: Redelegation, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RedelegationAmino): Redelegation;
        fromAminoMsg(object: RedelegationAminoMsg): Redelegation;
        fromPartial(object: {
            delegatorAddress?: string;
            entries?: {
                completionTime?: Date;
                creationHeight?: bigint;
                initialBalance?: string;
                sharesDst?: string;
            }[];
            validatorDstAddress?: string;
            validatorSrcAddress?: string;
        }): Redelegation;
        fromProtoMsg(message: RedelegationProtoMsg): Redelegation;
        toAmino(message: Redelegation): RedelegationAmino;
        toAminoMsg(message: Redelegation): RedelegationAminoMsg;
        toProto(message: Redelegation): Uint8Array;
        toProtoMsg(message: Redelegation): RedelegationProtoMsg;
    };
    RedelegationEntry: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RedelegationEntry;
        encode(message: RedelegationEntry, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RedelegationEntryAmino): RedelegationEntry;
        fromAminoMsg(object: RedelegationEntryAminoMsg): RedelegationEntry;
        fromPartial(object: {
            completionTime?: Date;
            creationHeight?: bigint;
            initialBalance?: string;
            sharesDst?: string;
        }): RedelegationEntry;
        fromProtoMsg(message: RedelegationEntryProtoMsg): RedelegationEntry;
        toAmino(message: RedelegationEntry): RedelegationEntryAmino;
        toAminoMsg(message: RedelegationEntry): RedelegationEntryAminoMsg;
        toProto(message: RedelegationEntry): Uint8Array;
        toProtoMsg(message: RedelegationEntry): RedelegationEntryProtoMsg;
    };
    RedelegationEntryResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RedelegationEntryResponse;
        encode(message: RedelegationEntryResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RedelegationEntryResponseAmino): RedelegationEntryResponse;
        fromAminoMsg(object: RedelegationEntryResponseAminoMsg): RedelegationEntryResponse;
        fromPartial(object: {
            balance?: string;
            redelegationEntry?: {
                completionTime?: Date;
                creationHeight?: bigint;
                initialBalance?: string;
                sharesDst?: string;
            };
        }): RedelegationEntryResponse;
        fromProtoMsg(message: RedelegationEntryResponseProtoMsg): RedelegationEntryResponse;
        toAmino(message: RedelegationEntryResponse): RedelegationEntryResponseAmino;
        toAminoMsg(message: RedelegationEntryResponse): RedelegationEntryResponseAminoMsg;
        toProto(message: RedelegationEntryResponse): Uint8Array;
        toProtoMsg(message: RedelegationEntryResponse): RedelegationEntryResponseProtoMsg;
    };
    RedelegationResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RedelegationResponse;
        encode(message: RedelegationResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RedelegationResponseAmino): RedelegationResponse;
        fromAminoMsg(object: RedelegationResponseAminoMsg): RedelegationResponse;
        fromPartial(object: {
            entries?: {
                balance?: string;
                redelegationEntry?: {
                    completionTime?: Date;
                    creationHeight?: bigint;
                    initialBalance?: string;
                    sharesDst?: string;
                };
            }[];
            redelegation?: {
                delegatorAddress?: string;
                entries?: {
                    completionTime?: Date;
                    creationHeight?: bigint;
                    initialBalance?: string;
                    sharesDst?: string;
                }[];
                validatorDstAddress?: string;
                validatorSrcAddress?: string;
            };
        }): RedelegationResponse;
        fromProtoMsg(message: RedelegationResponseProtoMsg): RedelegationResponse;
        toAmino(message: RedelegationResponse): RedelegationResponseAmino;
        toAminoMsg(message: RedelegationResponse): RedelegationResponseAminoMsg;
        toProto(message: RedelegationResponse): Uint8Array;
        toProtoMsg(message: RedelegationResponse): RedelegationResponseProtoMsg;
    };
    StakeAuthorization: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): StakeAuthorization;
        encode(message: StakeAuthorization, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: StakeAuthorizationAmino): StakeAuthorization;
        fromAminoMsg(object: StakeAuthorizationAminoMsg): StakeAuthorization;
        fromPartial(object: {
            $typeUrl?: "/cosmos.staking.v1beta1.StakeAuthorization";
            allowList?: {
                address?: string[];
            };
            authorizationType?: AuthorizationType;
            denyList?: {
                address?: string[];
            };
            maxTokens?: {
                amount?: string;
                denom?: string;
            };
        }): StakeAuthorization;
        fromProtoMsg(message: StakeAuthorizationProtoMsg): StakeAuthorization;
        toAmino(message: StakeAuthorization): StakeAuthorizationAmino;
        toAminoMsg(message: StakeAuthorization): StakeAuthorizationAminoMsg;
        toProto(message: StakeAuthorization): Uint8Array;
        toProtoMsg(message: StakeAuthorization): StakeAuthorizationProtoMsg;
    };
    StakeAuthorization_Validators: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): StakeAuthorization_Validators;
        encode(message: StakeAuthorization_Validators, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: StakeAuthorization_ValidatorsAmino): StakeAuthorization_Validators;
        fromAminoMsg(object: StakeAuthorization_ValidatorsAminoMsg): StakeAuthorization_Validators;
        fromPartial(object: {
            address?: string[];
        }): StakeAuthorization_Validators;
        fromProtoMsg(message: StakeAuthorization_ValidatorsProtoMsg): StakeAuthorization_Validators;
        toAmino(message: StakeAuthorization_Validators): StakeAuthorization_ValidatorsAmino;
        toAminoMsg(message: StakeAuthorization_Validators): StakeAuthorization_ValidatorsAminoMsg;
        toProto(message: StakeAuthorization_Validators): Uint8Array;
        toProtoMsg(message: StakeAuthorization_Validators): StakeAuthorization_ValidatorsProtoMsg;
    };
    UnbondingDelegation: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): UnbondingDelegation;
        encode(message: UnbondingDelegation, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: UnbondingDelegationAmino): UnbondingDelegation;
        fromAminoMsg(object: UnbondingDelegationAminoMsg): UnbondingDelegation;
        fromPartial(object: {
            delegatorAddress?: string;
            entries?: {
                balance?: string;
                completionTime?: Date;
                creationHeight?: bigint;
                initialBalance?: string;
            }[];
            validatorAddress?: string;
        }): UnbondingDelegation;
        fromProtoMsg(message: UnbondingDelegationProtoMsg): UnbondingDelegation;
        toAmino(message: UnbondingDelegation): UnbondingDelegationAmino;
        toAminoMsg(message: UnbondingDelegation): UnbondingDelegationAminoMsg;
        toProto(message: UnbondingDelegation): Uint8Array;
        toProtoMsg(message: UnbondingDelegation): UnbondingDelegationProtoMsg;
    };
    UnbondingDelegationEntry: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): UnbondingDelegationEntry;
        encode(message: UnbondingDelegationEntry, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: UnbondingDelegationEntryAmino): UnbondingDelegationEntry;
        fromAminoMsg(object: UnbondingDelegationEntryAminoMsg): UnbondingDelegationEntry;
        fromPartial(object: {
            balance?: string;
            completionTime?: Date;
            creationHeight?: bigint;
            initialBalance?: string;
        }): UnbondingDelegationEntry;
        fromProtoMsg(message: UnbondingDelegationEntryProtoMsg): UnbondingDelegationEntry;
        toAmino(message: UnbondingDelegationEntry): UnbondingDelegationEntryAmino;
        toAminoMsg(message: UnbondingDelegationEntry): UnbondingDelegationEntryAminoMsg;
        toProto(message: UnbondingDelegationEntry): Uint8Array;
        toProtoMsg(message: UnbondingDelegationEntry): UnbondingDelegationEntryProtoMsg;
    };
    ValAddresses: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ValAddresses;
        encode(message: ValAddresses, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValAddressesAmino): ValAddresses;
        fromAminoMsg(object: ValAddressesAminoMsg): ValAddresses;
        fromPartial(object: {
            addresses?: string[];
        }): ValAddresses;
        fromProtoMsg(message: ValAddressesProtoMsg): ValAddresses;
        toAmino(message: ValAddresses): ValAddressesAmino;
        toAminoMsg(message: ValAddresses): ValAddressesAminoMsg;
        toProto(message: ValAddresses): Uint8Array;
        toProtoMsg(message: ValAddresses): ValAddressesProtoMsg;
    };
    Validator: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Validator;
        encode(message: Validator, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorAmino): Validator;
        fromAminoMsg(object: ValidatorAminoMsg): Validator;
        fromPartial(object: {
            commission?: {
                commissionRates?: {
                    maxChangeRate?: string;
                    maxRate?: string;
                    rate?: string;
                };
                updateTime?: Date;
            };
            consensusPubkey?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            delegatorShares?: string;
            description?: {
                details?: string;
                identity?: string;
                moniker?: string;
                securityContact?: string;
                website?: string;
            };
            jailed?: boolean;
            minSelfDelegation?: string;
            operatorAddress?: string;
            status?: BondStatus;
            tokens?: string;
            unbondingHeight?: bigint;
            unbondingTime?: Date;
        }): Validator;
        fromProtoMsg(message: ValidatorProtoMsg): Validator;
        toAmino(message: Validator): ValidatorAmino;
        toAminoMsg(message: Validator): ValidatorAminoMsg;
        toProto(message: Validator): Uint8Array;
        toProtoMsg(message: Validator): ValidatorProtoMsg;
    };
    createRpcQueryExtension: ((base: QueryClient) => {
        delegation(request: QueryDelegationRequest): Promise<QueryDelegationResponse>;
        delegatorDelegations(request: QueryDelegatorDelegationsRequest): Promise<QueryDelegatorDelegationsResponse>;
        delegatorUnbondingDelegations(request: QueryDelegatorUnbondingDelegationsRequest): Promise<QueryDelegatorUnbondingDelegationsResponse>;
        delegatorValidator(request: QueryDelegatorValidatorRequest): Promise<QueryDelegatorValidatorResponse>;
        delegatorValidators(request: QueryDelegatorValidatorsRequest): Promise<QueryDelegatorValidatorsResponse>;
        historicalInfo(request: QueryHistoricalInfoRequest): Promise<QueryHistoricalInfoResponse>;
        params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
        pool(request?: QueryPoolRequest): Promise<QueryPoolResponse>;
        redelegations(request: QueryRedelegationsRequest): Promise<QueryRedelegationsResponse>;
        unbondingDelegation(request: QueryUnbondingDelegationRequest): Promise<QueryUnbondingDelegationResponse>;
        validator(request: QueryValidatorRequest): Promise<QueryValidatorResponse>;
        validatorDelegations(request: QueryValidatorDelegationsRequest): Promise<QueryValidatorDelegationsResponse>;
        validatorUnbondingDelegations(request: QueryValidatorUnbondingDelegationsRequest): Promise<QueryValidatorUnbondingDelegationsResponse>;
        validators(request: QueryValidatorsRequest): Promise<QueryValidatorsResponse>;
    });
    load: ((protoRegistry: Registry) => void);
    registry: readonly [string, TelescopeGeneratedType<any, any, any>][];
    authorizationTypeFromJSON(object: any): AuthorizationType;
    authorizationTypeToJSON(object: AuthorizationType): string;
    bondStatusFromJSON(object: any): BondStatus;
    bondStatusToJSON(object: BondStatus): string;
} = ...