Variable v1Const

v1: {
    State: any;
    LCDQueryClient: any;
    MsgClientImpl: any;
    QueryClientImpl: any;
    AminoConverter: {
        /ibc.core.connection.v1.MsgConnectionOpenAck: {
            aminoType: string;
            fromAmino: ((object: MsgConnectionOpenAckAmino) => MsgConnectionOpenAck);
            toAmino: ((message: MsgConnectionOpenAck) => MsgConnectionOpenAckAmino);
        };
        /ibc.core.connection.v1.MsgConnectionOpenConfirm: {
            aminoType: string;
            fromAmino: ((object: MsgConnectionOpenConfirmAmino) => MsgConnectionOpenConfirm);
            toAmino: ((message: MsgConnectionOpenConfirm) => MsgConnectionOpenConfirmAmino);
        };
        /ibc.core.connection.v1.MsgConnectionOpenInit: {
            aminoType: string;
            fromAmino: ((object: MsgConnectionOpenInitAmino) => MsgConnectionOpenInit);
            toAmino: ((message: MsgConnectionOpenInit) => MsgConnectionOpenInitAmino);
        };
        /ibc.core.connection.v1.MsgConnectionOpenTry: {
            aminoType: string;
            fromAmino: ((object: MsgConnectionOpenTryAmino) => MsgConnectionOpenTry);
            toAmino: ((message: MsgConnectionOpenTry) => MsgConnectionOpenTryAmino);
        };
    };
    ClientPaths: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ClientPaths;
        encode(message: ClientPaths, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ClientPathsAmino): ClientPaths;
        fromAminoMsg(object: ClientPathsAminoMsg): ClientPaths;
        fromPartial(object: {
            paths?: string[];
        }): ClientPaths;
        fromProtoMsg(message: ClientPathsProtoMsg): ClientPaths;
        toAmino(message: ClientPaths): ClientPathsAmino;
        toAminoMsg(message: ClientPaths): ClientPathsAminoMsg;
        toProto(message: ClientPaths): Uint8Array;
        toProtoMsg(message: ClientPaths): ClientPathsProtoMsg;
    };
    ConnectionEnd: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ConnectionEnd;
        encode(message: ConnectionEnd, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ConnectionEndAmino): ConnectionEnd;
        fromAminoMsg(object: ConnectionEndAminoMsg): ConnectionEnd;
        fromPartial(object: {
            clientId?: string;
            counterparty?: {
                clientId?: string;
                connectionId?: string;
                prefix?: {
                    keyPrefix?: Uint8Array;
                };
            };
            delayPeriod?: bigint;
            state?: State;
            versions?: {
                features?: string[];
                identifier?: string;
            }[];
        }): ConnectionEnd;
        fromProtoMsg(message: ConnectionEndProtoMsg): ConnectionEnd;
        toAmino(message: ConnectionEnd): ConnectionEndAmino;
        toAminoMsg(message: ConnectionEnd): ConnectionEndAminoMsg;
        toProto(message: ConnectionEnd): Uint8Array;
        toProtoMsg(message: ConnectionEnd): ConnectionEndProtoMsg;
    };
    ConnectionPaths: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ConnectionPaths;
        encode(message: ConnectionPaths, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ConnectionPathsAmino): ConnectionPaths;
        fromAminoMsg(object: ConnectionPathsAminoMsg): ConnectionPaths;
        fromPartial(object: {
            clientId?: string;
            paths?: string[];
        }): ConnectionPaths;
        fromProtoMsg(message: ConnectionPathsProtoMsg): ConnectionPaths;
        toAmino(message: ConnectionPaths): ConnectionPathsAmino;
        toAminoMsg(message: ConnectionPaths): ConnectionPathsAminoMsg;
        toProto(message: ConnectionPaths): Uint8Array;
        toProtoMsg(message: ConnectionPaths): ConnectionPathsProtoMsg;
    };
    Counterparty: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Counterparty;
        encode(message: Counterparty, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CounterpartyAmino): Counterparty;
        fromAminoMsg(object: CounterpartyAminoMsg): Counterparty;
        fromPartial(object: {
            clientId?: string;
            connectionId?: string;
            prefix?: {
                keyPrefix?: Uint8Array;
            };
        }): Counterparty;
        fromProtoMsg(message: CounterpartyProtoMsg): Counterparty;
        toAmino(message: Counterparty): CounterpartyAmino;
        toAminoMsg(message: Counterparty): CounterpartyAminoMsg;
        toProto(message: Counterparty): Uint8Array;
        toProtoMsg(message: Counterparty): CounterpartyProtoMsg;
    };
    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: {
            clientConnectionPaths?: {
                clientId?: string;
                paths?: string[];
            }[];
            connections?: {
                clientId?: string;
                counterparty?: {
                    clientId?: string;
                    connectionId?: string;
                    prefix?: {
                        keyPrefix?: (...) | (...);
                    };
                };
                delayPeriod?: bigint;
                id?: string;
                state?: State;
                versions?: {
                    features?: (...)[];
                    identifier?: string;
                }[];
            }[];
            nextConnectionSequence?: bigint;
            params?: {
                maxExpectedTimePerBlock?: bigint;
            };
        }): GenesisState;
        fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
        toAmino(message: GenesisState): GenesisStateAmino;
        toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
        toProto(message: GenesisState): Uint8Array;
        toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
    };
    IdentifiedConnection: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): IdentifiedConnection;
        encode(message: IdentifiedConnection, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: IdentifiedConnectionAmino): IdentifiedConnection;
        fromAminoMsg(object: IdentifiedConnectionAminoMsg): IdentifiedConnection;
        fromPartial(object: {
            clientId?: string;
            counterparty?: {
                clientId?: string;
                connectionId?: string;
                prefix?: {
                    keyPrefix?: Uint8Array;
                };
            };
            delayPeriod?: bigint;
            id?: string;
            state?: State;
            versions?: {
                features?: string[];
                identifier?: string;
            }[];
        }): IdentifiedConnection;
        fromProtoMsg(message: IdentifiedConnectionProtoMsg): IdentifiedConnection;
        toAmino(message: IdentifiedConnection): IdentifiedConnectionAmino;
        toAminoMsg(message: IdentifiedConnection): IdentifiedConnectionAminoMsg;
        toProto(message: IdentifiedConnection): Uint8Array;
        toProtoMsg(message: IdentifiedConnection): IdentifiedConnectionProtoMsg;
    };
    MessageComposer: {
        encoded: {
            connectionOpenAck(value: MsgConnectionOpenAck): {
                typeUrl: string;
                value: Uint8Array;
            };
            connectionOpenConfirm(value: MsgConnectionOpenConfirm): {
                typeUrl: string;
                value: Uint8Array;
            };
            connectionOpenInit(value: MsgConnectionOpenInit): {
                typeUrl: string;
                value: Uint8Array;
            };
            connectionOpenTry(value: MsgConnectionOpenTry): {
                typeUrl: string;
                value: Uint8Array;
            };
        };
        fromPartial: {
            connectionOpenAck(value: MsgConnectionOpenAck): {
                typeUrl: string;
                value: MsgConnectionOpenAck;
            };
            connectionOpenConfirm(value: MsgConnectionOpenConfirm): {
                typeUrl: string;
                value: MsgConnectionOpenConfirm;
            };
            connectionOpenInit(value: MsgConnectionOpenInit): {
                typeUrl: string;
                value: MsgConnectionOpenInit;
            };
            connectionOpenTry(value: MsgConnectionOpenTry): {
                typeUrl: string;
                value: MsgConnectionOpenTry;
            };
        };
        withTypeUrl: {
            connectionOpenAck(value: MsgConnectionOpenAck): {
                typeUrl: string;
                value: MsgConnectionOpenAck;
            };
            connectionOpenConfirm(value: MsgConnectionOpenConfirm): {
                typeUrl: string;
                value: MsgConnectionOpenConfirm;
            };
            connectionOpenInit(value: MsgConnectionOpenInit): {
                typeUrl: string;
                value: MsgConnectionOpenInit;
            };
            connectionOpenTry(value: MsgConnectionOpenTry): {
                typeUrl: string;
                value: MsgConnectionOpenTry;
            };
        };
    };
    MsgConnectionOpenAck: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgConnectionOpenAck;
        encode(message: MsgConnectionOpenAck, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgConnectionOpenAckAmino): MsgConnectionOpenAck;
        fromAminoMsg(object: MsgConnectionOpenAckAminoMsg): MsgConnectionOpenAck;
        fromPartial(object: {
            clientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            connectionId?: string;
            consensusHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            counterpartyConnectionId?: string;
            proofClient?: Uint8Array;
            proofConsensus?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            proofTry?: Uint8Array;
            signer?: string;
            version?: {
                features?: string[];
                identifier?: string;
            };
        }): MsgConnectionOpenAck;
        fromProtoMsg(message: MsgConnectionOpenAckProtoMsg): MsgConnectionOpenAck;
        toAmino(message: MsgConnectionOpenAck): MsgConnectionOpenAckAmino;
        toAminoMsg(message: MsgConnectionOpenAck): MsgConnectionOpenAckAminoMsg;
        toProto(message: MsgConnectionOpenAck): Uint8Array;
        toProtoMsg(message: MsgConnectionOpenAck): MsgConnectionOpenAckProtoMsg;
    };
    MsgConnectionOpenAckResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgConnectionOpenAckResponse;
        encode(_: MsgConnectionOpenAckResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgConnectionOpenAckResponseAmino): MsgConnectionOpenAckResponse;
        fromAminoMsg(object: MsgConnectionOpenAckResponseAminoMsg): MsgConnectionOpenAckResponse;
        fromPartial(_: {}): MsgConnectionOpenAckResponse;
        fromProtoMsg(message: MsgConnectionOpenAckResponseProtoMsg): MsgConnectionOpenAckResponse;
        toAmino(_: MsgConnectionOpenAckResponse): MsgConnectionOpenAckResponseAmino;
        toAminoMsg(message: MsgConnectionOpenAckResponse): MsgConnectionOpenAckResponseAminoMsg;
        toProto(message: MsgConnectionOpenAckResponse): Uint8Array;
        toProtoMsg(message: MsgConnectionOpenAckResponse): MsgConnectionOpenAckResponseProtoMsg;
    };
    MsgConnectionOpenConfirm: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgConnectionOpenConfirm;
        encode(message: MsgConnectionOpenConfirm, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgConnectionOpenConfirmAmino): MsgConnectionOpenConfirm;
        fromAminoMsg(object: MsgConnectionOpenConfirmAminoMsg): MsgConnectionOpenConfirm;
        fromPartial(object: {
            connectionId?: string;
            proofAck?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            signer?: string;
        }): MsgConnectionOpenConfirm;
        fromProtoMsg(message: MsgConnectionOpenConfirmProtoMsg): MsgConnectionOpenConfirm;
        toAmino(message: MsgConnectionOpenConfirm): MsgConnectionOpenConfirmAmino;
        toAminoMsg(message: MsgConnectionOpenConfirm): MsgConnectionOpenConfirmAminoMsg;
        toProto(message: MsgConnectionOpenConfirm): Uint8Array;
        toProtoMsg(message: MsgConnectionOpenConfirm): MsgConnectionOpenConfirmProtoMsg;
    };
    MsgConnectionOpenConfirmResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgConnectionOpenConfirmResponse;
        encode(_: MsgConnectionOpenConfirmResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgConnectionOpenConfirmResponseAmino): MsgConnectionOpenConfirmResponse;
        fromAminoMsg(object: MsgConnectionOpenConfirmResponseAminoMsg): MsgConnectionOpenConfirmResponse;
        fromPartial(_: {}): MsgConnectionOpenConfirmResponse;
        fromProtoMsg(message: MsgConnectionOpenConfirmResponseProtoMsg): MsgConnectionOpenConfirmResponse;
        toAmino(_: MsgConnectionOpenConfirmResponse): MsgConnectionOpenConfirmResponseAmino;
        toAminoMsg(message: MsgConnectionOpenConfirmResponse): MsgConnectionOpenConfirmResponseAminoMsg;
        toProto(message: MsgConnectionOpenConfirmResponse): Uint8Array;
        toProtoMsg(message: MsgConnectionOpenConfirmResponse): MsgConnectionOpenConfirmResponseProtoMsg;
    };
    MsgConnectionOpenInit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgConnectionOpenInit;
        encode(message: MsgConnectionOpenInit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgConnectionOpenInitAmino): MsgConnectionOpenInit;
        fromAminoMsg(object: MsgConnectionOpenInitAminoMsg): MsgConnectionOpenInit;
        fromPartial(object: {
            clientId?: string;
            counterparty?: {
                clientId?: string;
                connectionId?: string;
                prefix?: {
                    keyPrefix?: Uint8Array;
                };
            };
            delayPeriod?: bigint;
            signer?: string;
            version?: {
                features?: string[];
                identifier?: string;
            };
        }): MsgConnectionOpenInit;
        fromProtoMsg(message: MsgConnectionOpenInitProtoMsg): MsgConnectionOpenInit;
        toAmino(message: MsgConnectionOpenInit): MsgConnectionOpenInitAmino;
        toAminoMsg(message: MsgConnectionOpenInit): MsgConnectionOpenInitAminoMsg;
        toProto(message: MsgConnectionOpenInit): Uint8Array;
        toProtoMsg(message: MsgConnectionOpenInit): MsgConnectionOpenInitProtoMsg;
    };
    MsgConnectionOpenInitResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgConnectionOpenInitResponse;
        encode(_: MsgConnectionOpenInitResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgConnectionOpenInitResponseAmino): MsgConnectionOpenInitResponse;
        fromAminoMsg(object: MsgConnectionOpenInitResponseAminoMsg): MsgConnectionOpenInitResponse;
        fromPartial(_: {}): MsgConnectionOpenInitResponse;
        fromProtoMsg(message: MsgConnectionOpenInitResponseProtoMsg): MsgConnectionOpenInitResponse;
        toAmino(_: MsgConnectionOpenInitResponse): MsgConnectionOpenInitResponseAmino;
        toAminoMsg(message: MsgConnectionOpenInitResponse): MsgConnectionOpenInitResponseAminoMsg;
        toProto(message: MsgConnectionOpenInitResponse): Uint8Array;
        toProtoMsg(message: MsgConnectionOpenInitResponse): MsgConnectionOpenInitResponseProtoMsg;
    };
    MsgConnectionOpenTry: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgConnectionOpenTry;
        encode(message: MsgConnectionOpenTry, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgConnectionOpenTryAmino): MsgConnectionOpenTry;
        fromAminoMsg(object: MsgConnectionOpenTryAminoMsg): MsgConnectionOpenTry;
        fromPartial(object: {
            clientId?: string;
            clientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            consensusHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            counterparty?: {
                clientId?: string;
                connectionId?: string;
                prefix?: {
                    keyPrefix?: Uint8Array;
                };
            };
            counterpartyVersions?: {
                features?: string[];
                identifier?: string;
            }[];
            delayPeriod?: bigint;
            previousConnectionId?: string;
            proofClient?: Uint8Array;
            proofConsensus?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            proofInit?: Uint8Array;
            signer?: string;
        }): MsgConnectionOpenTry;
        fromProtoMsg(message: MsgConnectionOpenTryProtoMsg): MsgConnectionOpenTry;
        toAmino(message: MsgConnectionOpenTry): MsgConnectionOpenTryAmino;
        toAminoMsg(message: MsgConnectionOpenTry): MsgConnectionOpenTryAminoMsg;
        toProto(message: MsgConnectionOpenTry): Uint8Array;
        toProtoMsg(message: MsgConnectionOpenTry): MsgConnectionOpenTryProtoMsg;
    };
    MsgConnectionOpenTryResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgConnectionOpenTryResponse;
        encode(_: MsgConnectionOpenTryResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgConnectionOpenTryResponseAmino): MsgConnectionOpenTryResponse;
        fromAminoMsg(object: MsgConnectionOpenTryResponseAminoMsg): MsgConnectionOpenTryResponse;
        fromPartial(_: {}): MsgConnectionOpenTryResponse;
        fromProtoMsg(message: MsgConnectionOpenTryResponseProtoMsg): MsgConnectionOpenTryResponse;
        toAmino(_: MsgConnectionOpenTryResponse): MsgConnectionOpenTryResponseAmino;
        toAminoMsg(message: MsgConnectionOpenTryResponse): MsgConnectionOpenTryResponseAminoMsg;
        toProto(message: MsgConnectionOpenTryResponse): Uint8Array;
        toProtoMsg(message: MsgConnectionOpenTryResponse): MsgConnectionOpenTryResponseProtoMsg;
    };
    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: {
            maxExpectedTimePerBlock?: bigint;
        }): Params;
        fromProtoMsg(message: ParamsProtoMsg): Params;
        toAmino(message: Params): ParamsAmino;
        toAminoMsg(message: Params): ParamsAminoMsg;
        toProto(message: Params): Uint8Array;
        toProtoMsg(message: Params): ParamsProtoMsg;
    };
    QueryClientConnectionsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientConnectionsRequest;
        encode(message: QueryClientConnectionsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientConnectionsRequestAmino): QueryClientConnectionsRequest;
        fromAminoMsg(object: QueryClientConnectionsRequestAminoMsg): QueryClientConnectionsRequest;
        fromPartial(object: {
            clientId?: string;
        }): QueryClientConnectionsRequest;
        fromProtoMsg(message: QueryClientConnectionsRequestProtoMsg): QueryClientConnectionsRequest;
        toAmino(message: QueryClientConnectionsRequest): QueryClientConnectionsRequestAmino;
        toAminoMsg(message: QueryClientConnectionsRequest): QueryClientConnectionsRequestAminoMsg;
        toProto(message: QueryClientConnectionsRequest): Uint8Array;
        toProtoMsg(message: QueryClientConnectionsRequest): QueryClientConnectionsRequestProtoMsg;
    };
    QueryClientConnectionsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryClientConnectionsResponse;
        encode(message: QueryClientConnectionsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryClientConnectionsResponseAmino): QueryClientConnectionsResponse;
        fromAminoMsg(object: QueryClientConnectionsResponseAminoMsg): QueryClientConnectionsResponse;
        fromPartial(object: {
            connectionPaths?: string[];
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryClientConnectionsResponse;
        fromProtoMsg(message: QueryClientConnectionsResponseProtoMsg): QueryClientConnectionsResponse;
        toAmino(message: QueryClientConnectionsResponse): QueryClientConnectionsResponseAmino;
        toAminoMsg(message: QueryClientConnectionsResponse): QueryClientConnectionsResponseAminoMsg;
        toProto(message: QueryClientConnectionsResponse): Uint8Array;
        toProtoMsg(message: QueryClientConnectionsResponse): QueryClientConnectionsResponseProtoMsg;
    };
    QueryConnectionClientStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionClientStateRequest;
        encode(message: QueryConnectionClientStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionClientStateRequestAmino): QueryConnectionClientStateRequest;
        fromAminoMsg(object: QueryConnectionClientStateRequestAminoMsg): QueryConnectionClientStateRequest;
        fromPartial(object: {
            connectionId?: string;
        }): QueryConnectionClientStateRequest;
        fromProtoMsg(message: QueryConnectionClientStateRequestProtoMsg): QueryConnectionClientStateRequest;
        toAmino(message: QueryConnectionClientStateRequest): QueryConnectionClientStateRequestAmino;
        toAminoMsg(message: QueryConnectionClientStateRequest): QueryConnectionClientStateRequestAminoMsg;
        toProto(message: QueryConnectionClientStateRequest): Uint8Array;
        toProtoMsg(message: QueryConnectionClientStateRequest): QueryConnectionClientStateRequestProtoMsg;
    };
    QueryConnectionClientStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionClientStateResponse;
        encode(message: QueryConnectionClientStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionClientStateResponseAmino): QueryConnectionClientStateResponse;
        fromAminoMsg(object: QueryConnectionClientStateResponseAminoMsg): QueryConnectionClientStateResponse;
        fromPartial(object: {
            identifiedClientState?: {
                clientId?: string;
                clientState?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
            };
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryConnectionClientStateResponse;
        fromProtoMsg(message: QueryConnectionClientStateResponseProtoMsg): QueryConnectionClientStateResponse;
        toAmino(message: QueryConnectionClientStateResponse): QueryConnectionClientStateResponseAmino;
        toAminoMsg(message: QueryConnectionClientStateResponse): QueryConnectionClientStateResponseAminoMsg;
        toProto(message: QueryConnectionClientStateResponse): Uint8Array;
        toProtoMsg(message: QueryConnectionClientStateResponse): QueryConnectionClientStateResponseProtoMsg;
    };
    QueryConnectionConsensusStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionConsensusStateRequest;
        encode(message: QueryConnectionConsensusStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionConsensusStateRequestAmino): QueryConnectionConsensusStateRequest;
        fromAminoMsg(object: QueryConnectionConsensusStateRequestAminoMsg): QueryConnectionConsensusStateRequest;
        fromPartial(object: {
            connectionId?: string;
            revisionHeight?: bigint;
            revisionNumber?: bigint;
        }): QueryConnectionConsensusStateRequest;
        fromProtoMsg(message: QueryConnectionConsensusStateRequestProtoMsg): QueryConnectionConsensusStateRequest;
        toAmino(message: QueryConnectionConsensusStateRequest): QueryConnectionConsensusStateRequestAmino;
        toAminoMsg(message: QueryConnectionConsensusStateRequest): QueryConnectionConsensusStateRequestAminoMsg;
        toProto(message: QueryConnectionConsensusStateRequest): Uint8Array;
        toProtoMsg(message: QueryConnectionConsensusStateRequest): QueryConnectionConsensusStateRequestProtoMsg;
    };
    QueryConnectionConsensusStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionConsensusStateResponse;
        encode(message: QueryConnectionConsensusStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionConsensusStateResponseAmino): QueryConnectionConsensusStateResponse;
        fromAminoMsg(object: QueryConnectionConsensusStateResponseAminoMsg): QueryConnectionConsensusStateResponse;
        fromPartial(object: {
            clientId?: string;
            consensusState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryConnectionConsensusStateResponse;
        fromProtoMsg(message: QueryConnectionConsensusStateResponseProtoMsg): QueryConnectionConsensusStateResponse;
        toAmino(message: QueryConnectionConsensusStateResponse): QueryConnectionConsensusStateResponseAmino;
        toAminoMsg(message: QueryConnectionConsensusStateResponse): QueryConnectionConsensusStateResponseAminoMsg;
        toProto(message: QueryConnectionConsensusStateResponse): Uint8Array;
        toProtoMsg(message: QueryConnectionConsensusStateResponse): QueryConnectionConsensusStateResponseProtoMsg;
    };
    QueryConnectionRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionRequest;
        encode(message: QueryConnectionRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionRequestAmino): QueryConnectionRequest;
        fromAminoMsg(object: QueryConnectionRequestAminoMsg): QueryConnectionRequest;
        fromPartial(object: {
            connectionId?: string;
        }): QueryConnectionRequest;
        fromProtoMsg(message: QueryConnectionRequestProtoMsg): QueryConnectionRequest;
        toAmino(message: QueryConnectionRequest): QueryConnectionRequestAmino;
        toAminoMsg(message: QueryConnectionRequest): QueryConnectionRequestAminoMsg;
        toProto(message: QueryConnectionRequest): Uint8Array;
        toProtoMsg(message: QueryConnectionRequest): QueryConnectionRequestProtoMsg;
    };
    QueryConnectionResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionResponse;
        encode(message: QueryConnectionResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionResponseAmino): QueryConnectionResponse;
        fromAminoMsg(object: QueryConnectionResponseAminoMsg): QueryConnectionResponse;
        fromPartial(object: {
            connection?: {
                clientId?: string;
                counterparty?: {
                    clientId?: string;
                    connectionId?: string;
                    prefix?: {
                        keyPrefix?: Uint8Array;
                    };
                };
                delayPeriod?: bigint;
                state?: State;
                versions?: {
                    features?: string[];
                    identifier?: string;
                }[];
            };
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryConnectionResponse;
        fromProtoMsg(message: QueryConnectionResponseProtoMsg): QueryConnectionResponse;
        toAmino(message: QueryConnectionResponse): QueryConnectionResponseAmino;
        toAminoMsg(message: QueryConnectionResponse): QueryConnectionResponseAminoMsg;
        toProto(message: QueryConnectionResponse): Uint8Array;
        toProtoMsg(message: QueryConnectionResponse): QueryConnectionResponseProtoMsg;
    };
    QueryConnectionsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionsRequest;
        encode(message: QueryConnectionsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionsRequestAmino): QueryConnectionsRequest;
        fromAminoMsg(object: QueryConnectionsRequestAminoMsg): QueryConnectionsRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryConnectionsRequest;
        fromProtoMsg(message: QueryConnectionsRequestProtoMsg): QueryConnectionsRequest;
        toAmino(message: QueryConnectionsRequest): QueryConnectionsRequestAmino;
        toAminoMsg(message: QueryConnectionsRequest): QueryConnectionsRequestAminoMsg;
        toProto(message: QueryConnectionsRequest): Uint8Array;
        toProtoMsg(message: QueryConnectionsRequest): QueryConnectionsRequestProtoMsg;
    };
    QueryConnectionsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionsResponse;
        encode(message: QueryConnectionsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionsResponseAmino): QueryConnectionsResponse;
        fromAminoMsg(object: QueryConnectionsResponseAminoMsg): QueryConnectionsResponse;
        fromPartial(object: {
            connections?: {
                clientId?: string;
                counterparty?: {
                    clientId?: string;
                    connectionId?: string;
                    prefix?: {
                        keyPrefix?: (...) | (...);
                    };
                };
                delayPeriod?: bigint;
                id?: string;
                state?: State;
                versions?: {
                    features?: (...)[];
                    identifier?: string;
                }[];
            }[];
            height?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryConnectionsResponse;
        fromProtoMsg(message: QueryConnectionsResponseProtoMsg): QueryConnectionsResponse;
        toAmino(message: QueryConnectionsResponse): QueryConnectionsResponseAmino;
        toAminoMsg(message: QueryConnectionsResponse): QueryConnectionsResponseAminoMsg;
        toProto(message: QueryConnectionsResponse): Uint8Array;
        toProtoMsg(message: QueryConnectionsResponse): QueryConnectionsResponseProtoMsg;
    };
    StateAmino: typeof State;
    StateSDKType: typeof State;
    Version: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Version;
        encode(message: Version, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: VersionAmino): Version;
        fromAminoMsg(object: VersionAminoMsg): Version;
        fromPartial(object: {
            features?: string[];
            identifier?: string;
        }): Version;
        fromProtoMsg(message: VersionProtoMsg): Version;
        toAmino(message: Version): VersionAmino;
        toAminoMsg(message: Version): VersionAminoMsg;
        toProto(message: Version): Uint8Array;
        toProtoMsg(message: Version): VersionProtoMsg;
    };
    createRpcQueryExtension: ((base: QueryClient) => {
        clientConnections(request: QueryClientConnectionsRequest): Promise<QueryClientConnectionsResponse>;
        connection(request: QueryConnectionRequest): Promise<QueryConnectionResponse>;
        connectionClientState(request: QueryConnectionClientStateRequest): Promise<QueryConnectionClientStateResponse>;
        connectionConsensusState(request: QueryConnectionConsensusStateRequest): Promise<QueryConnectionConsensusStateResponse>;
        connections(request?: QueryConnectionsRequest): Promise<QueryConnectionsResponse>;
    });
    load: ((protoRegistry: Registry) => void);
    registry: readonly [string, TelescopeGeneratedType<any, any, any>][];
    stateFromJSON(object: any): State;
    stateToJSON(object: State): string;
} = ...

Type declaration

Settings

Member Visibility