Variable v1beta1Const

v1beta1: {
    ProposalStatus: any;
    VoteOption: any;
    LCDQueryClient: any;
    MsgClientImpl: any;
    QueryClientImpl: any;
    AminoConverter: {
        /cosmos.gov.v1beta1.MsgDeposit: {
            aminoType: string;
            fromAmino: ((object: MsgDepositAmino) => MsgDeposit);
            toAmino: ((message: MsgDeposit) => MsgDepositAmino);
        };
        /cosmos.gov.v1beta1.MsgSubmitProposal: {
            aminoType: string;
            fromAmino: ((object: MsgSubmitProposalAmino) => MsgSubmitProposal);
            toAmino: ((message: MsgSubmitProposal) => MsgSubmitProposalAmino);
        };
        /cosmos.gov.v1beta1.MsgVote: {
            aminoType: string;
            fromAmino: ((object: MsgVoteAmino) => MsgVote);
            toAmino: ((message: MsgVote) => MsgVoteAmino);
        };
        /cosmos.gov.v1beta1.MsgVoteWeighted: {
            aminoType: string;
            fromAmino: ((object: MsgVoteWeightedAmino) => MsgVoteWeighted);
            toAmino: ((message: MsgVoteWeighted) => MsgVoteWeightedAmino);
        };
    };
    Content_FromAmino: ((content: AnyAmino) => Any);
    Content_InterfaceDecoder: ((input: Uint8Array | BinaryReader) => Any | TextProposal);
    Content_ToAmino: ((content: Any) => AnyAmino);
    Deposit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Deposit;
        encode(message: Deposit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DepositAmino): Deposit;
        fromAminoMsg(object: DepositAminoMsg): Deposit;
        fromPartial(object: {
            amount?: {
                amount?: string;
                denom?: string;
            }[];
            depositor?: string;
            proposalId?: bigint;
        }): Deposit;
        fromProtoMsg(message: DepositProtoMsg): Deposit;
        toAmino(message: Deposit): DepositAmino;
        toAminoMsg(message: Deposit): DepositAminoMsg;
        toProto(message: Deposit): Uint8Array;
        toProtoMsg(message: Deposit): DepositProtoMsg;
    };
    DepositParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): DepositParams;
        encode(message: DepositParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: DepositParamsAmino): DepositParams;
        fromAminoMsg(object: DepositParamsAminoMsg): DepositParams;
        fromPartial(object: {
            maxDepositPeriod?: {
                nanos?: number;
                seconds?: bigint;
            };
            minDeposit?: {
                amount?: string;
                denom?: string;
            }[];
            minExpeditedDeposit?: {
                amount?: string;
                denom?: string;
            }[];
        }): DepositParams;
        fromProtoMsg(message: DepositParamsProtoMsg): DepositParams;
        toAmino(message: DepositParams): DepositParamsAmino;
        toAminoMsg(message: DepositParams): DepositParamsAminoMsg;
        toProto(message: DepositParams): Uint8Array;
        toProtoMsg(message: DepositParams): DepositParamsProtoMsg;
    };
    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: {
            depositParams?: {
                maxDepositPeriod?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                minDeposit?: {
                    amount?: string;
                    denom?: string;
                }[];
                minExpeditedDeposit?: {
                    amount?: string;
                    denom?: string;
                }[];
            };
            deposits?: {
                amount?: {
                    amount?: string;
                    denom?: string;
                }[];
                depositor?: string;
                proposalId?: bigint;
            }[];
            proposals?: {
                content?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                } | {
                    $typeUrl?: "/cosmos.gov.v1beta1.TextProposal";
                    description?: string;
                    isExpedited?: boolean;
                    title?: string;
                };
                depositEndTime?: Date;
                finalTallyResult?: {
                    abstain?: string;
                    no?: string;
                    noWithVeto?: string;
                    yes?: string;
                };
                isExpedited?: boolean;
                proposalId?: bigint;
                status?: ProposalStatus;
                submitTime?: Date;
                totalDeposit?: {
                    amount?: string;
                    denom?: string;
                }[];
                votingEndTime?: Date;
                votingStartTime?: Date;
            }[];
            startingProposalId?: bigint;
            tallyParams?: {
                expeditedQuorum?: Uint8Array;
                expeditedThreshold?: Uint8Array;
                quorum?: Uint8Array;
                threshold?: Uint8Array;
                vetoThreshold?: Uint8Array;
            };
            votes?: {
                option?: VoteOption;
                options?: {
                    option?: VoteOption;
                    weight?: string;
                }[];
                proposalId?: bigint;
                voter?: string;
            }[];
            votingParams?: {
                expeditedVotingPeriod?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                votingPeriod?: {
                    nanos?: number;
                    seconds?: bigint;
                };
            };
        }): GenesisState;
        fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
        toAmino(message: GenesisState): GenesisStateAmino;
        toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
        toProto(message: GenesisState): Uint8Array;
        toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
    };
    MessageComposer: {
        encoded: {
            deposit(value: MsgDeposit): {
                typeUrl: string;
                value: Uint8Array;
            };
            submitProposal(value: MsgSubmitProposal): {
                typeUrl: string;
                value: Uint8Array;
            };
            vote(value: MsgVote): {
                typeUrl: string;
                value: Uint8Array;
            };
            voteWeighted(value: MsgVoteWeighted): {
                typeUrl: string;
                value: Uint8Array;
            };
        };
        fromPartial: {
            deposit(value: MsgDeposit): {
                typeUrl: string;
                value: MsgDeposit;
            };
            submitProposal(value: MsgSubmitProposal): {
                typeUrl: string;
                value: MsgSubmitProposal;
            };
            vote(value: MsgVote): {
                typeUrl: string;
                value: MsgVote;
            };
            voteWeighted(value: MsgVoteWeighted): {
                typeUrl: string;
                value: MsgVoteWeighted;
            };
        };
        withTypeUrl: {
            deposit(value: MsgDeposit): {
                typeUrl: string;
                value: MsgDeposit;
            };
            submitProposal(value: MsgSubmitProposal): {
                typeUrl: string;
                value: MsgSubmitProposal;
            };
            vote(value: MsgVote): {
                typeUrl: string;
                value: MsgVote;
            };
            voteWeighted(value: MsgVoteWeighted): {
                typeUrl: string;
                value: MsgVoteWeighted;
            };
        };
    };
    MsgDeposit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgDeposit;
        encode(message: MsgDeposit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgDepositAmino): MsgDeposit;
        fromAminoMsg(object: MsgDepositAminoMsg): MsgDeposit;
        fromPartial(object: {
            amount?: {
                amount?: string;
                denom?: string;
            }[];
            depositor?: string;
            proposalId?: bigint;
        }): MsgDeposit;
        fromProtoMsg(message: MsgDepositProtoMsg): MsgDeposit;
        toAmino(message: MsgDeposit): MsgDepositAmino;
        toAminoMsg(message: MsgDeposit): MsgDepositAminoMsg;
        toProto(message: MsgDeposit): Uint8Array;
        toProtoMsg(message: MsgDeposit): MsgDepositProtoMsg;
    };
    MsgDepositResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgDepositResponse;
        encode(_: MsgDepositResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgDepositResponseAmino): MsgDepositResponse;
        fromAminoMsg(object: MsgDepositResponseAminoMsg): MsgDepositResponse;
        fromPartial(_: {}): MsgDepositResponse;
        fromProtoMsg(message: MsgDepositResponseProtoMsg): MsgDepositResponse;
        toAmino(_: MsgDepositResponse): MsgDepositResponseAmino;
        toAminoMsg(message: MsgDepositResponse): MsgDepositResponseAminoMsg;
        toProto(message: MsgDepositResponse): Uint8Array;
        toProtoMsg(message: MsgDepositResponse): MsgDepositResponseProtoMsg;
    };
    MsgSubmitProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgSubmitProposal;
        encode(message: MsgSubmitProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgSubmitProposalAmino): MsgSubmitProposal;
        fromAminoMsg(object: MsgSubmitProposalAminoMsg): MsgSubmitProposal;
        fromPartial(object: {
            content?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            } | {
                $typeUrl?: "/cosmos.gov.v1beta1.TextProposal";
                description?: string;
                isExpedited?: boolean;
                title?: string;
            };
            initialDeposit?: {
                amount?: string;
                denom?: string;
            }[];
            isExpedited?: boolean;
            proposer?: string;
        }): MsgSubmitProposal;
        fromProtoMsg(message: MsgSubmitProposalProtoMsg): MsgSubmitProposal;
        toAmino(message: MsgSubmitProposal): MsgSubmitProposalAmino;
        toAminoMsg(message: MsgSubmitProposal): MsgSubmitProposalAminoMsg;
        toProto(message: MsgSubmitProposal): Uint8Array;
        toProtoMsg(message: MsgSubmitProposal): MsgSubmitProposalProtoMsg;
    };
    MsgSubmitProposalResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgSubmitProposalResponse;
        encode(message: MsgSubmitProposalResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgSubmitProposalResponseAmino): MsgSubmitProposalResponse;
        fromAminoMsg(object: MsgSubmitProposalResponseAminoMsg): MsgSubmitProposalResponse;
        fromPartial(object: {
            proposalId?: bigint;
        }): MsgSubmitProposalResponse;
        fromProtoMsg(message: MsgSubmitProposalResponseProtoMsg): MsgSubmitProposalResponse;
        toAmino(message: MsgSubmitProposalResponse): MsgSubmitProposalResponseAmino;
        toAminoMsg(message: MsgSubmitProposalResponse): MsgSubmitProposalResponseAminoMsg;
        toProto(message: MsgSubmitProposalResponse): Uint8Array;
        toProtoMsg(message: MsgSubmitProposalResponse): MsgSubmitProposalResponseProtoMsg;
    };
    MsgVote: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgVote;
        encode(message: MsgVote, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgVoteAmino): MsgVote;
        fromAminoMsg(object: MsgVoteAminoMsg): MsgVote;
        fromPartial(object: {
            option?: VoteOption;
            proposalId?: bigint;
            voter?: string;
        }): MsgVote;
        fromProtoMsg(message: MsgVoteProtoMsg): MsgVote;
        toAmino(message: MsgVote): MsgVoteAmino;
        toAminoMsg(message: MsgVote): MsgVoteAminoMsg;
        toProto(message: MsgVote): Uint8Array;
        toProtoMsg(message: MsgVote): MsgVoteProtoMsg;
    };
    MsgVoteResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgVoteResponse;
        encode(_: MsgVoteResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgVoteResponseAmino): MsgVoteResponse;
        fromAminoMsg(object: MsgVoteResponseAminoMsg): MsgVoteResponse;
        fromPartial(_: {}): MsgVoteResponse;
        fromProtoMsg(message: MsgVoteResponseProtoMsg): MsgVoteResponse;
        toAmino(_: MsgVoteResponse): MsgVoteResponseAmino;
        toAminoMsg(message: MsgVoteResponse): MsgVoteResponseAminoMsg;
        toProto(message: MsgVoteResponse): Uint8Array;
        toProtoMsg(message: MsgVoteResponse): MsgVoteResponseProtoMsg;
    };
    MsgVoteWeighted: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgVoteWeighted;
        encode(message: MsgVoteWeighted, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgVoteWeightedAmino): MsgVoteWeighted;
        fromAminoMsg(object: MsgVoteWeightedAminoMsg): MsgVoteWeighted;
        fromPartial(object: {
            options?: {
                option?: VoteOption;
                weight?: string;
            }[];
            proposalId?: bigint;
            voter?: string;
        }): MsgVoteWeighted;
        fromProtoMsg(message: MsgVoteWeightedProtoMsg): MsgVoteWeighted;
        toAmino(message: MsgVoteWeighted): MsgVoteWeightedAmino;
        toAminoMsg(message: MsgVoteWeighted): MsgVoteWeightedAminoMsg;
        toProto(message: MsgVoteWeighted): Uint8Array;
        toProtoMsg(message: MsgVoteWeighted): MsgVoteWeightedProtoMsg;
    };
    MsgVoteWeightedResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgVoteWeightedResponse;
        encode(_: MsgVoteWeightedResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgVoteWeightedResponseAmino): MsgVoteWeightedResponse;
        fromAminoMsg(object: MsgVoteWeightedResponseAminoMsg): MsgVoteWeightedResponse;
        fromPartial(_: {}): MsgVoteWeightedResponse;
        fromProtoMsg(message: MsgVoteWeightedResponseProtoMsg): MsgVoteWeightedResponse;
        toAmino(_: MsgVoteWeightedResponse): MsgVoteWeightedResponseAmino;
        toAminoMsg(message: MsgVoteWeightedResponse): MsgVoteWeightedResponseAminoMsg;
        toProto(message: MsgVoteWeightedResponse): Uint8Array;
        toProtoMsg(message: MsgVoteWeightedResponse): MsgVoteWeightedResponseProtoMsg;
    };
    Proposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Proposal;
        encode(message: Proposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ProposalAmino): Proposal;
        fromAminoMsg(object: ProposalAminoMsg): Proposal;
        fromPartial(object: {
            content?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            } | {
                $typeUrl?: "/cosmos.gov.v1beta1.TextProposal";
                description?: string;
                isExpedited?: boolean;
                title?: string;
            };
            depositEndTime?: Date;
            finalTallyResult?: {
                abstain?: string;
                no?: string;
                noWithVeto?: string;
                yes?: string;
            };
            isExpedited?: boolean;
            proposalId?: bigint;
            status?: ProposalStatus;
            submitTime?: Date;
            totalDeposit?: {
                amount?: string;
                denom?: string;
            }[];
            votingEndTime?: Date;
            votingStartTime?: Date;
        }): Proposal;
        fromProtoMsg(message: ProposalProtoMsg): Proposal;
        toAmino(message: Proposal): ProposalAmino;
        toAminoMsg(message: Proposal): ProposalAminoMsg;
        toProto(message: Proposal): Uint8Array;
        toProtoMsg(message: Proposal): ProposalProtoMsg;
    };
    ProposalStatusAmino: typeof ProposalStatus;
    ProposalStatusSDKType: typeof ProposalStatus;
    QueryDepositRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDepositRequest;
        encode(message: QueryDepositRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDepositRequestAmino): QueryDepositRequest;
        fromAminoMsg(object: QueryDepositRequestAminoMsg): QueryDepositRequest;
        fromPartial(object: {
            depositor?: string;
            proposalId?: bigint;
        }): QueryDepositRequest;
        fromProtoMsg(message: QueryDepositRequestProtoMsg): QueryDepositRequest;
        toAmino(message: QueryDepositRequest): QueryDepositRequestAmino;
        toAminoMsg(message: QueryDepositRequest): QueryDepositRequestAminoMsg;
        toProto(message: QueryDepositRequest): Uint8Array;
        toProtoMsg(message: QueryDepositRequest): QueryDepositRequestProtoMsg;
    };
    QueryDepositResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDepositResponse;
        encode(message: QueryDepositResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDepositResponseAmino): QueryDepositResponse;
        fromAminoMsg(object: QueryDepositResponseAminoMsg): QueryDepositResponse;
        fromPartial(object: {
            deposit?: {
                amount?: {
                    amount?: string;
                    denom?: string;
                }[];
                depositor?: string;
                proposalId?: bigint;
            };
        }): QueryDepositResponse;
        fromProtoMsg(message: QueryDepositResponseProtoMsg): QueryDepositResponse;
        toAmino(message: QueryDepositResponse): QueryDepositResponseAmino;
        toAminoMsg(message: QueryDepositResponse): QueryDepositResponseAminoMsg;
        toProto(message: QueryDepositResponse): Uint8Array;
        toProtoMsg(message: QueryDepositResponse): QueryDepositResponseProtoMsg;
    };
    QueryDepositsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDepositsRequest;
        encode(message: QueryDepositsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDepositsRequestAmino): QueryDepositsRequest;
        fromAminoMsg(object: QueryDepositsRequestAminoMsg): QueryDepositsRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            proposalId?: bigint;
        }): QueryDepositsRequest;
        fromProtoMsg(message: QueryDepositsRequestProtoMsg): QueryDepositsRequest;
        toAmino(message: QueryDepositsRequest): QueryDepositsRequestAmino;
        toAminoMsg(message: QueryDepositsRequest): QueryDepositsRequestAminoMsg;
        toProto(message: QueryDepositsRequest): Uint8Array;
        toProtoMsg(message: QueryDepositsRequest): QueryDepositsRequestProtoMsg;
    };
    QueryDepositsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryDepositsResponse;
        encode(message: QueryDepositsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryDepositsResponseAmino): QueryDepositsResponse;
        fromAminoMsg(object: QueryDepositsResponseAminoMsg): QueryDepositsResponse;
        fromPartial(object: {
            deposits?: {
                amount?: {
                    amount?: string;
                    denom?: string;
                }[];
                depositor?: string;
                proposalId?: bigint;
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryDepositsResponse;
        fromProtoMsg(message: QueryDepositsResponseProtoMsg): QueryDepositsResponse;
        toAmino(message: QueryDepositsResponse): QueryDepositsResponseAmino;
        toAminoMsg(message: QueryDepositsResponse): QueryDepositsResponseAminoMsg;
        toProto(message: QueryDepositsResponse): Uint8Array;
        toProtoMsg(message: QueryDepositsResponse): QueryDepositsResponseProtoMsg;
    };
    QueryParamsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsRequest;
        encode(message: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryParamsRequestAmino): QueryParamsRequest;
        fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
        fromPartial(object: {
            paramsType?: string;
        }): QueryParamsRequest;
        fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
        toAmino(message: 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: {
            depositParams?: {
                maxDepositPeriod?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                minDeposit?: {
                    amount?: string;
                    denom?: string;
                }[];
                minExpeditedDeposit?: {
                    amount?: string;
                    denom?: string;
                }[];
            };
            tallyParams?: {
                expeditedQuorum?: Uint8Array;
                expeditedThreshold?: Uint8Array;
                quorum?: Uint8Array;
                threshold?: Uint8Array;
                vetoThreshold?: Uint8Array;
            };
            votingParams?: {
                expeditedVotingPeriod?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                votingPeriod?: {
                    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;
    };
    QueryProposalRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryProposalRequest;
        encode(message: QueryProposalRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryProposalRequestAmino): QueryProposalRequest;
        fromAminoMsg(object: QueryProposalRequestAminoMsg): QueryProposalRequest;
        fromPartial(object: {
            proposalId?: bigint;
        }): QueryProposalRequest;
        fromProtoMsg(message: QueryProposalRequestProtoMsg): QueryProposalRequest;
        toAmino(message: QueryProposalRequest): QueryProposalRequestAmino;
        toAminoMsg(message: QueryProposalRequest): QueryProposalRequestAminoMsg;
        toProto(message: QueryProposalRequest): Uint8Array;
        toProtoMsg(message: QueryProposalRequest): QueryProposalRequestProtoMsg;
    };
    QueryProposalResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryProposalResponse;
        encode(message: QueryProposalResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryProposalResponseAmino): QueryProposalResponse;
        fromAminoMsg(object: QueryProposalResponseAminoMsg): QueryProposalResponse;
        fromPartial(object: {
            proposal?: {
                content?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                } | {
                    $typeUrl?: "/cosmos.gov.v1beta1.TextProposal";
                    description?: string;
                    isExpedited?: boolean;
                    title?: string;
                };
                depositEndTime?: Date;
                finalTallyResult?: {
                    abstain?: string;
                    no?: string;
                    noWithVeto?: string;
                    yes?: string;
                };
                isExpedited?: boolean;
                proposalId?: bigint;
                status?: ProposalStatus;
                submitTime?: Date;
                totalDeposit?: {
                    amount?: string;
                    denom?: string;
                }[];
                votingEndTime?: Date;
                votingStartTime?: Date;
            };
        }): QueryProposalResponse;
        fromProtoMsg(message: QueryProposalResponseProtoMsg): QueryProposalResponse;
        toAmino(message: QueryProposalResponse): QueryProposalResponseAmino;
        toAminoMsg(message: QueryProposalResponse): QueryProposalResponseAminoMsg;
        toProto(message: QueryProposalResponse): Uint8Array;
        toProtoMsg(message: QueryProposalResponse): QueryProposalResponseProtoMsg;
    };
    QueryProposalsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryProposalsRequest;
        encode(message: QueryProposalsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryProposalsRequestAmino): QueryProposalsRequest;
        fromAminoMsg(object: QueryProposalsRequestAminoMsg): QueryProposalsRequest;
        fromPartial(object: {
            depositor?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            proposalStatus?: ProposalStatus;
            voter?: string;
        }): QueryProposalsRequest;
        fromProtoMsg(message: QueryProposalsRequestProtoMsg): QueryProposalsRequest;
        toAmino(message: QueryProposalsRequest): QueryProposalsRequestAmino;
        toAminoMsg(message: QueryProposalsRequest): QueryProposalsRequestAminoMsg;
        toProto(message: QueryProposalsRequest): Uint8Array;
        toProtoMsg(message: QueryProposalsRequest): QueryProposalsRequestProtoMsg;
    };
    QueryProposalsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryProposalsResponse;
        encode(message: QueryProposalsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryProposalsResponseAmino): QueryProposalsResponse;
        fromAminoMsg(object: QueryProposalsResponseAminoMsg): QueryProposalsResponse;
        fromPartial(object: {
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
            proposals?: {
                content?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                } | {
                    $typeUrl?: "/cosmos.gov.v1beta1.TextProposal";
                    description?: string;
                    isExpedited?: boolean;
                    title?: string;
                };
                depositEndTime?: Date;
                finalTallyResult?: {
                    abstain?: string;
                    no?: string;
                    noWithVeto?: string;
                    yes?: string;
                };
                isExpedited?: boolean;
                proposalId?: bigint;
                status?: ProposalStatus;
                submitTime?: Date;
                totalDeposit?: {
                    amount?: string;
                    denom?: string;
                }[];
                votingEndTime?: Date;
                votingStartTime?: Date;
            }[];
        }): QueryProposalsResponse;
        fromProtoMsg(message: QueryProposalsResponseProtoMsg): QueryProposalsResponse;
        toAmino(message: QueryProposalsResponse): QueryProposalsResponseAmino;
        toAminoMsg(message: QueryProposalsResponse): QueryProposalsResponseAminoMsg;
        toProto(message: QueryProposalsResponse): Uint8Array;
        toProtoMsg(message: QueryProposalsResponse): QueryProposalsResponseProtoMsg;
    };
    QueryTallyResultRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryTallyResultRequest;
        encode(message: QueryTallyResultRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryTallyResultRequestAmino): QueryTallyResultRequest;
        fromAminoMsg(object: QueryTallyResultRequestAminoMsg): QueryTallyResultRequest;
        fromPartial(object: {
            proposalId?: bigint;
        }): QueryTallyResultRequest;
        fromProtoMsg(message: QueryTallyResultRequestProtoMsg): QueryTallyResultRequest;
        toAmino(message: QueryTallyResultRequest): QueryTallyResultRequestAmino;
        toAminoMsg(message: QueryTallyResultRequest): QueryTallyResultRequestAminoMsg;
        toProto(message: QueryTallyResultRequest): Uint8Array;
        toProtoMsg(message: QueryTallyResultRequest): QueryTallyResultRequestProtoMsg;
    };
    QueryTallyResultResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryTallyResultResponse;
        encode(message: QueryTallyResultResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryTallyResultResponseAmino): QueryTallyResultResponse;
        fromAminoMsg(object: QueryTallyResultResponseAminoMsg): QueryTallyResultResponse;
        fromPartial(object: {
            tally?: {
                abstain?: string;
                no?: string;
                noWithVeto?: string;
                yes?: string;
            };
        }): QueryTallyResultResponse;
        fromProtoMsg(message: QueryTallyResultResponseProtoMsg): QueryTallyResultResponse;
        toAmino(message: QueryTallyResultResponse): QueryTallyResultResponseAmino;
        toAminoMsg(message: QueryTallyResultResponse): QueryTallyResultResponseAminoMsg;
        toProto(message: QueryTallyResultResponse): Uint8Array;
        toProtoMsg(message: QueryTallyResultResponse): QueryTallyResultResponseProtoMsg;
    };
    QueryVoteRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryVoteRequest;
        encode(message: QueryVoteRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryVoteRequestAmino): QueryVoteRequest;
        fromAminoMsg(object: QueryVoteRequestAminoMsg): QueryVoteRequest;
        fromPartial(object: {
            proposalId?: bigint;
            voter?: string;
        }): QueryVoteRequest;
        fromProtoMsg(message: QueryVoteRequestProtoMsg): QueryVoteRequest;
        toAmino(message: QueryVoteRequest): QueryVoteRequestAmino;
        toAminoMsg(message: QueryVoteRequest): QueryVoteRequestAminoMsg;
        toProto(message: QueryVoteRequest): Uint8Array;
        toProtoMsg(message: QueryVoteRequest): QueryVoteRequestProtoMsg;
    };
    QueryVoteResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryVoteResponse;
        encode(message: QueryVoteResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryVoteResponseAmino): QueryVoteResponse;
        fromAminoMsg(object: QueryVoteResponseAminoMsg): QueryVoteResponse;
        fromPartial(object: {
            vote?: {
                option?: VoteOption;
                options?: {
                    option?: VoteOption;
                    weight?: string;
                }[];
                proposalId?: bigint;
                voter?: string;
            };
        }): QueryVoteResponse;
        fromProtoMsg(message: QueryVoteResponseProtoMsg): QueryVoteResponse;
        toAmino(message: QueryVoteResponse): QueryVoteResponseAmino;
        toAminoMsg(message: QueryVoteResponse): QueryVoteResponseAminoMsg;
        toProto(message: QueryVoteResponse): Uint8Array;
        toProtoMsg(message: QueryVoteResponse): QueryVoteResponseProtoMsg;
    };
    QueryVotesRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryVotesRequest;
        encode(message: QueryVotesRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryVotesRequestAmino): QueryVotesRequest;
        fromAminoMsg(object: QueryVotesRequestAminoMsg): QueryVotesRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            proposalId?: bigint;
        }): QueryVotesRequest;
        fromProtoMsg(message: QueryVotesRequestProtoMsg): QueryVotesRequest;
        toAmino(message: QueryVotesRequest): QueryVotesRequestAmino;
        toAminoMsg(message: QueryVotesRequest): QueryVotesRequestAminoMsg;
        toProto(message: QueryVotesRequest): Uint8Array;
        toProtoMsg(message: QueryVotesRequest): QueryVotesRequestProtoMsg;
    };
    QueryVotesResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryVotesResponse;
        encode(message: QueryVotesResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryVotesResponseAmino): QueryVotesResponse;
        fromAminoMsg(object: QueryVotesResponseAminoMsg): QueryVotesResponse;
        fromPartial(object: {
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
            votes?: {
                option?: VoteOption;
                options?: {
                    option?: VoteOption;
                    weight?: string;
                }[];
                proposalId?: bigint;
                voter?: string;
            }[];
        }): QueryVotesResponse;
        fromProtoMsg(message: QueryVotesResponseProtoMsg): QueryVotesResponse;
        toAmino(message: QueryVotesResponse): QueryVotesResponseAmino;
        toAminoMsg(message: QueryVotesResponse): QueryVotesResponseAminoMsg;
        toProto(message: QueryVotesResponse): Uint8Array;
        toProtoMsg(message: QueryVotesResponse): QueryVotesResponseProtoMsg;
    };
    TallyParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): TallyParams;
        encode(message: TallyParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: TallyParamsAmino): TallyParams;
        fromAminoMsg(object: TallyParamsAminoMsg): TallyParams;
        fromPartial(object: {
            expeditedQuorum?: Uint8Array;
            expeditedThreshold?: Uint8Array;
            quorum?: Uint8Array;
            threshold?: Uint8Array;
            vetoThreshold?: Uint8Array;
        }): TallyParams;
        fromProtoMsg(message: TallyParamsProtoMsg): TallyParams;
        toAmino(message: TallyParams): TallyParamsAmino;
        toAminoMsg(message: TallyParams): TallyParamsAminoMsg;
        toProto(message: TallyParams): Uint8Array;
        toProtoMsg(message: TallyParams): TallyParamsProtoMsg;
    };
    TallyResult: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): TallyResult;
        encode(message: TallyResult, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: TallyResultAmino): TallyResult;
        fromAminoMsg(object: TallyResultAminoMsg): TallyResult;
        fromPartial(object: {
            abstain?: string;
            no?: string;
            noWithVeto?: string;
            yes?: string;
        }): TallyResult;
        fromProtoMsg(message: TallyResultProtoMsg): TallyResult;
        toAmino(message: TallyResult): TallyResultAmino;
        toAminoMsg(message: TallyResult): TallyResultAminoMsg;
        toProto(message: TallyResult): Uint8Array;
        toProtoMsg(message: TallyResult): TallyResultProtoMsg;
    };
    TextProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): TextProposal;
        encode(message: TextProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: TextProposalAmino): TextProposal;
        fromAminoMsg(object: TextProposalAminoMsg): TextProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmos.gov.v1beta1.TextProposal";
            description?: string;
            isExpedited?: boolean;
            title?: string;
        }): TextProposal;
        fromProtoMsg(message: TextProposalProtoMsg): TextProposal;
        toAmino(message: TextProposal): TextProposalAmino;
        toAminoMsg(message: TextProposal): TextProposalAminoMsg;
        toProto(message: TextProposal): Uint8Array;
        toProtoMsg(message: TextProposal): TextProposalProtoMsg;
    };
    Vote: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Vote;
        encode(message: Vote, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: VoteAmino): Vote;
        fromAminoMsg(object: VoteAminoMsg): Vote;
        fromPartial(object: {
            option?: VoteOption;
            options?: {
                option?: VoteOption;
                weight?: string;
            }[];
            proposalId?: bigint;
            voter?: string;
        }): Vote;
        fromProtoMsg(message: VoteProtoMsg): Vote;
        toAmino(message: Vote): VoteAmino;
        toAminoMsg(message: Vote): VoteAminoMsg;
        toProto(message: Vote): Uint8Array;
        toProtoMsg(message: Vote): VoteProtoMsg;
    };
    VoteOptionAmino: typeof VoteOption;
    VoteOptionSDKType: typeof VoteOption;
    VotingParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): VotingParams;
        encode(message: VotingParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: VotingParamsAmino): VotingParams;
        fromAminoMsg(object: VotingParamsAminoMsg): VotingParams;
        fromPartial(object: {
            expeditedVotingPeriod?: {
                nanos?: number;
                seconds?: bigint;
            };
            votingPeriod?: {
                nanos?: number;
                seconds?: bigint;
            };
        }): VotingParams;
        fromProtoMsg(message: VotingParamsProtoMsg): VotingParams;
        toAmino(message: VotingParams): VotingParamsAmino;
        toAminoMsg(message: VotingParams): VotingParamsAminoMsg;
        toProto(message: VotingParams): Uint8Array;
        toProtoMsg(message: VotingParams): VotingParamsProtoMsg;
    };
    WeightedVoteOption: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): WeightedVoteOption;
        encode(message: WeightedVoteOption, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: WeightedVoteOptionAmino): WeightedVoteOption;
        fromAminoMsg(object: WeightedVoteOptionAminoMsg): WeightedVoteOption;
        fromPartial(object: {
            option?: VoteOption;
            weight?: string;
        }): WeightedVoteOption;
        fromProtoMsg(message: WeightedVoteOptionProtoMsg): WeightedVoteOption;
        toAmino(message: WeightedVoteOption): WeightedVoteOptionAmino;
        toAminoMsg(message: WeightedVoteOption): WeightedVoteOptionAminoMsg;
        toProto(message: WeightedVoteOption): Uint8Array;
        toProtoMsg(message: WeightedVoteOption): WeightedVoteOptionProtoMsg;
    };
    createRpcQueryExtension: ((base: QueryClient) => {
        deposit(request: QueryDepositRequest): Promise<QueryDepositResponse>;
        deposits(request: QueryDepositsRequest): Promise<QueryDepositsResponse>;
        params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
        proposal(request: QueryProposalRequest): Promise<QueryProposalResponse>;
        proposals(request: QueryProposalsRequest): Promise<QueryProposalsResponse>;
        tallyResult(request: QueryTallyResultRequest): Promise<QueryTallyResultResponse>;
        vote(request: QueryVoteRequest): Promise<QueryVoteResponse>;
        votes(request: QueryVotesRequest): Promise<QueryVotesResponse>;
    });
    load: ((protoRegistry: Registry) => void);
    registry: readonly [string, TelescopeGeneratedType<any, any, any>][];
    proposalStatusFromJSON(object: any): ProposalStatus;
    proposalStatusToJSON(object: ProposalStatus): string;
    voteOptionFromJSON(object: any): VoteOption;
    voteOptionToJSON(object: VoteOption): string;
} = ...

Type declaration

Settings

Member Visibility