Variable v1Const

v1: {
    Order: any;
    State: any;
    LCDQueryClient: any;
    MsgClientImpl: any;
    QueryClientImpl: any;
    Acknowledgement: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Acknowledgement;
        encode(message: Acknowledgement, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AcknowledgementAmino): Acknowledgement;
        fromAminoMsg(object: AcknowledgementAminoMsg): Acknowledgement;
        fromPartial(object: {
            error?: string;
            result?: Uint8Array;
        }): Acknowledgement;
        fromProtoMsg(message: AcknowledgementProtoMsg): Acknowledgement;
        toAmino(message: Acknowledgement): AcknowledgementAmino;
        toAminoMsg(message: Acknowledgement): AcknowledgementAminoMsg;
        toProto(message: Acknowledgement): Uint8Array;
        toProtoMsg(message: Acknowledgement): AcknowledgementProtoMsg;
    };
    AminoConverter: {
        /ibc.core.channel.v1.MsgAcknowledgement: {
            aminoType: string;
            fromAmino: ((object: MsgAcknowledgementAmino) => MsgAcknowledgement);
            toAmino: ((message: MsgAcknowledgement) => MsgAcknowledgementAmino);
        };
        /ibc.core.channel.v1.MsgChannelCloseConfirm: {
            aminoType: string;
            fromAmino: ((object: MsgChannelCloseConfirmAmino) => MsgChannelCloseConfirm);
            toAmino: ((message: MsgChannelCloseConfirm) => MsgChannelCloseConfirmAmino);
        };
        /ibc.core.channel.v1.MsgChannelCloseInit: {
            aminoType: string;
            fromAmino: ((object: MsgChannelCloseInitAmino) => MsgChannelCloseInit);
            toAmino: ((message: MsgChannelCloseInit) => MsgChannelCloseInitAmino);
        };
        /ibc.core.channel.v1.MsgChannelOpenAck: {
            aminoType: string;
            fromAmino: ((object: MsgChannelOpenAckAmino) => MsgChannelOpenAck);
            toAmino: ((message: MsgChannelOpenAck) => MsgChannelOpenAckAmino);
        };
        /ibc.core.channel.v1.MsgChannelOpenConfirm: {
            aminoType: string;
            fromAmino: ((object: MsgChannelOpenConfirmAmino) => MsgChannelOpenConfirm);
            toAmino: ((message: MsgChannelOpenConfirm) => MsgChannelOpenConfirmAmino);
        };
        /ibc.core.channel.v1.MsgChannelOpenInit: {
            aminoType: string;
            fromAmino: ((object: MsgChannelOpenInitAmino) => MsgChannelOpenInit);
            toAmino: ((message: MsgChannelOpenInit) => MsgChannelOpenInitAmino);
        };
        /ibc.core.channel.v1.MsgChannelOpenTry: {
            aminoType: string;
            fromAmino: ((object: MsgChannelOpenTryAmino) => MsgChannelOpenTry);
            toAmino: ((message: MsgChannelOpenTry) => MsgChannelOpenTryAmino);
        };
        /ibc.core.channel.v1.MsgRecvPacket: {
            aminoType: string;
            fromAmino: ((object: MsgRecvPacketAmino) => MsgRecvPacket);
            toAmino: ((message: MsgRecvPacket) => MsgRecvPacketAmino);
        };
        /ibc.core.channel.v1.MsgTimeout: {
            aminoType: string;
            fromAmino: ((object: MsgTimeoutAmino) => MsgTimeout);
            toAmino: ((message: MsgTimeout) => MsgTimeoutAmino);
        };
        /ibc.core.channel.v1.MsgTimeoutOnClose: {
            aminoType: string;
            fromAmino: ((object: MsgTimeoutOnCloseAmino) => MsgTimeoutOnClose);
            toAmino: ((message: MsgTimeoutOnClose) => MsgTimeoutOnCloseAmino);
        };
    };
    Channel: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Channel;
        encode(message: Channel, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ChannelAmino): Channel;
        fromAminoMsg(object: ChannelAminoMsg): Channel;
        fromPartial(object: {
            connectionHops?: string[];
            counterparty?: {
                channelId?: string;
                portId?: string;
            };
            ordering?: Order;
            state?: State;
            version?: string;
        }): Channel;
        fromProtoMsg(message: ChannelProtoMsg): Channel;
        toAmino(message: Channel): ChannelAmino;
        toAminoMsg(message: Channel): ChannelAminoMsg;
        toProto(message: Channel): Uint8Array;
        toProtoMsg(message: Channel): ChannelProtoMsg;
    };
    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: {
            channelId?: string;
            portId?: string;
        }): 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: {
            ackSequences?: {
                channelId?: string;
                portId?: string;
                sequence?: bigint;
            }[];
            acknowledgements?: {
                channelId?: string;
                data?: Uint8Array;
                portId?: string;
                sequence?: bigint;
            }[];
            channels?: {
                channelId?: string;
                connectionHops?: string[];
                counterparty?: {
                    channelId?: string;
                    portId?: string;
                };
                ordering?: Order;
                portId?: string;
                state?: State;
                version?: string;
            }[];
            commitments?: {
                channelId?: string;
                data?: Uint8Array;
                portId?: string;
                sequence?: bigint;
            }[];
            nextChannelSequence?: bigint;
            receipts?: {
                channelId?: string;
                data?: Uint8Array;
                portId?: string;
                sequence?: bigint;
            }[];
            recvSequences?: {
                channelId?: string;
                portId?: string;
                sequence?: bigint;
            }[];
            sendSequences?: {
                channelId?: string;
                portId?: string;
                sequence?: bigint;
            }[];
        }): GenesisState;
        fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
        toAmino(message: GenesisState): GenesisStateAmino;
        toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
        toProto(message: GenesisState): Uint8Array;
        toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
    };
    IdentifiedChannel: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): IdentifiedChannel;
        encode(message: IdentifiedChannel, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: IdentifiedChannelAmino): IdentifiedChannel;
        fromAminoMsg(object: IdentifiedChannelAminoMsg): IdentifiedChannel;
        fromPartial(object: {
            channelId?: string;
            connectionHops?: string[];
            counterparty?: {
                channelId?: string;
                portId?: string;
            };
            ordering?: Order;
            portId?: string;
            state?: State;
            version?: string;
        }): IdentifiedChannel;
        fromProtoMsg(message: IdentifiedChannelProtoMsg): IdentifiedChannel;
        toAmino(message: IdentifiedChannel): IdentifiedChannelAmino;
        toAminoMsg(message: IdentifiedChannel): IdentifiedChannelAminoMsg;
        toProto(message: IdentifiedChannel): Uint8Array;
        toProtoMsg(message: IdentifiedChannel): IdentifiedChannelProtoMsg;
    };
    MessageComposer: {
        encoded: {
            acknowledgement(value: MsgAcknowledgement): {
                typeUrl: string;
                value: Uint8Array;
            };
            channelCloseConfirm(value: MsgChannelCloseConfirm): {
                typeUrl: string;
                value: Uint8Array;
            };
            channelCloseInit(value: MsgChannelCloseInit): {
                typeUrl: string;
                value: Uint8Array;
            };
            channelOpenAck(value: MsgChannelOpenAck): {
                typeUrl: string;
                value: Uint8Array;
            };
            channelOpenConfirm(value: MsgChannelOpenConfirm): {
                typeUrl: string;
                value: Uint8Array;
            };
            channelOpenInit(value: MsgChannelOpenInit): {
                typeUrl: string;
                value: Uint8Array;
            };
            channelOpenTry(value: MsgChannelOpenTry): {
                typeUrl: string;
                value: Uint8Array;
            };
            recvPacket(value: MsgRecvPacket): {
                typeUrl: string;
                value: Uint8Array;
            };
            timeout(value: MsgTimeout): {
                typeUrl: string;
                value: Uint8Array;
            };
            timeoutOnClose(value: MsgTimeoutOnClose): {
                typeUrl: string;
                value: Uint8Array;
            };
        };
        fromPartial: {
            acknowledgement(value: MsgAcknowledgement): {
                typeUrl: string;
                value: MsgAcknowledgement;
            };
            channelCloseConfirm(value: MsgChannelCloseConfirm): {
                typeUrl: string;
                value: MsgChannelCloseConfirm;
            };
            channelCloseInit(value: MsgChannelCloseInit): {
                typeUrl: string;
                value: MsgChannelCloseInit;
            };
            channelOpenAck(value: MsgChannelOpenAck): {
                typeUrl: string;
                value: MsgChannelOpenAck;
            };
            channelOpenConfirm(value: MsgChannelOpenConfirm): {
                typeUrl: string;
                value: MsgChannelOpenConfirm;
            };
            channelOpenInit(value: MsgChannelOpenInit): {
                typeUrl: string;
                value: MsgChannelOpenInit;
            };
            channelOpenTry(value: MsgChannelOpenTry): {
                typeUrl: string;
                value: MsgChannelOpenTry;
            };
            recvPacket(value: MsgRecvPacket): {
                typeUrl: string;
                value: MsgRecvPacket;
            };
            timeout(value: MsgTimeout): {
                typeUrl: string;
                value: MsgTimeout;
            };
            timeoutOnClose(value: MsgTimeoutOnClose): {
                typeUrl: string;
                value: MsgTimeoutOnClose;
            };
        };
        withTypeUrl: {
            acknowledgement(value: MsgAcknowledgement): {
                typeUrl: string;
                value: MsgAcknowledgement;
            };
            channelCloseConfirm(value: MsgChannelCloseConfirm): {
                typeUrl: string;
                value: MsgChannelCloseConfirm;
            };
            channelCloseInit(value: MsgChannelCloseInit): {
                typeUrl: string;
                value: MsgChannelCloseInit;
            };
            channelOpenAck(value: MsgChannelOpenAck): {
                typeUrl: string;
                value: MsgChannelOpenAck;
            };
            channelOpenConfirm(value: MsgChannelOpenConfirm): {
                typeUrl: string;
                value: MsgChannelOpenConfirm;
            };
            channelOpenInit(value: MsgChannelOpenInit): {
                typeUrl: string;
                value: MsgChannelOpenInit;
            };
            channelOpenTry(value: MsgChannelOpenTry): {
                typeUrl: string;
                value: MsgChannelOpenTry;
            };
            recvPacket(value: MsgRecvPacket): {
                typeUrl: string;
                value: MsgRecvPacket;
            };
            timeout(value: MsgTimeout): {
                typeUrl: string;
                value: MsgTimeout;
            };
            timeoutOnClose(value: MsgTimeoutOnClose): {
                typeUrl: string;
                value: MsgTimeoutOnClose;
            };
        };
    };
    MsgAcknowledgement: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgAcknowledgement;
        encode(message: MsgAcknowledgement, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgAcknowledgementAmino): MsgAcknowledgement;
        fromAminoMsg(object: MsgAcknowledgementAminoMsg): MsgAcknowledgement;
        fromPartial(object: {
            acknowledgement?: Uint8Array;
            packet?: {
                data?: Uint8Array;
                destinationChannel?: string;
                destinationPort?: string;
                sequence?: bigint;
                sourceChannel?: string;
                sourcePort?: string;
                timeoutHeight?: {
                    revisionHeight?: bigint;
                    revisionNumber?: bigint;
                };
                timeoutTimestamp?: bigint;
            };
            proofAcked?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            signer?: string;
        }): MsgAcknowledgement;
        fromProtoMsg(message: MsgAcknowledgementProtoMsg): MsgAcknowledgement;
        toAmino(message: MsgAcknowledgement): MsgAcknowledgementAmino;
        toAminoMsg(message: MsgAcknowledgement): MsgAcknowledgementAminoMsg;
        toProto(message: MsgAcknowledgement): Uint8Array;
        toProtoMsg(message: MsgAcknowledgement): MsgAcknowledgementProtoMsg;
    };
    MsgAcknowledgementResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgAcknowledgementResponse;
        encode(_: MsgAcknowledgementResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgAcknowledgementResponseAmino): MsgAcknowledgementResponse;
        fromAminoMsg(object: MsgAcknowledgementResponseAminoMsg): MsgAcknowledgementResponse;
        fromPartial(_: {}): MsgAcknowledgementResponse;
        fromProtoMsg(message: MsgAcknowledgementResponseProtoMsg): MsgAcknowledgementResponse;
        toAmino(_: MsgAcknowledgementResponse): MsgAcknowledgementResponseAmino;
        toAminoMsg(message: MsgAcknowledgementResponse): MsgAcknowledgementResponseAminoMsg;
        toProto(message: MsgAcknowledgementResponse): Uint8Array;
        toProtoMsg(message: MsgAcknowledgementResponse): MsgAcknowledgementResponseProtoMsg;
    };
    MsgChannelCloseConfirm: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelCloseConfirm;
        encode(message: MsgChannelCloseConfirm, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgChannelCloseConfirmAmino): MsgChannelCloseConfirm;
        fromAminoMsg(object: MsgChannelCloseConfirmAminoMsg): MsgChannelCloseConfirm;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            proofInit?: Uint8Array;
            signer?: string;
        }): MsgChannelCloseConfirm;
        fromProtoMsg(message: MsgChannelCloseConfirmProtoMsg): MsgChannelCloseConfirm;
        toAmino(message: MsgChannelCloseConfirm): MsgChannelCloseConfirmAmino;
        toAminoMsg(message: MsgChannelCloseConfirm): MsgChannelCloseConfirmAminoMsg;
        toProto(message: MsgChannelCloseConfirm): Uint8Array;
        toProtoMsg(message: MsgChannelCloseConfirm): MsgChannelCloseConfirmProtoMsg;
    };
    MsgChannelCloseConfirmResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelCloseConfirmResponse;
        encode(_: MsgChannelCloseConfirmResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgChannelCloseConfirmResponseAmino): MsgChannelCloseConfirmResponse;
        fromAminoMsg(object: MsgChannelCloseConfirmResponseAminoMsg): MsgChannelCloseConfirmResponse;
        fromPartial(_: {}): MsgChannelCloseConfirmResponse;
        fromProtoMsg(message: MsgChannelCloseConfirmResponseProtoMsg): MsgChannelCloseConfirmResponse;
        toAmino(_: MsgChannelCloseConfirmResponse): MsgChannelCloseConfirmResponseAmino;
        toAminoMsg(message: MsgChannelCloseConfirmResponse): MsgChannelCloseConfirmResponseAminoMsg;
        toProto(message: MsgChannelCloseConfirmResponse): Uint8Array;
        toProtoMsg(message: MsgChannelCloseConfirmResponse): MsgChannelCloseConfirmResponseProtoMsg;
    };
    MsgChannelCloseInit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelCloseInit;
        encode(message: MsgChannelCloseInit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgChannelCloseInitAmino): MsgChannelCloseInit;
        fromAminoMsg(object: MsgChannelCloseInitAminoMsg): MsgChannelCloseInit;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
            signer?: string;
        }): MsgChannelCloseInit;
        fromProtoMsg(message: MsgChannelCloseInitProtoMsg): MsgChannelCloseInit;
        toAmino(message: MsgChannelCloseInit): MsgChannelCloseInitAmino;
        toAminoMsg(message: MsgChannelCloseInit): MsgChannelCloseInitAminoMsg;
        toProto(message: MsgChannelCloseInit): Uint8Array;
        toProtoMsg(message: MsgChannelCloseInit): MsgChannelCloseInitProtoMsg;
    };
    MsgChannelCloseInitResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelCloseInitResponse;
        encode(_: MsgChannelCloseInitResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgChannelCloseInitResponseAmino): MsgChannelCloseInitResponse;
        fromAminoMsg(object: MsgChannelCloseInitResponseAminoMsg): MsgChannelCloseInitResponse;
        fromPartial(_: {}): MsgChannelCloseInitResponse;
        fromProtoMsg(message: MsgChannelCloseInitResponseProtoMsg): MsgChannelCloseInitResponse;
        toAmino(_: MsgChannelCloseInitResponse): MsgChannelCloseInitResponseAmino;
        toAminoMsg(message: MsgChannelCloseInitResponse): MsgChannelCloseInitResponseAminoMsg;
        toProto(message: MsgChannelCloseInitResponse): Uint8Array;
        toProtoMsg(message: MsgChannelCloseInitResponse): MsgChannelCloseInitResponseProtoMsg;
    };
    MsgChannelOpenAck: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelOpenAck;
        encode(message: MsgChannelOpenAck, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgChannelOpenAckAmino): MsgChannelOpenAck;
        fromAminoMsg(object: MsgChannelOpenAckAminoMsg): MsgChannelOpenAck;
        fromPartial(object: {
            channelId?: string;
            counterpartyChannelId?: string;
            counterpartyVersion?: string;
            portId?: string;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            proofTry?: Uint8Array;
            signer?: string;
        }): MsgChannelOpenAck;
        fromProtoMsg(message: MsgChannelOpenAckProtoMsg): MsgChannelOpenAck;
        toAmino(message: MsgChannelOpenAck): MsgChannelOpenAckAmino;
        toAminoMsg(message: MsgChannelOpenAck): MsgChannelOpenAckAminoMsg;
        toProto(message: MsgChannelOpenAck): Uint8Array;
        toProtoMsg(message: MsgChannelOpenAck): MsgChannelOpenAckProtoMsg;
    };
    MsgChannelOpenAckResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelOpenAckResponse;
        encode(_: MsgChannelOpenAckResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgChannelOpenAckResponseAmino): MsgChannelOpenAckResponse;
        fromAminoMsg(object: MsgChannelOpenAckResponseAminoMsg): MsgChannelOpenAckResponse;
        fromPartial(_: {}): MsgChannelOpenAckResponse;
        fromProtoMsg(message: MsgChannelOpenAckResponseProtoMsg): MsgChannelOpenAckResponse;
        toAmino(_: MsgChannelOpenAckResponse): MsgChannelOpenAckResponseAmino;
        toAminoMsg(message: MsgChannelOpenAckResponse): MsgChannelOpenAckResponseAminoMsg;
        toProto(message: MsgChannelOpenAckResponse): Uint8Array;
        toProtoMsg(message: MsgChannelOpenAckResponse): MsgChannelOpenAckResponseProtoMsg;
    };
    MsgChannelOpenConfirm: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelOpenConfirm;
        encode(message: MsgChannelOpenConfirm, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgChannelOpenConfirmAmino): MsgChannelOpenConfirm;
        fromAminoMsg(object: MsgChannelOpenConfirmAminoMsg): MsgChannelOpenConfirm;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
            proofAck?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            signer?: string;
        }): MsgChannelOpenConfirm;
        fromProtoMsg(message: MsgChannelOpenConfirmProtoMsg): MsgChannelOpenConfirm;
        toAmino(message: MsgChannelOpenConfirm): MsgChannelOpenConfirmAmino;
        toAminoMsg(message: MsgChannelOpenConfirm): MsgChannelOpenConfirmAminoMsg;
        toProto(message: MsgChannelOpenConfirm): Uint8Array;
        toProtoMsg(message: MsgChannelOpenConfirm): MsgChannelOpenConfirmProtoMsg;
    };
    MsgChannelOpenConfirmResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelOpenConfirmResponse;
        encode(_: MsgChannelOpenConfirmResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgChannelOpenConfirmResponseAmino): MsgChannelOpenConfirmResponse;
        fromAminoMsg(object: MsgChannelOpenConfirmResponseAminoMsg): MsgChannelOpenConfirmResponse;
        fromPartial(_: {}): MsgChannelOpenConfirmResponse;
        fromProtoMsg(message: MsgChannelOpenConfirmResponseProtoMsg): MsgChannelOpenConfirmResponse;
        toAmino(_: MsgChannelOpenConfirmResponse): MsgChannelOpenConfirmResponseAmino;
        toAminoMsg(message: MsgChannelOpenConfirmResponse): MsgChannelOpenConfirmResponseAminoMsg;
        toProto(message: MsgChannelOpenConfirmResponse): Uint8Array;
        toProtoMsg(message: MsgChannelOpenConfirmResponse): MsgChannelOpenConfirmResponseProtoMsg;
    };
    MsgChannelOpenInit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelOpenInit;
        encode(message: MsgChannelOpenInit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgChannelOpenInitAmino): MsgChannelOpenInit;
        fromAminoMsg(object: MsgChannelOpenInitAminoMsg): MsgChannelOpenInit;
        fromPartial(object: {
            channel?: {
                connectionHops?: string[];
                counterparty?: {
                    channelId?: string;
                    portId?: string;
                };
                ordering?: Order;
                state?: State;
                version?: string;
            };
            portId?: string;
            signer?: string;
        }): MsgChannelOpenInit;
        fromProtoMsg(message: MsgChannelOpenInitProtoMsg): MsgChannelOpenInit;
        toAmino(message: MsgChannelOpenInit): MsgChannelOpenInitAmino;
        toAminoMsg(message: MsgChannelOpenInit): MsgChannelOpenInitAminoMsg;
        toProto(message: MsgChannelOpenInit): Uint8Array;
        toProtoMsg(message: MsgChannelOpenInit): MsgChannelOpenInitProtoMsg;
    };
    MsgChannelOpenInitResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelOpenInitResponse;
        encode(_: MsgChannelOpenInitResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgChannelOpenInitResponseAmino): MsgChannelOpenInitResponse;
        fromAminoMsg(object: MsgChannelOpenInitResponseAminoMsg): MsgChannelOpenInitResponse;
        fromPartial(_: {}): MsgChannelOpenInitResponse;
        fromProtoMsg(message: MsgChannelOpenInitResponseProtoMsg): MsgChannelOpenInitResponse;
        toAmino(_: MsgChannelOpenInitResponse): MsgChannelOpenInitResponseAmino;
        toAminoMsg(message: MsgChannelOpenInitResponse): MsgChannelOpenInitResponseAminoMsg;
        toProto(message: MsgChannelOpenInitResponse): Uint8Array;
        toProtoMsg(message: MsgChannelOpenInitResponse): MsgChannelOpenInitResponseProtoMsg;
    };
    MsgChannelOpenTry: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelOpenTry;
        encode(message: MsgChannelOpenTry, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgChannelOpenTryAmino): MsgChannelOpenTry;
        fromAminoMsg(object: MsgChannelOpenTryAminoMsg): MsgChannelOpenTry;
        fromPartial(object: {
            channel?: {
                connectionHops?: string[];
                counterparty?: {
                    channelId?: string;
                    portId?: string;
                };
                ordering?: Order;
                state?: State;
                version?: string;
            };
            counterpartyVersion?: string;
            portId?: string;
            previousChannelId?: string;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            proofInit?: Uint8Array;
            signer?: string;
        }): MsgChannelOpenTry;
        fromProtoMsg(message: MsgChannelOpenTryProtoMsg): MsgChannelOpenTry;
        toAmino(message: MsgChannelOpenTry): MsgChannelOpenTryAmino;
        toAminoMsg(message: MsgChannelOpenTry): MsgChannelOpenTryAminoMsg;
        toProto(message: MsgChannelOpenTry): Uint8Array;
        toProtoMsg(message: MsgChannelOpenTry): MsgChannelOpenTryProtoMsg;
    };
    MsgChannelOpenTryResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgChannelOpenTryResponse;
        encode(_: MsgChannelOpenTryResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgChannelOpenTryResponseAmino): MsgChannelOpenTryResponse;
        fromAminoMsg(object: MsgChannelOpenTryResponseAminoMsg): MsgChannelOpenTryResponse;
        fromPartial(_: {}): MsgChannelOpenTryResponse;
        fromProtoMsg(message: MsgChannelOpenTryResponseProtoMsg): MsgChannelOpenTryResponse;
        toAmino(_: MsgChannelOpenTryResponse): MsgChannelOpenTryResponseAmino;
        toAminoMsg(message: MsgChannelOpenTryResponse): MsgChannelOpenTryResponseAminoMsg;
        toProto(message: MsgChannelOpenTryResponse): Uint8Array;
        toProtoMsg(message: MsgChannelOpenTryResponse): MsgChannelOpenTryResponseProtoMsg;
    };
    MsgRecvPacket: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgRecvPacket;
        encode(message: MsgRecvPacket, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgRecvPacketAmino): MsgRecvPacket;
        fromAminoMsg(object: MsgRecvPacketAminoMsg): MsgRecvPacket;
        fromPartial(object: {
            packet?: {
                data?: Uint8Array;
                destinationChannel?: string;
                destinationPort?: string;
                sequence?: bigint;
                sourceChannel?: string;
                sourcePort?: string;
                timeoutHeight?: {
                    revisionHeight?: bigint;
                    revisionNumber?: bigint;
                };
                timeoutTimestamp?: bigint;
            };
            proofCommitment?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            signer?: string;
        }): MsgRecvPacket;
        fromProtoMsg(message: MsgRecvPacketProtoMsg): MsgRecvPacket;
        toAmino(message: MsgRecvPacket): MsgRecvPacketAmino;
        toAminoMsg(message: MsgRecvPacket): MsgRecvPacketAminoMsg;
        toProto(message: MsgRecvPacket): Uint8Array;
        toProtoMsg(message: MsgRecvPacket): MsgRecvPacketProtoMsg;
    };
    MsgRecvPacketResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgRecvPacketResponse;
        encode(_: MsgRecvPacketResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgRecvPacketResponseAmino): MsgRecvPacketResponse;
        fromAminoMsg(object: MsgRecvPacketResponseAminoMsg): MsgRecvPacketResponse;
        fromPartial(_: {}): MsgRecvPacketResponse;
        fromProtoMsg(message: MsgRecvPacketResponseProtoMsg): MsgRecvPacketResponse;
        toAmino(_: MsgRecvPacketResponse): MsgRecvPacketResponseAmino;
        toAminoMsg(message: MsgRecvPacketResponse): MsgRecvPacketResponseAminoMsg;
        toProto(message: MsgRecvPacketResponse): Uint8Array;
        toProtoMsg(message: MsgRecvPacketResponse): MsgRecvPacketResponseProtoMsg;
    };
    MsgTimeout: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgTimeout;
        encode(message: MsgTimeout, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgTimeoutAmino): MsgTimeout;
        fromAminoMsg(object: MsgTimeoutAminoMsg): MsgTimeout;
        fromPartial(object: {
            nextSequenceRecv?: bigint;
            packet?: {
                data?: Uint8Array;
                destinationChannel?: string;
                destinationPort?: string;
                sequence?: bigint;
                sourceChannel?: string;
                sourcePort?: string;
                timeoutHeight?: {
                    revisionHeight?: bigint;
                    revisionNumber?: bigint;
                };
                timeoutTimestamp?: bigint;
            };
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            proofUnreceived?: Uint8Array;
            signer?: string;
        }): MsgTimeout;
        fromProtoMsg(message: MsgTimeoutProtoMsg): MsgTimeout;
        toAmino(message: MsgTimeout): MsgTimeoutAmino;
        toAminoMsg(message: MsgTimeout): MsgTimeoutAminoMsg;
        toProto(message: MsgTimeout): Uint8Array;
        toProtoMsg(message: MsgTimeout): MsgTimeoutProtoMsg;
    };
    MsgTimeoutOnClose: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgTimeoutOnClose;
        encode(message: MsgTimeoutOnClose, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgTimeoutOnCloseAmino): MsgTimeoutOnClose;
        fromAminoMsg(object: MsgTimeoutOnCloseAminoMsg): MsgTimeoutOnClose;
        fromPartial(object: {
            nextSequenceRecv?: bigint;
            packet?: {
                data?: Uint8Array;
                destinationChannel?: string;
                destinationPort?: string;
                sequence?: bigint;
                sourceChannel?: string;
                sourcePort?: string;
                timeoutHeight?: {
                    revisionHeight?: bigint;
                    revisionNumber?: bigint;
                };
                timeoutTimestamp?: bigint;
            };
            proofClose?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            proofUnreceived?: Uint8Array;
            signer?: string;
        }): MsgTimeoutOnClose;
        fromProtoMsg(message: MsgTimeoutOnCloseProtoMsg): MsgTimeoutOnClose;
        toAmino(message: MsgTimeoutOnClose): MsgTimeoutOnCloseAmino;
        toAminoMsg(message: MsgTimeoutOnClose): MsgTimeoutOnCloseAminoMsg;
        toProto(message: MsgTimeoutOnClose): Uint8Array;
        toProtoMsg(message: MsgTimeoutOnClose): MsgTimeoutOnCloseProtoMsg;
    };
    MsgTimeoutOnCloseResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgTimeoutOnCloseResponse;
        encode(_: MsgTimeoutOnCloseResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgTimeoutOnCloseResponseAmino): MsgTimeoutOnCloseResponse;
        fromAminoMsg(object: MsgTimeoutOnCloseResponseAminoMsg): MsgTimeoutOnCloseResponse;
        fromPartial(_: {}): MsgTimeoutOnCloseResponse;
        fromProtoMsg(message: MsgTimeoutOnCloseResponseProtoMsg): MsgTimeoutOnCloseResponse;
        toAmino(_: MsgTimeoutOnCloseResponse): MsgTimeoutOnCloseResponseAmino;
        toAminoMsg(message: MsgTimeoutOnCloseResponse): MsgTimeoutOnCloseResponseAminoMsg;
        toProto(message: MsgTimeoutOnCloseResponse): Uint8Array;
        toProtoMsg(message: MsgTimeoutOnCloseResponse): MsgTimeoutOnCloseResponseProtoMsg;
    };
    MsgTimeoutResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgTimeoutResponse;
        encode(_: MsgTimeoutResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgTimeoutResponseAmino): MsgTimeoutResponse;
        fromAminoMsg(object: MsgTimeoutResponseAminoMsg): MsgTimeoutResponse;
        fromPartial(_: {}): MsgTimeoutResponse;
        fromProtoMsg(message: MsgTimeoutResponseProtoMsg): MsgTimeoutResponse;
        toAmino(_: MsgTimeoutResponse): MsgTimeoutResponseAmino;
        toAminoMsg(message: MsgTimeoutResponse): MsgTimeoutResponseAminoMsg;
        toProto(message: MsgTimeoutResponse): Uint8Array;
        toProtoMsg(message: MsgTimeoutResponse): MsgTimeoutResponseProtoMsg;
    };
    OrderAmino: typeof Order;
    OrderSDKType: typeof Order;
    Packet: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Packet;
        encode(message: Packet, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PacketAmino): Packet;
        fromAminoMsg(object: PacketAminoMsg): Packet;
        fromPartial(object: {
            data?: Uint8Array;
            destinationChannel?: string;
            destinationPort?: string;
            sequence?: bigint;
            sourceChannel?: string;
            sourcePort?: string;
            timeoutHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            timeoutTimestamp?: bigint;
        }): Packet;
        fromProtoMsg(message: PacketProtoMsg): Packet;
        toAmino(message: Packet): PacketAmino;
        toAminoMsg(message: Packet): PacketAminoMsg;
        toProto(message: Packet): Uint8Array;
        toProtoMsg(message: Packet): PacketProtoMsg;
    };
    PacketSequence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): PacketSequence;
        encode(message: PacketSequence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PacketSequenceAmino): PacketSequence;
        fromAminoMsg(object: PacketSequenceAminoMsg): PacketSequence;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
            sequence?: bigint;
        }): PacketSequence;
        fromProtoMsg(message: PacketSequenceProtoMsg): PacketSequence;
        toAmino(message: PacketSequence): PacketSequenceAmino;
        toAminoMsg(message: PacketSequence): PacketSequenceAminoMsg;
        toProto(message: PacketSequence): Uint8Array;
        toProtoMsg(message: PacketSequence): PacketSequenceProtoMsg;
    };
    PacketState: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): PacketState;
        encode(message: PacketState, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PacketStateAmino): PacketState;
        fromAminoMsg(object: PacketStateAminoMsg): PacketState;
        fromPartial(object: {
            channelId?: string;
            data?: Uint8Array;
            portId?: string;
            sequence?: bigint;
        }): PacketState;
        fromProtoMsg(message: PacketStateProtoMsg): PacketState;
        toAmino(message: PacketState): PacketStateAmino;
        toAminoMsg(message: PacketState): PacketStateAminoMsg;
        toProto(message: PacketState): Uint8Array;
        toProtoMsg(message: PacketState): PacketStateProtoMsg;
    };
    QueryChannelClientStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryChannelClientStateRequest;
        encode(message: QueryChannelClientStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryChannelClientStateRequestAmino): QueryChannelClientStateRequest;
        fromAminoMsg(object: QueryChannelClientStateRequestAminoMsg): QueryChannelClientStateRequest;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
        }): QueryChannelClientStateRequest;
        fromProtoMsg(message: QueryChannelClientStateRequestProtoMsg): QueryChannelClientStateRequest;
        toAmino(message: QueryChannelClientStateRequest): QueryChannelClientStateRequestAmino;
        toAminoMsg(message: QueryChannelClientStateRequest): QueryChannelClientStateRequestAminoMsg;
        toProto(message: QueryChannelClientStateRequest): Uint8Array;
        toProtoMsg(message: QueryChannelClientStateRequest): QueryChannelClientStateRequestProtoMsg;
    };
    QueryChannelClientStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryChannelClientStateResponse;
        encode(message: QueryChannelClientStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryChannelClientStateResponseAmino): QueryChannelClientStateResponse;
        fromAminoMsg(object: QueryChannelClientStateResponseAminoMsg): QueryChannelClientStateResponse;
        fromPartial(object: {
            identifiedClientState?: {
                clientId?: string;
                clientState?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
            };
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryChannelClientStateResponse;
        fromProtoMsg(message: QueryChannelClientStateResponseProtoMsg): QueryChannelClientStateResponse;
        toAmino(message: QueryChannelClientStateResponse): QueryChannelClientStateResponseAmino;
        toAminoMsg(message: QueryChannelClientStateResponse): QueryChannelClientStateResponseAminoMsg;
        toProto(message: QueryChannelClientStateResponse): Uint8Array;
        toProtoMsg(message: QueryChannelClientStateResponse): QueryChannelClientStateResponseProtoMsg;
    };
    QueryChannelConsensusStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryChannelConsensusStateRequest;
        encode(message: QueryChannelConsensusStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryChannelConsensusStateRequestAmino): QueryChannelConsensusStateRequest;
        fromAminoMsg(object: QueryChannelConsensusStateRequestAminoMsg): QueryChannelConsensusStateRequest;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
            revisionHeight?: bigint;
            revisionNumber?: bigint;
        }): QueryChannelConsensusStateRequest;
        fromProtoMsg(message: QueryChannelConsensusStateRequestProtoMsg): QueryChannelConsensusStateRequest;
        toAmino(message: QueryChannelConsensusStateRequest): QueryChannelConsensusStateRequestAmino;
        toAminoMsg(message: QueryChannelConsensusStateRequest): QueryChannelConsensusStateRequestAminoMsg;
        toProto(message: QueryChannelConsensusStateRequest): Uint8Array;
        toProtoMsg(message: QueryChannelConsensusStateRequest): QueryChannelConsensusStateRequestProtoMsg;
    };
    QueryChannelConsensusStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryChannelConsensusStateResponse;
        encode(message: QueryChannelConsensusStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryChannelConsensusStateResponseAmino): QueryChannelConsensusStateResponse;
        fromAminoMsg(object: QueryChannelConsensusStateResponseAminoMsg): QueryChannelConsensusStateResponse;
        fromPartial(object: {
            clientId?: string;
            consensusState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryChannelConsensusStateResponse;
        fromProtoMsg(message: QueryChannelConsensusStateResponseProtoMsg): QueryChannelConsensusStateResponse;
        toAmino(message: QueryChannelConsensusStateResponse): QueryChannelConsensusStateResponseAmino;
        toAminoMsg(message: QueryChannelConsensusStateResponse): QueryChannelConsensusStateResponseAminoMsg;
        toProto(message: QueryChannelConsensusStateResponse): Uint8Array;
        toProtoMsg(message: QueryChannelConsensusStateResponse): QueryChannelConsensusStateResponseProtoMsg;
    };
    QueryChannelRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryChannelRequest;
        encode(message: QueryChannelRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryChannelRequestAmino): QueryChannelRequest;
        fromAminoMsg(object: QueryChannelRequestAminoMsg): QueryChannelRequest;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
        }): QueryChannelRequest;
        fromProtoMsg(message: QueryChannelRequestProtoMsg): QueryChannelRequest;
        toAmino(message: QueryChannelRequest): QueryChannelRequestAmino;
        toAminoMsg(message: QueryChannelRequest): QueryChannelRequestAminoMsg;
        toProto(message: QueryChannelRequest): Uint8Array;
        toProtoMsg(message: QueryChannelRequest): QueryChannelRequestProtoMsg;
    };
    QueryChannelResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryChannelResponse;
        encode(message: QueryChannelResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryChannelResponseAmino): QueryChannelResponse;
        fromAminoMsg(object: QueryChannelResponseAminoMsg): QueryChannelResponse;
        fromPartial(object: {
            channel?: {
                connectionHops?: string[];
                counterparty?: {
                    channelId?: string;
                    portId?: string;
                };
                ordering?: Order;
                state?: State;
                version?: string;
            };
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryChannelResponse;
        fromProtoMsg(message: QueryChannelResponseProtoMsg): QueryChannelResponse;
        toAmino(message: QueryChannelResponse): QueryChannelResponseAmino;
        toAminoMsg(message: QueryChannelResponse): QueryChannelResponseAminoMsg;
        toProto(message: QueryChannelResponse): Uint8Array;
        toProtoMsg(message: QueryChannelResponse): QueryChannelResponseProtoMsg;
    };
    QueryChannelsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryChannelsRequest;
        encode(message: QueryChannelsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryChannelsRequestAmino): QueryChannelsRequest;
        fromAminoMsg(object: QueryChannelsRequestAminoMsg): QueryChannelsRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryChannelsRequest;
        fromProtoMsg(message: QueryChannelsRequestProtoMsg): QueryChannelsRequest;
        toAmino(message: QueryChannelsRequest): QueryChannelsRequestAmino;
        toAminoMsg(message: QueryChannelsRequest): QueryChannelsRequestAminoMsg;
        toProto(message: QueryChannelsRequest): Uint8Array;
        toProtoMsg(message: QueryChannelsRequest): QueryChannelsRequestProtoMsg;
    };
    QueryChannelsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryChannelsResponse;
        encode(message: QueryChannelsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryChannelsResponseAmino): QueryChannelsResponse;
        fromAminoMsg(object: QueryChannelsResponseAminoMsg): QueryChannelsResponse;
        fromPartial(object: {
            channels?: {
                channelId?: string;
                connectionHops?: string[];
                counterparty?: {
                    channelId?: string;
                    portId?: string;
                };
                ordering?: Order;
                portId?: string;
                state?: State;
                version?: string;
            }[];
            height?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryChannelsResponse;
        fromProtoMsg(message: QueryChannelsResponseProtoMsg): QueryChannelsResponse;
        toAmino(message: QueryChannelsResponse): QueryChannelsResponseAmino;
        toAminoMsg(message: QueryChannelsResponse): QueryChannelsResponseAminoMsg;
        toProto(message: QueryChannelsResponse): Uint8Array;
        toProtoMsg(message: QueryChannelsResponse): QueryChannelsResponseProtoMsg;
    };
    QueryConnectionChannelsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionChannelsRequest;
        encode(message: QueryConnectionChannelsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionChannelsRequestAmino): QueryConnectionChannelsRequest;
        fromAminoMsg(object: QueryConnectionChannelsRequestAminoMsg): QueryConnectionChannelsRequest;
        fromPartial(object: {
            connection?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryConnectionChannelsRequest;
        fromProtoMsg(message: QueryConnectionChannelsRequestProtoMsg): QueryConnectionChannelsRequest;
        toAmino(message: QueryConnectionChannelsRequest): QueryConnectionChannelsRequestAmino;
        toAminoMsg(message: QueryConnectionChannelsRequest): QueryConnectionChannelsRequestAminoMsg;
        toProto(message: QueryConnectionChannelsRequest): Uint8Array;
        toProtoMsg(message: QueryConnectionChannelsRequest): QueryConnectionChannelsRequestProtoMsg;
    };
    QueryConnectionChannelsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryConnectionChannelsResponse;
        encode(message: QueryConnectionChannelsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryConnectionChannelsResponseAmino): QueryConnectionChannelsResponse;
        fromAminoMsg(object: QueryConnectionChannelsResponseAminoMsg): QueryConnectionChannelsResponse;
        fromPartial(object: {
            channels?: {
                channelId?: string;
                connectionHops?: string[];
                counterparty?: {
                    channelId?: string;
                    portId?: string;
                };
                ordering?: Order;
                portId?: string;
                state?: State;
                version?: string;
            }[];
            height?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryConnectionChannelsResponse;
        fromProtoMsg(message: QueryConnectionChannelsResponseProtoMsg): QueryConnectionChannelsResponse;
        toAmino(message: QueryConnectionChannelsResponse): QueryConnectionChannelsResponseAmino;
        toAminoMsg(message: QueryConnectionChannelsResponse): QueryConnectionChannelsResponseAminoMsg;
        toProto(message: QueryConnectionChannelsResponse): Uint8Array;
        toProtoMsg(message: QueryConnectionChannelsResponse): QueryConnectionChannelsResponseProtoMsg;
    };
    QueryNextSequenceReceiveRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryNextSequenceReceiveRequest;
        encode(message: QueryNextSequenceReceiveRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryNextSequenceReceiveRequestAmino): QueryNextSequenceReceiveRequest;
        fromAminoMsg(object: QueryNextSequenceReceiveRequestAminoMsg): QueryNextSequenceReceiveRequest;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
        }): QueryNextSequenceReceiveRequest;
        fromProtoMsg(message: QueryNextSequenceReceiveRequestProtoMsg): QueryNextSequenceReceiveRequest;
        toAmino(message: QueryNextSequenceReceiveRequest): QueryNextSequenceReceiveRequestAmino;
        toAminoMsg(message: QueryNextSequenceReceiveRequest): QueryNextSequenceReceiveRequestAminoMsg;
        toProto(message: QueryNextSequenceReceiveRequest): Uint8Array;
        toProtoMsg(message: QueryNextSequenceReceiveRequest): QueryNextSequenceReceiveRequestProtoMsg;
    };
    QueryNextSequenceReceiveResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryNextSequenceReceiveResponse;
        encode(message: QueryNextSequenceReceiveResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryNextSequenceReceiveResponseAmino): QueryNextSequenceReceiveResponse;
        fromAminoMsg(object: QueryNextSequenceReceiveResponseAminoMsg): QueryNextSequenceReceiveResponse;
        fromPartial(object: {
            nextSequenceReceive?: bigint;
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryNextSequenceReceiveResponse;
        fromProtoMsg(message: QueryNextSequenceReceiveResponseProtoMsg): QueryNextSequenceReceiveResponse;
        toAmino(message: QueryNextSequenceReceiveResponse): QueryNextSequenceReceiveResponseAmino;
        toAminoMsg(message: QueryNextSequenceReceiveResponse): QueryNextSequenceReceiveResponseAminoMsg;
        toProto(message: QueryNextSequenceReceiveResponse): Uint8Array;
        toProtoMsg(message: QueryNextSequenceReceiveResponse): QueryNextSequenceReceiveResponseProtoMsg;
    };
    QueryPacketAcknowledgementRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketAcknowledgementRequest;
        encode(message: QueryPacketAcknowledgementRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketAcknowledgementRequestAmino): QueryPacketAcknowledgementRequest;
        fromAminoMsg(object: QueryPacketAcknowledgementRequestAminoMsg): QueryPacketAcknowledgementRequest;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
            sequence?: bigint;
        }): QueryPacketAcknowledgementRequest;
        fromProtoMsg(message: QueryPacketAcknowledgementRequestProtoMsg): QueryPacketAcknowledgementRequest;
        toAmino(message: QueryPacketAcknowledgementRequest): QueryPacketAcknowledgementRequestAmino;
        toAminoMsg(message: QueryPacketAcknowledgementRequest): QueryPacketAcknowledgementRequestAminoMsg;
        toProto(message: QueryPacketAcknowledgementRequest): Uint8Array;
        toProtoMsg(message: QueryPacketAcknowledgementRequest): QueryPacketAcknowledgementRequestProtoMsg;
    };
    QueryPacketAcknowledgementResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketAcknowledgementResponse;
        encode(message: QueryPacketAcknowledgementResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketAcknowledgementResponseAmino): QueryPacketAcknowledgementResponse;
        fromAminoMsg(object: QueryPacketAcknowledgementResponseAminoMsg): QueryPacketAcknowledgementResponse;
        fromPartial(object: {
            acknowledgement?: Uint8Array;
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryPacketAcknowledgementResponse;
        fromProtoMsg(message: QueryPacketAcknowledgementResponseProtoMsg): QueryPacketAcknowledgementResponse;
        toAmino(message: QueryPacketAcknowledgementResponse): QueryPacketAcknowledgementResponseAmino;
        toAminoMsg(message: QueryPacketAcknowledgementResponse): QueryPacketAcknowledgementResponseAminoMsg;
        toProto(message: QueryPacketAcknowledgementResponse): Uint8Array;
        toProtoMsg(message: QueryPacketAcknowledgementResponse): QueryPacketAcknowledgementResponseProtoMsg;
    };
    QueryPacketAcknowledgementsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketAcknowledgementsRequest;
        encode(message: QueryPacketAcknowledgementsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketAcknowledgementsRequestAmino): QueryPacketAcknowledgementsRequest;
        fromAminoMsg(object: QueryPacketAcknowledgementsRequestAminoMsg): QueryPacketAcknowledgementsRequest;
        fromPartial(object: {
            channelId?: string;
            packetCommitmentSequences?: bigint[];
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            portId?: string;
        }): QueryPacketAcknowledgementsRequest;
        fromProtoMsg(message: QueryPacketAcknowledgementsRequestProtoMsg): QueryPacketAcknowledgementsRequest;
        toAmino(message: QueryPacketAcknowledgementsRequest): QueryPacketAcknowledgementsRequestAmino;
        toAminoMsg(message: QueryPacketAcknowledgementsRequest): QueryPacketAcknowledgementsRequestAminoMsg;
        toProto(message: QueryPacketAcknowledgementsRequest): Uint8Array;
        toProtoMsg(message: QueryPacketAcknowledgementsRequest): QueryPacketAcknowledgementsRequestProtoMsg;
    };
    QueryPacketAcknowledgementsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketAcknowledgementsResponse;
        encode(message: QueryPacketAcknowledgementsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketAcknowledgementsResponseAmino): QueryPacketAcknowledgementsResponse;
        fromAminoMsg(object: QueryPacketAcknowledgementsResponseAminoMsg): QueryPacketAcknowledgementsResponse;
        fromPartial(object: {
            acknowledgements?: {
                channelId?: string;
                data?: Uint8Array;
                portId?: string;
                sequence?: bigint;
            }[];
            height?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryPacketAcknowledgementsResponse;
        fromProtoMsg(message: QueryPacketAcknowledgementsResponseProtoMsg): QueryPacketAcknowledgementsResponse;
        toAmino(message: QueryPacketAcknowledgementsResponse): QueryPacketAcknowledgementsResponseAmino;
        toAminoMsg(message: QueryPacketAcknowledgementsResponse): QueryPacketAcknowledgementsResponseAminoMsg;
        toProto(message: QueryPacketAcknowledgementsResponse): Uint8Array;
        toProtoMsg(message: QueryPacketAcknowledgementsResponse): QueryPacketAcknowledgementsResponseProtoMsg;
    };
    QueryPacketCommitmentRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketCommitmentRequest;
        encode(message: QueryPacketCommitmentRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketCommitmentRequestAmino): QueryPacketCommitmentRequest;
        fromAminoMsg(object: QueryPacketCommitmentRequestAminoMsg): QueryPacketCommitmentRequest;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
            sequence?: bigint;
        }): QueryPacketCommitmentRequest;
        fromProtoMsg(message: QueryPacketCommitmentRequestProtoMsg): QueryPacketCommitmentRequest;
        toAmino(message: QueryPacketCommitmentRequest): QueryPacketCommitmentRequestAmino;
        toAminoMsg(message: QueryPacketCommitmentRequest): QueryPacketCommitmentRequestAminoMsg;
        toProto(message: QueryPacketCommitmentRequest): Uint8Array;
        toProtoMsg(message: QueryPacketCommitmentRequest): QueryPacketCommitmentRequestProtoMsg;
    };
    QueryPacketCommitmentResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketCommitmentResponse;
        encode(message: QueryPacketCommitmentResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketCommitmentResponseAmino): QueryPacketCommitmentResponse;
        fromAminoMsg(object: QueryPacketCommitmentResponseAminoMsg): QueryPacketCommitmentResponse;
        fromPartial(object: {
            commitment?: Uint8Array;
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
        }): QueryPacketCommitmentResponse;
        fromProtoMsg(message: QueryPacketCommitmentResponseProtoMsg): QueryPacketCommitmentResponse;
        toAmino(message: QueryPacketCommitmentResponse): QueryPacketCommitmentResponseAmino;
        toAminoMsg(message: QueryPacketCommitmentResponse): QueryPacketCommitmentResponseAminoMsg;
        toProto(message: QueryPacketCommitmentResponse): Uint8Array;
        toProtoMsg(message: QueryPacketCommitmentResponse): QueryPacketCommitmentResponseProtoMsg;
    };
    QueryPacketCommitmentsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketCommitmentsRequest;
        encode(message: QueryPacketCommitmentsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketCommitmentsRequestAmino): QueryPacketCommitmentsRequest;
        fromAminoMsg(object: QueryPacketCommitmentsRequestAminoMsg): QueryPacketCommitmentsRequest;
        fromPartial(object: {
            channelId?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
            portId?: string;
        }): QueryPacketCommitmentsRequest;
        fromProtoMsg(message: QueryPacketCommitmentsRequestProtoMsg): QueryPacketCommitmentsRequest;
        toAmino(message: QueryPacketCommitmentsRequest): QueryPacketCommitmentsRequestAmino;
        toAminoMsg(message: QueryPacketCommitmentsRequest): QueryPacketCommitmentsRequestAminoMsg;
        toProto(message: QueryPacketCommitmentsRequest): Uint8Array;
        toProtoMsg(message: QueryPacketCommitmentsRequest): QueryPacketCommitmentsRequestProtoMsg;
    };
    QueryPacketCommitmentsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketCommitmentsResponse;
        encode(message: QueryPacketCommitmentsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketCommitmentsResponseAmino): QueryPacketCommitmentsResponse;
        fromAminoMsg(object: QueryPacketCommitmentsResponseAminoMsg): QueryPacketCommitmentsResponse;
        fromPartial(object: {
            commitments?: {
                channelId?: string;
                data?: Uint8Array;
                portId?: string;
                sequence?: bigint;
            }[];
            height?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryPacketCommitmentsResponse;
        fromProtoMsg(message: QueryPacketCommitmentsResponseProtoMsg): QueryPacketCommitmentsResponse;
        toAmino(message: QueryPacketCommitmentsResponse): QueryPacketCommitmentsResponseAmino;
        toAminoMsg(message: QueryPacketCommitmentsResponse): QueryPacketCommitmentsResponseAminoMsg;
        toProto(message: QueryPacketCommitmentsResponse): Uint8Array;
        toProtoMsg(message: QueryPacketCommitmentsResponse): QueryPacketCommitmentsResponseProtoMsg;
    };
    QueryPacketReceiptRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketReceiptRequest;
        encode(message: QueryPacketReceiptRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketReceiptRequestAmino): QueryPacketReceiptRequest;
        fromAminoMsg(object: QueryPacketReceiptRequestAminoMsg): QueryPacketReceiptRequest;
        fromPartial(object: {
            channelId?: string;
            portId?: string;
            sequence?: bigint;
        }): QueryPacketReceiptRequest;
        fromProtoMsg(message: QueryPacketReceiptRequestProtoMsg): QueryPacketReceiptRequest;
        toAmino(message: QueryPacketReceiptRequest): QueryPacketReceiptRequestAmino;
        toAminoMsg(message: QueryPacketReceiptRequest): QueryPacketReceiptRequestAminoMsg;
        toProto(message: QueryPacketReceiptRequest): Uint8Array;
        toProtoMsg(message: QueryPacketReceiptRequest): QueryPacketReceiptRequestProtoMsg;
    };
    QueryPacketReceiptResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPacketReceiptResponse;
        encode(message: QueryPacketReceiptResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPacketReceiptResponseAmino): QueryPacketReceiptResponse;
        fromAminoMsg(object: QueryPacketReceiptResponseAminoMsg): QueryPacketReceiptResponse;
        fromPartial(object: {
            proof?: Uint8Array;
            proofHeight?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            received?: boolean;
        }): QueryPacketReceiptResponse;
        fromProtoMsg(message: QueryPacketReceiptResponseProtoMsg): QueryPacketReceiptResponse;
        toAmino(message: QueryPacketReceiptResponse): QueryPacketReceiptResponseAmino;
        toAminoMsg(message: QueryPacketReceiptResponse): QueryPacketReceiptResponseAminoMsg;
        toProto(message: QueryPacketReceiptResponse): Uint8Array;
        toProtoMsg(message: QueryPacketReceiptResponse): QueryPacketReceiptResponseProtoMsg;
    };
    QueryUnreceivedAcksRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUnreceivedAcksRequest;
        encode(message: QueryUnreceivedAcksRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryUnreceivedAcksRequestAmino): QueryUnreceivedAcksRequest;
        fromAminoMsg(object: QueryUnreceivedAcksRequestAminoMsg): QueryUnreceivedAcksRequest;
        fromPartial(object: {
            channelId?: string;
            packetAckSequences?: bigint[];
            portId?: string;
        }): QueryUnreceivedAcksRequest;
        fromProtoMsg(message: QueryUnreceivedAcksRequestProtoMsg): QueryUnreceivedAcksRequest;
        toAmino(message: QueryUnreceivedAcksRequest): QueryUnreceivedAcksRequestAmino;
        toAminoMsg(message: QueryUnreceivedAcksRequest): QueryUnreceivedAcksRequestAminoMsg;
        toProto(message: QueryUnreceivedAcksRequest): Uint8Array;
        toProtoMsg(message: QueryUnreceivedAcksRequest): QueryUnreceivedAcksRequestProtoMsg;
    };
    QueryUnreceivedAcksResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUnreceivedAcksResponse;
        encode(message: QueryUnreceivedAcksResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryUnreceivedAcksResponseAmino): QueryUnreceivedAcksResponse;
        fromAminoMsg(object: QueryUnreceivedAcksResponseAminoMsg): QueryUnreceivedAcksResponse;
        fromPartial(object: {
            height?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            sequences?: bigint[];
        }): QueryUnreceivedAcksResponse;
        fromProtoMsg(message: QueryUnreceivedAcksResponseProtoMsg): QueryUnreceivedAcksResponse;
        toAmino(message: QueryUnreceivedAcksResponse): QueryUnreceivedAcksResponseAmino;
        toAminoMsg(message: QueryUnreceivedAcksResponse): QueryUnreceivedAcksResponseAminoMsg;
        toProto(message: QueryUnreceivedAcksResponse): Uint8Array;
        toProtoMsg(message: QueryUnreceivedAcksResponse): QueryUnreceivedAcksResponseProtoMsg;
    };
    QueryUnreceivedPacketsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUnreceivedPacketsRequest;
        encode(message: QueryUnreceivedPacketsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryUnreceivedPacketsRequestAmino): QueryUnreceivedPacketsRequest;
        fromAminoMsg(object: QueryUnreceivedPacketsRequestAminoMsg): QueryUnreceivedPacketsRequest;
        fromPartial(object: {
            channelId?: string;
            packetCommitmentSequences?: bigint[];
            portId?: string;
        }): QueryUnreceivedPacketsRequest;
        fromProtoMsg(message: QueryUnreceivedPacketsRequestProtoMsg): QueryUnreceivedPacketsRequest;
        toAmino(message: QueryUnreceivedPacketsRequest): QueryUnreceivedPacketsRequestAmino;
        toAminoMsg(message: QueryUnreceivedPacketsRequest): QueryUnreceivedPacketsRequestAminoMsg;
        toProto(message: QueryUnreceivedPacketsRequest): Uint8Array;
        toProtoMsg(message: QueryUnreceivedPacketsRequest): QueryUnreceivedPacketsRequestProtoMsg;
    };
    QueryUnreceivedPacketsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryUnreceivedPacketsResponse;
        encode(message: QueryUnreceivedPacketsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryUnreceivedPacketsResponseAmino): QueryUnreceivedPacketsResponse;
        fromAminoMsg(object: QueryUnreceivedPacketsResponseAminoMsg): QueryUnreceivedPacketsResponse;
        fromPartial(object: {
            height?: {
                revisionHeight?: bigint;
                revisionNumber?: bigint;
            };
            sequences?: bigint[];
        }): QueryUnreceivedPacketsResponse;
        fromProtoMsg(message: QueryUnreceivedPacketsResponseProtoMsg): QueryUnreceivedPacketsResponse;
        toAmino(message: QueryUnreceivedPacketsResponse): QueryUnreceivedPacketsResponseAmino;
        toAminoMsg(message: QueryUnreceivedPacketsResponse): QueryUnreceivedPacketsResponseAminoMsg;
        toProto(message: QueryUnreceivedPacketsResponse): Uint8Array;
        toProtoMsg(message: QueryUnreceivedPacketsResponse): QueryUnreceivedPacketsResponseProtoMsg;
    };
    StateAmino: typeof State;
    StateSDKType: typeof State;
    createRpcQueryExtension: ((base: QueryClient) => {
        channel(request: QueryChannelRequest): Promise<QueryChannelResponse>;
        channelClientState(request: QueryChannelClientStateRequest): Promise<QueryChannelClientStateResponse>;
        channelConsensusState(request: QueryChannelConsensusStateRequest): Promise<QueryChannelConsensusStateResponse>;
        channels(request?: QueryChannelsRequest): Promise<QueryChannelsResponse>;
        connectionChannels(request: QueryConnectionChannelsRequest): Promise<QueryConnectionChannelsResponse>;
        nextSequenceReceive(request: QueryNextSequenceReceiveRequest): Promise<QueryNextSequenceReceiveResponse>;
        packetAcknowledgement(request: QueryPacketAcknowledgementRequest): Promise<QueryPacketAcknowledgementResponse>;
        packetAcknowledgements(request: QueryPacketAcknowledgementsRequest): Promise<QueryPacketAcknowledgementsResponse>;
        packetCommitment(request: QueryPacketCommitmentRequest): Promise<QueryPacketCommitmentResponse>;
        packetCommitments(request: QueryPacketCommitmentsRequest): Promise<QueryPacketCommitmentsResponse>;
        packetReceipt(request: QueryPacketReceiptRequest): Promise<QueryPacketReceiptResponse>;
        unreceivedAcks(request: QueryUnreceivedAcksRequest): Promise<QueryUnreceivedAcksResponse>;
        unreceivedPackets(request: QueryUnreceivedPacketsRequest): Promise<QueryUnreceivedPacketsResponse>;
    });
    load: ((protoRegistry: Registry) => void);
    registry: readonly [string, TelescopeGeneratedType<any, any, any>][];
    orderFromJSON(object: any): Order;
    orderToJSON(object: Order): string;
    stateFromJSON(object: any): State;
    stateToJSON(object: State): string;
} = ...