Variable v1Const

v1: {
    LCDQueryClient: any;
    MsgClientImpl: any;
    QueryClientImpl: any;
    AminoConverter: {
        /ibc.core.client.v1.MsgCreateClient: {
            aminoType: string;
            fromAmino: ((object: MsgCreateClientAmino) => MsgCreateClient);
            toAmino: ((message: MsgCreateClient) => MsgCreateClientAmino);
        };
        /ibc.core.client.v1.MsgSubmitMisbehaviour: {
            aminoType: string;
            fromAmino: ((object: MsgSubmitMisbehaviourAmino) => MsgSubmitMisbehaviour);
            toAmino: ((message: MsgSubmitMisbehaviour) => MsgSubmitMisbehaviourAmino);
        };
        /ibc.core.client.v1.MsgUpdateClient: {
            aminoType: string;
            fromAmino: ((object: MsgUpdateClientAmino) => MsgUpdateClient);
            toAmino: ((message: MsgUpdateClient) => MsgUpdateClientAmino);
        };
        /ibc.core.client.v1.MsgUpgradeClient: {
            aminoType: string;
            fromAmino: ((object: MsgUpgradeClientAmino) => MsgUpgradeClient);
            toAmino: ((message: MsgUpgradeClient) => MsgUpgradeClientAmino);
        };
    };
    ClientConsensusStates: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ClientConsensusStates;
        encode(message: ClientConsensusStates, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ClientConsensusStatesAmino): ClientConsensusStates;
        fromAminoMsg(object: ClientConsensusStatesAminoMsg): ClientConsensusStates;
        fromPartial(object: {
            clientId?: string;
            consensusStates?: {
                consensusState?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                height?: {
                    revisionHeight?: bigint;
                    revisionNumber?: bigint;
                };
            }[];
        }): ClientConsensusStates;
        fromProtoMsg(message: ClientConsensusStatesProtoMsg): ClientConsensusStates;
        toAmino(message: ClientConsensusStates): ClientConsensusStatesAmino;
        toAminoMsg(message: ClientConsensusStates): ClientConsensusStatesAminoMsg;
        toProto(message: ClientConsensusStates): Uint8Array;
        toProtoMsg(message: ClientConsensusStates): ClientConsensusStatesProtoMsg;
    };
    ClientUpdateProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ClientUpdateProposal;
        encode(message: ClientUpdateProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ClientUpdateProposalAmino): ClientUpdateProposal;
        fromAminoMsg(object: ClientUpdateProposalAminoMsg): ClientUpdateProposal;
        fromPartial(object: {
            $typeUrl?: "/ibc.core.client.v1.ClientUpdateProposal";
            description?: string;
            subjectClientId?: string;
            substituteClientId?: string;
            title?: string;
        }): ClientUpdateProposal;
        fromProtoMsg(message: ClientUpdateProposalProtoMsg): ClientUpdateProposal;
        toAmino(message: ClientUpdateProposal): ClientUpdateProposalAmino;
        toAminoMsg(message: ClientUpdateProposal): ClientUpdateProposalAminoMsg;
        toProto(message: ClientUpdateProposal): Uint8Array;
        toProtoMsg(message: ClientUpdateProposal): ClientUpdateProposalProtoMsg;
    };
    ConsensusStateWithHeight: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ConsensusStateWithHeight;
        encode(message: ConsensusStateWithHeight, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ConsensusStateWithHeightAmino): ConsensusStateWithHeight;
        fromAminoMsg(object: ConsensusStateWithHeightAminoMsg): ConsensusStateWithHeight;
        fromPartial(object: {
            consensusState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            height?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): ConsensusStateWithHeight;
        fromProtoMsg(message: ConsensusStateWithHeightProtoMsg): ConsensusStateWithHeight;
        toAmino(message: ConsensusStateWithHeight): ConsensusStateWithHeightAmino;
        toAminoMsg(message: ConsensusStateWithHeight): ConsensusStateWithHeightAminoMsg;
        toProto(message: ConsensusStateWithHeight): Uint8Array;
        toProtoMsg(message: ConsensusStateWithHeight): ConsensusStateWithHeightProtoMsg;
    };
    GenesisMetadata: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): GenesisMetadata;
        encode(message: GenesisMetadata, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: GenesisMetadataAmino): GenesisMetadata;
        fromAminoMsg(object: GenesisMetadataAminoMsg): GenesisMetadata;
        fromPartial(object: {
            key?: Uint8Array;
            value?: Uint8Array;
        }): GenesisMetadata;
        fromProtoMsg(message: GenesisMetadataProtoMsg): GenesisMetadata;
        toAmino(message: GenesisMetadata): GenesisMetadataAmino;
        toAminoMsg(message: GenesisMetadata): GenesisMetadataAminoMsg;
        toProto(message: GenesisMetadata): Uint8Array;
        toProtoMsg(message: GenesisMetadata): GenesisMetadataProtoMsg;
    };
    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: {
            clients?: {
                clientId?: string;
                clientState?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
            }[];
            clientsConsensus?: {
                clientId?: string;
                consensusStates?: {
                    consensusState?: {
                        $typeUrl?: ...;
                        typeUrl?: ...;
                        value?: ...;
                    };
                    height?: {
                        revisionHeight?: ...;
                        revisionNumber?: ...;
                    };
                }[];
            }[];
            clientsMetadata?: {
                clientId?: string;
                clientMetadata?: {
                    key?: Uint8Array;
                    value?: Uint8Array;
                }[];
            }[];
            createLocalhost?: boolean;
            nextClientSequence?: bigint;
            params?: {
                allowedClients?: string[];
            };
        }): GenesisState;
        fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
        toAmino(message: GenesisState): GenesisStateAmino;
        toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
        toProto(message: GenesisState): Uint8Array;
        toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
    };
    Height: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Height;
        encode(message: Height, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: HeightAmino): Height;
        fromAminoMsg(object: HeightAminoMsg): Height;
        fromPartial(object: {
            revisionHeight?: bigint;
            revisionNumber?: bigint;
        }): Height;
        fromProtoMsg(message: HeightProtoMsg): Height;
        toAmino(message: Height): HeightAmino;
        toAminoMsg(message: Height): HeightAminoMsg;
        toProto(message: Height): Uint8Array;
        toProtoMsg(message: Height): HeightProtoMsg;
    };
    IdentifiedClientState: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): IdentifiedClientState;
        encode(message: IdentifiedClientState, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: IdentifiedClientStateAmino): IdentifiedClientState;
        fromAminoMsg(object: IdentifiedClientStateAminoMsg): IdentifiedClientState;
        fromPartial(object: {
            clientId?: string;
            clientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
        }): IdentifiedClientState;
        fromProtoMsg(message: IdentifiedClientStateProtoMsg): IdentifiedClientState;
        toAmino(message: IdentifiedClientState): IdentifiedClientStateAmino;
        toAminoMsg(message: IdentifiedClientState): IdentifiedClientStateAminoMsg;
        toProto(message: IdentifiedClientState): Uint8Array;
        toProtoMsg(message: IdentifiedClientState): IdentifiedClientStateProtoMsg;
    };
    IdentifiedGenesisMetadata: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): IdentifiedGenesisMetadata;
        encode(message: IdentifiedGenesisMetadata, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: IdentifiedGenesisMetadataAmino): IdentifiedGenesisMetadata;
        fromAminoMsg(object: IdentifiedGenesisMetadataAminoMsg): IdentifiedGenesisMetadata;
        fromPartial(object: {
            clientId?: string;
            clientMetadata?: {
                key?: Uint8Array;
                value?: Uint8Array;
            }[];
        }): IdentifiedGenesisMetadata;
        fromProtoMsg(message: IdentifiedGenesisMetadataProtoMsg): IdentifiedGenesisMetadata;
        toAmino(message: IdentifiedGenesisMetadata): IdentifiedGenesisMetadataAmino;
        toAminoMsg(message: IdentifiedGenesisMetadata): IdentifiedGenesisMetadataAminoMsg;
        toProto(message: IdentifiedGenesisMetadata): Uint8Array;
        toProtoMsg(message: IdentifiedGenesisMetadata): IdentifiedGenesisMetadataProtoMsg;
    };
    MessageComposer: {
        encoded: {
            createClient(value: MsgCreateClient): {
                typeUrl: string;
                value: Uint8Array;
            };
            submitMisbehaviour(value: MsgSubmitMisbehaviour): {
                typeUrl: string;
                value: Uint8Array;
            };
            updateClient(value: MsgUpdateClient): {
                typeUrl: string;
                value: Uint8Array;
            };
            upgradeClient(value: MsgUpgradeClient): {
                typeUrl: string;
                value: Uint8Array;
            };
        };
        fromPartial: {
            createClient(value: MsgCreateClient): {
                typeUrl: string;
                value: MsgCreateClient;
            };
            submitMisbehaviour(value: MsgSubmitMisbehaviour): {
                typeUrl: string;
                value: MsgSubmitMisbehaviour;
            };
            updateClient(value: MsgUpdateClient): {
                typeUrl: string;
                value: MsgUpdateClient;
            };
            upgradeClient(value: MsgUpgradeClient): {
                typeUrl: string;
                value: MsgUpgradeClient;
            };
        };
        withTypeUrl: {
            createClient(value: MsgCreateClient): {
                typeUrl: string;
                value: MsgCreateClient;
            };
            submitMisbehaviour(value: MsgSubmitMisbehaviour): {
                typeUrl: string;
                value: MsgSubmitMisbehaviour;
            };
            updateClient(value: MsgUpdateClient): {
                typeUrl: string;
                value: MsgUpdateClient;
            };
            upgradeClient(value: MsgUpgradeClient): {
                typeUrl: string;
                value: MsgUpgradeClient;
            };
        };
    };
    MsgCreateClient: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgCreateClient;
        encode(message: MsgCreateClient, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgCreateClientAmino): MsgCreateClient;
        fromAminoMsg(object: MsgCreateClientAminoMsg): MsgCreateClient;
        fromPartial(object: {
            clientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            consensusState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            signer?: string;
        }): MsgCreateClient;
        fromProtoMsg(message: MsgCreateClientProtoMsg): MsgCreateClient;
        toAmino(message: MsgCreateClient): MsgCreateClientAmino;
        toAminoMsg(message: MsgCreateClient): MsgCreateClientAminoMsg;
        toProto(message: MsgCreateClient): Uint8Array;
        toProtoMsg(message: MsgCreateClient): MsgCreateClientProtoMsg;
    };
    MsgCreateClientResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgCreateClientResponse;
        encode(_: MsgCreateClientResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgCreateClientResponseAmino): MsgCreateClientResponse;
        fromAminoMsg(object: MsgCreateClientResponseAminoMsg): MsgCreateClientResponse;
        fromPartial(_: {}): MsgCreateClientResponse;
        fromProtoMsg(message: MsgCreateClientResponseProtoMsg): MsgCreateClientResponse;
        toAmino(_: MsgCreateClientResponse): MsgCreateClientResponseAmino;
        toAminoMsg(message: MsgCreateClientResponse): MsgCreateClientResponseAminoMsg;
        toProto(message: MsgCreateClientResponse): Uint8Array;
        toProtoMsg(message: MsgCreateClientResponse): MsgCreateClientResponseProtoMsg;
    };
    MsgSubmitMisbehaviour: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgSubmitMisbehaviour;
        encode(message: MsgSubmitMisbehaviour, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgSubmitMisbehaviourAmino): MsgSubmitMisbehaviour;
        fromAminoMsg(object: MsgSubmitMisbehaviourAminoMsg): MsgSubmitMisbehaviour;
        fromPartial(object: {
            clientId?: string;
            misbehaviour?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            signer?: string;
        }): MsgSubmitMisbehaviour;
        fromProtoMsg(message: MsgSubmitMisbehaviourProtoMsg): MsgSubmitMisbehaviour;
        toAmino(message: MsgSubmitMisbehaviour): MsgSubmitMisbehaviourAmino;
        toAminoMsg(message: MsgSubmitMisbehaviour): MsgSubmitMisbehaviourAminoMsg;
        toProto(message: MsgSubmitMisbehaviour): Uint8Array;
        toProtoMsg(message: MsgSubmitMisbehaviour): MsgSubmitMisbehaviourProtoMsg;
    };
    MsgSubmitMisbehaviourResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgSubmitMisbehaviourResponse;
        encode(_: MsgSubmitMisbehaviourResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgSubmitMisbehaviourResponseAmino): MsgSubmitMisbehaviourResponse;
        fromAminoMsg(object: MsgSubmitMisbehaviourResponseAminoMsg): MsgSubmitMisbehaviourResponse;
        fromPartial(_: {}): MsgSubmitMisbehaviourResponse;
        fromProtoMsg(message: MsgSubmitMisbehaviourResponseProtoMsg): MsgSubmitMisbehaviourResponse;
        toAmino(_: MsgSubmitMisbehaviourResponse): MsgSubmitMisbehaviourResponseAmino;
        toAminoMsg(message: MsgSubmitMisbehaviourResponse): MsgSubmitMisbehaviourResponseAminoMsg;
        toProto(message: MsgSubmitMisbehaviourResponse): Uint8Array;
        toProtoMsg(message: MsgSubmitMisbehaviourResponse): MsgSubmitMisbehaviourResponseProtoMsg;
    };
    MsgUpdateClient: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpdateClient;
        encode(message: MsgUpdateClient, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUpdateClientAmino): MsgUpdateClient;
        fromAminoMsg(object: MsgUpdateClientAminoMsg): MsgUpdateClient;
        fromPartial(object: {
            clientId?: string;
            header?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            signer?: string;
        }): MsgUpdateClient;
        fromProtoMsg(message: MsgUpdateClientProtoMsg): MsgUpdateClient;
        toAmino(message: MsgUpdateClient): MsgUpdateClientAmino;
        toAminoMsg(message: MsgUpdateClient): MsgUpdateClientAminoMsg;
        toProto(message: MsgUpdateClient): Uint8Array;
        toProtoMsg(message: MsgUpdateClient): MsgUpdateClientProtoMsg;
    };
    MsgUpdateClientResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpdateClientResponse;
        encode(_: MsgUpdateClientResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgUpdateClientResponseAmino): MsgUpdateClientResponse;
        fromAminoMsg(object: MsgUpdateClientResponseAminoMsg): MsgUpdateClientResponse;
        fromPartial(_: {}): MsgUpdateClientResponse;
        fromProtoMsg(message: MsgUpdateClientResponseProtoMsg): MsgUpdateClientResponse;
        toAmino(_: MsgUpdateClientResponse): MsgUpdateClientResponseAmino;
        toAminoMsg(message: MsgUpdateClientResponse): MsgUpdateClientResponseAminoMsg;
        toProto(message: MsgUpdateClientResponse): Uint8Array;
        toProtoMsg(message: MsgUpdateClientResponse): MsgUpdateClientResponseProtoMsg;
    };
    MsgUpgradeClient: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpgradeClient;
        encode(message: MsgUpgradeClient, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUpgradeClientAmino): MsgUpgradeClient;
        fromAminoMsg(object: MsgUpgradeClientAminoMsg): MsgUpgradeClient;
        fromPartial(object: {
            clientId?: string;
            clientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            consensusState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            proofUpgradeClient?: Uint8Array;
            proofUpgradeConsensusState?: Uint8Array;
            signer?: string;
        }): MsgUpgradeClient;
        fromProtoMsg(message: MsgUpgradeClientProtoMsg): MsgUpgradeClient;
        toAmino(message: MsgUpgradeClient): MsgUpgradeClientAmino;
        toAminoMsg(message: MsgUpgradeClient): MsgUpgradeClientAminoMsg;
        toProto(message: MsgUpgradeClient): Uint8Array;
        toProtoMsg(message: MsgUpgradeClient): MsgUpgradeClientProtoMsg;
    };
    MsgUpgradeClientResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpgradeClientResponse;
        encode(_: MsgUpgradeClientResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgUpgradeClientResponseAmino): MsgUpgradeClientResponse;
        fromAminoMsg(object: MsgUpgradeClientResponseAminoMsg): MsgUpgradeClientResponse;
        fromPartial(_: {}): MsgUpgradeClientResponse;
        fromProtoMsg(message: MsgUpgradeClientResponseProtoMsg): MsgUpgradeClientResponse;
        toAmino(_: MsgUpgradeClientResponse): MsgUpgradeClientResponseAmino;
        toAminoMsg(message: MsgUpgradeClientResponse): MsgUpgradeClientResponseAminoMsg;
        toProto(message: MsgUpgradeClientResponse): Uint8Array;
        toProtoMsg(message: MsgUpgradeClientResponse): MsgUpgradeClientResponseProtoMsg;
    };
    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: {
            allowedClients?: string[];
        }): Params;
        fromProtoMsg(message: ParamsProtoMsg): Params;
        toAmino(message: Params): ParamsAmino;
        toAminoMsg(message: Params): ParamsAminoMsg;
        toProto(message: Params): Uint8Array;
        toProtoMsg(message: Params): ParamsProtoMsg;
    };
    QueryClientParamsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientParamsRequest;
        encode(_: QueryClientParamsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: QueryClientParamsRequestAmino): QueryClientParamsRequest;
        fromAminoMsg(object: QueryClientParamsRequestAminoMsg): QueryClientParamsRequest;
        fromPartial(_: {}): QueryClientParamsRequest;
        fromProtoMsg(message: QueryClientParamsRequestProtoMsg): QueryClientParamsRequest;
        toAmino(_: QueryClientParamsRequest): QueryClientParamsRequestAmino;
        toAminoMsg(message: QueryClientParamsRequest): QueryClientParamsRequestAminoMsg;
        toProto(message: QueryClientParamsRequest): Uint8Array;
        toProtoMsg(message: QueryClientParamsRequest): QueryClientParamsRequestProtoMsg;
    };
    QueryClientParamsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientParamsResponse;
        encode(message: QueryClientParamsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientParamsResponseAmino): QueryClientParamsResponse;
        fromAminoMsg(object: QueryClientParamsResponseAminoMsg): QueryClientParamsResponse;
        fromPartial(object: {
            params?: {
                allowedClients?: string[];
            };
        }): QueryClientParamsResponse;
        fromProtoMsg(message: QueryClientParamsResponseProtoMsg): QueryClientParamsResponse;
        toAmino(message: QueryClientParamsResponse): QueryClientParamsResponseAmino;
        toAminoMsg(message: QueryClientParamsResponse): QueryClientParamsResponseAminoMsg;
        toProto(message: QueryClientParamsResponse): Uint8Array;
        toProtoMsg(message: QueryClientParamsResponse): QueryClientParamsResponseProtoMsg;
    };
    QueryClientStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientStateRequest;
        encode(message: QueryClientStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientStateRequestAmino): QueryClientStateRequest;
        fromAminoMsg(object: QueryClientStateRequestAminoMsg): QueryClientStateRequest;
        fromPartial(object: {
            clientId?: string;
        }): QueryClientStateRequest;
        fromProtoMsg(message: QueryClientStateRequestProtoMsg): QueryClientStateRequest;
        toAmino(message: QueryClientStateRequest): QueryClientStateRequestAmino;
        toAminoMsg(message: QueryClientStateRequest): QueryClientStateRequestAminoMsg;
        toProto(message: QueryClientStateRequest): Uint8Array;
        toProtoMsg(message: QueryClientStateRequest): QueryClientStateRequestProtoMsg;
    };
    QueryClientStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientStateResponse;
        encode(message: QueryClientStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientStateResponseAmino): QueryClientStateResponse;
        fromAminoMsg(object: QueryClientStateResponseAminoMsg): QueryClientStateResponse;
        fromPartial(object: {
            clientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryClientStateResponse;
        fromProtoMsg(message: QueryClientStateResponseProtoMsg): QueryClientStateResponse;
        toAmino(message: QueryClientStateResponse): QueryClientStateResponseAmino;
        toAminoMsg(message: QueryClientStateResponse): QueryClientStateResponseAminoMsg;
        toProto(message: QueryClientStateResponse): Uint8Array;
        toProtoMsg(message: QueryClientStateResponse): QueryClientStateResponseProtoMsg;
    };
    QueryClientStatesRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientStatesRequest;
        encode(message: QueryClientStatesRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientStatesRequestAmino): QueryClientStatesRequest;
        fromAminoMsg(object: QueryClientStatesRequestAminoMsg): QueryClientStatesRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryClientStatesRequest;
        fromProtoMsg(message: QueryClientStatesRequestProtoMsg): QueryClientStatesRequest;
        toAmino(message: QueryClientStatesRequest): QueryClientStatesRequestAmino;
        toAminoMsg(message: QueryClientStatesRequest): QueryClientStatesRequestAminoMsg;
        toProto(message: QueryClientStatesRequest): Uint8Array;
        toProtoMsg(message: QueryClientStatesRequest): QueryClientStatesRequestProtoMsg;
    };
    QueryClientStatesResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientStatesResponse;
        encode(message: QueryClientStatesResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientStatesResponseAmino): QueryClientStatesResponse;
        fromAminoMsg(object: QueryClientStatesResponseAminoMsg): QueryClientStatesResponse;
        fromPartial(object: {
            clientStates?: {
                clientId?: string;
                clientState?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryClientStatesResponse;
        fromProtoMsg(message: QueryClientStatesResponseProtoMsg): QueryClientStatesResponse;
        toAmino(message: QueryClientStatesResponse): QueryClientStatesResponseAmino;
        toAminoMsg(message: QueryClientStatesResponse): QueryClientStatesResponseAminoMsg;
        toProto(message: QueryClientStatesResponse): Uint8Array;
        toProtoMsg(message: QueryClientStatesResponse): QueryClientStatesResponseProtoMsg;
    };
    QueryClientStatusRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientStatusRequest;
        encode(message: QueryClientStatusRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientStatusRequestAmino): QueryClientStatusRequest;
        fromAminoMsg(object: QueryClientStatusRequestAminoMsg): QueryClientStatusRequest;
        fromPartial(object: {
            clientId?: string;
        }): QueryClientStatusRequest;
        fromProtoMsg(message: QueryClientStatusRequestProtoMsg): QueryClientStatusRequest;
        toAmino(message: QueryClientStatusRequest): QueryClientStatusRequestAmino;
        toAminoMsg(message: QueryClientStatusRequest): QueryClientStatusRequestAminoMsg;
        toProto(message: QueryClientStatusRequest): Uint8Array;
        toProtoMsg(message: QueryClientStatusRequest): QueryClientStatusRequestProtoMsg;
    };
    QueryClientStatusResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientStatusResponse;
        encode(message: QueryClientStatusResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientStatusResponseAmino): QueryClientStatusResponse;
        fromAminoMsg(object: QueryClientStatusResponseAminoMsg): QueryClientStatusResponse;
        fromPartial(object: {
            status?: string;
        }): QueryClientStatusResponse;
        fromProtoMsg(message: QueryClientStatusResponseProtoMsg): QueryClientStatusResponse;
        toAmino(message: QueryClientStatusResponse): QueryClientStatusResponseAmino;
        toAminoMsg(message: QueryClientStatusResponse): QueryClientStatusResponseAminoMsg;
        toProto(message: QueryClientStatusResponse): Uint8Array;
        toProtoMsg(message: QueryClientStatusResponse): QueryClientStatusResponseProtoMsg;
    };
    QueryConsensusStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConsensusStateRequest;
        encode(message: QueryConsensusStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConsensusStateRequestAmino): QueryConsensusStateRequest;
        fromAminoMsg(object: QueryConsensusStateRequestAminoMsg): QueryConsensusStateRequest;
        fromPartial(object: {
            clientId?: string;
            latestHeight?: boolean;
            revisionHeight?: bigint;
            revisionNumber?: bigint;
        }): QueryConsensusStateRequest;
        fromProtoMsg(message: QueryConsensusStateRequestProtoMsg): QueryConsensusStateRequest;
        toAmino(message: QueryConsensusStateRequest): QueryConsensusStateRequestAmino;
        toAminoMsg(message: QueryConsensusStateRequest): QueryConsensusStateRequestAminoMsg;
        toProto(message: QueryConsensusStateRequest): Uint8Array;
        toProtoMsg(message: QueryConsensusStateRequest): QueryConsensusStateRequestProtoMsg;
    };
    QueryConsensusStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConsensusStateResponse;
        encode(message: QueryConsensusStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConsensusStateResponseAmino): QueryConsensusStateResponse;
        fromAminoMsg(object: QueryConsensusStateResponseAminoMsg): QueryConsensusStateResponse;
        fromPartial(object: {
            consensusState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryConsensusStateResponse;
        fromProtoMsg(message: QueryConsensusStateResponseProtoMsg): QueryConsensusStateResponse;
        toAmino(message: QueryConsensusStateResponse): QueryConsensusStateResponseAmino;
        toAminoMsg(message: QueryConsensusStateResponse): QueryConsensusStateResponseAminoMsg;
        toProto(message: QueryConsensusStateResponse): Uint8Array;
        toProtoMsg(message: QueryConsensusStateResponse): QueryConsensusStateResponseProtoMsg;
    };
    QueryConsensusStatesRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConsensusStatesRequest;
        encode(message: QueryConsensusStatesRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConsensusStatesRequestAmino): QueryConsensusStatesRequest;
        fromAminoMsg(object: QueryConsensusStatesRequestAminoMsg): QueryConsensusStatesRequest;
        fromPartial(object: {
            clientId?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryConsensusStatesRequest;
        fromProtoMsg(message: QueryConsensusStatesRequestProtoMsg): QueryConsensusStatesRequest;
        toAmino(message: QueryConsensusStatesRequest): QueryConsensusStatesRequestAmino;
        toAminoMsg(message: QueryConsensusStatesRequest): QueryConsensusStatesRequestAminoMsg;
        toProto(message: QueryConsensusStatesRequest): Uint8Array;
        toProtoMsg(message: QueryConsensusStatesRequest): QueryConsensusStatesRequestProtoMsg;
    };
    QueryConsensusStatesResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConsensusStatesResponse;
        encode(message: QueryConsensusStatesResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConsensusStatesResponseAmino): QueryConsensusStatesResponse;
        fromAminoMsg(object: QueryConsensusStatesResponseAminoMsg): QueryConsensusStatesResponse;
        fromPartial(object: {
            consensusStates?: {
                consensusState?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                height?: {
                    revisionHeight?: bigint;
                    revisionNumber?: bigint;
                };
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryConsensusStatesResponse;
        fromProtoMsg(message: QueryConsensusStatesResponseProtoMsg): QueryConsensusStatesResponse;
        toAmino(message: QueryConsensusStatesResponse): QueryConsensusStatesResponseAmino;
        toAminoMsg(message: QueryConsensusStatesResponse): QueryConsensusStatesResponseAminoMsg;
        toProto(message: QueryConsensusStatesResponse): Uint8Array;
        toProtoMsg(message: QueryConsensusStatesResponse): QueryConsensusStatesResponseProtoMsg;
    };
    QueryUpgradedClientStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUpgradedClientStateRequest;
        encode(_: QueryUpgradedClientStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: QueryUpgradedClientStateRequestAmino): QueryUpgradedClientStateRequest;
        fromAminoMsg(object: QueryUpgradedClientStateRequestAminoMsg): QueryUpgradedClientStateRequest;
        fromPartial(_: {}): QueryUpgradedClientStateRequest;
        fromProtoMsg(message: QueryUpgradedClientStateRequestProtoMsg): QueryUpgradedClientStateRequest;
        toAmino(_: QueryUpgradedClientStateRequest): QueryUpgradedClientStateRequestAmino;
        toAminoMsg(message: QueryUpgradedClientStateRequest): QueryUpgradedClientStateRequestAminoMsg;
        toProto(message: QueryUpgradedClientStateRequest): Uint8Array;
        toProtoMsg(message: QueryUpgradedClientStateRequest): QueryUpgradedClientStateRequestProtoMsg;
    };
    QueryUpgradedClientStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUpgradedClientStateResponse;
        encode(message: QueryUpgradedClientStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryUpgradedClientStateResponseAmino): QueryUpgradedClientStateResponse;
        fromAminoMsg(object: QueryUpgradedClientStateResponseAminoMsg): QueryUpgradedClientStateResponse;
        fromPartial(object: {
            upgradedClientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
        }): QueryUpgradedClientStateResponse;
        fromProtoMsg(message: QueryUpgradedClientStateResponseProtoMsg): QueryUpgradedClientStateResponse;
        toAmino(message: QueryUpgradedClientStateResponse): QueryUpgradedClientStateResponseAmino;
        toAminoMsg(message: QueryUpgradedClientStateResponse): QueryUpgradedClientStateResponseAminoMsg;
        toProto(message: QueryUpgradedClientStateResponse): Uint8Array;
        toProtoMsg(message: QueryUpgradedClientStateResponse): QueryUpgradedClientStateResponseProtoMsg;
    };
    QueryUpgradedConsensusStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUpgradedConsensusStateRequest;
        encode(_: QueryUpgradedConsensusStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: QueryUpgradedConsensusStateRequestAmino): QueryUpgradedConsensusStateRequest;
        fromAminoMsg(object: QueryUpgradedConsensusStateRequestAminoMsg): QueryUpgradedConsensusStateRequest;
        fromPartial(_: {}): QueryUpgradedConsensusStateRequest;
        fromProtoMsg(message: QueryUpgradedConsensusStateRequestProtoMsg): QueryUpgradedConsensusStateRequest;
        toAmino(_: QueryUpgradedConsensusStateRequest): QueryUpgradedConsensusStateRequestAmino;
        toAminoMsg(message: QueryUpgradedConsensusStateRequest): QueryUpgradedConsensusStateRequestAminoMsg;
        toProto(message: QueryUpgradedConsensusStateRequest): Uint8Array;
        toProtoMsg(message: QueryUpgradedConsensusStateRequest): QueryUpgradedConsensusStateRequestProtoMsg;
    };
    QueryUpgradedConsensusStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUpgradedConsensusStateResponse;
        encode(message: QueryUpgradedConsensusStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryUpgradedConsensusStateResponseAmino): QueryUpgradedConsensusStateResponse;
        fromAminoMsg(object: QueryUpgradedConsensusStateResponseAminoMsg): QueryUpgradedConsensusStateResponse;
        fromPartial(object: {
            upgradedConsensusState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
        }): QueryUpgradedConsensusStateResponse;
        fromProtoMsg(message: QueryUpgradedConsensusStateResponseProtoMsg): QueryUpgradedConsensusStateResponse;
        toAmino(message: QueryUpgradedConsensusStateResponse): QueryUpgradedConsensusStateResponseAmino;
        toAminoMsg(message: QueryUpgradedConsensusStateResponse): QueryUpgradedConsensusStateResponseAminoMsg;
        toProto(message: QueryUpgradedConsensusStateResponse): Uint8Array;
        toProtoMsg(message: QueryUpgradedConsensusStateResponse): QueryUpgradedConsensusStateResponseProtoMsg;
    };
    UpgradeProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): UpgradeProposal;
        encode(message: UpgradeProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: UpgradeProposalAmino): UpgradeProposal;
        fromAminoMsg(object: UpgradeProposalAminoMsg): UpgradeProposal;
        fromPartial(object: {
            $typeUrl?: "/ibc.core.client.v1.UpgradeProposal";
            description?: string;
            plan?: {
                height?: bigint;
                info?: string;
                name?: string;
                time?: Date;
                upgradedClientState?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
            };
            title?: string;
            upgradedClientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
        }): UpgradeProposal;
        fromProtoMsg(message: UpgradeProposalProtoMsg): UpgradeProposal;
        toAmino(message: UpgradeProposal): UpgradeProposalAmino;
        toAminoMsg(message: UpgradeProposal): UpgradeProposalAminoMsg;
        toProto(message: UpgradeProposal): Uint8Array;
        toProtoMsg(message: UpgradeProposal): UpgradeProposalProtoMsg;
    };
    createRpcQueryExtension: ((base: QueryClient) => {
        clientParams(request?: QueryClientParamsRequest): Promise<QueryClientParamsResponse>;
        clientState(request: QueryClientStateRequest): Promise<QueryClientStateResponse>;
        clientStates(request?: QueryClientStatesRequest): Promise<QueryClientStatesResponse>;
        clientStatus(request: QueryClientStatusRequest): Promise<QueryClientStatusResponse>;
        consensusState(request: QueryConsensusStateRequest): Promise<QueryConsensusStateResponse>;
        consensusStates(request: QueryConsensusStatesRequest): Promise<QueryConsensusStatesResponse>;
        upgradedClientState(request?: QueryUpgradedClientStateRequest): Promise<QueryUpgradedClientStateResponse>;
        upgradedConsensusState(request?: QueryUpgradedConsensusStateRequest): Promise<QueryUpgradedConsensusStateResponse>;
    });
    load: ((protoRegistry: Registry) => void);
    registry: readonly [string, TelescopeGeneratedType<any, any, any>][];
} = ...

Type declaration

Settings

Member Visibility