import * as _106 from "./applications/transfer/v1/genesis";
import * as _107 from "./applications/transfer/v1/query";
import * as _108 from "./applications/transfer/v1/transfer";
import * as _109 from "./applications/transfer/v1/tx";
import * as _110 from "./applications/transfer/v2/packet";
import * as _111 from "./core/channel/v1/channel";
import * as _112 from "./core/channel/v1/genesis";
import * as _113 from "./core/channel/v1/query";
import * as _114 from "./core/channel/v1/tx";
import * as _115 from "./core/client/v1/client";
import * as _116 from "./core/client/v1/genesis";
import * as _117 from "./core/client/v1/query";
import * as _118 from "./core/client/v1/tx";
import * as _119 from "./core/commitment/v1/commitment";
import * as _120 from "./core/connection/v1/connection";
import * as _121 from "./core/connection/v1/genesis";
import * as _122 from "./core/connection/v1/query";
import * as _123 from "./core/connection/v1/tx";
import * as _124 from "./lightclients/localhost/v1/localhost";
import * as _125 from "./lightclients/solomachine/v1/solomachine";
import * as _126 from "./lightclients/solomachine/v2/solomachine";
import * as _127 from "./lightclients/tendermint/v1/tendermint";
import * as _246 from "./applications/transfer/v1/query.lcd";
import * as _247 from "./core/channel/v1/query.lcd";
import * as _248 from "./core/client/v1/query.lcd";
import * as _249 from "./core/connection/v1/query.lcd";
import * as _250 from "./applications/transfer/v1/query.rpc.Query";
import * as _251 from "./core/channel/v1/query.rpc.Query";
import * as _252 from "./core/client/v1/query.rpc.Query";
import * as _253 from "./core/connection/v1/query.rpc.Query";
import * as _254 from "./applications/transfer/v1/tx.rpc.msg";
import * as _255 from "./core/channel/v1/tx.rpc.msg";
import * as _256 from "./core/client/v1/tx.rpc.msg";
import * as _257 from "./core/connection/v1/tx.rpc.msg";
export declare namespace ibc {
    namespace applications {
        namespace transfer {
            const v1: {
                MsgClientImpl: typeof _254.MsgClientImpl;
                QueryClientImpl: typeof _250.QueryClientImpl;
                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
                    denomTrace(request: _107.QueryDenomTraceRequest): Promise<_107.QueryDenomTraceResponse>;
                    denomTraces(request?: _107.QueryDenomTracesRequest): Promise<_107.QueryDenomTracesResponse>;
                    params(request?: _107.QueryParamsRequest): Promise<_107.QueryParamsResponse>;
                };
                LCDQueryClient: typeof _246.LCDQueryClient;
                registry: ReadonlyArray<[string, import("@cosmjs/proto-signing").GeneratedType]>;
                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
                MessageComposer: {
                    encoded: {
                        transfer(value: _109.MsgTransfer): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                    };
                    withTypeUrl: {
                        transfer(value: _109.MsgTransfer): {
                            typeUrl: string;
                            value: _109.MsgTransfer;
                        };
                    };
                    fromPartial: {
                        transfer(value: _109.MsgTransfer): {
                            typeUrl: string;
                            value: _109.MsgTransfer;
                        };
                    };
                };
                AminoConverter: {
                    "/ibc.applications.transfer.v1.MsgTransfer": {
                        aminoType: string;
                        toAmino: (message: _109.MsgTransfer) => _109.MsgTransferAmino;
                        fromAmino: (object: _109.MsgTransferAmino) => _109.MsgTransfer;
                    };
                };
                MsgTransfer: {
                    typeUrl: string;
                    encode(message: _109.MsgTransfer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _109.MsgTransfer;
                    fromPartial(object: Partial<_109.MsgTransfer>): _109.MsgTransfer;
                    fromAmino(object: _109.MsgTransferAmino): _109.MsgTransfer;
                    toAmino(message: _109.MsgTransfer): _109.MsgTransferAmino;
                    fromAminoMsg(object: _109.MsgTransferAminoMsg): _109.MsgTransfer;
                    toAminoMsg(message: _109.MsgTransfer): _109.MsgTransferAminoMsg;
                    fromProtoMsg(message: _109.MsgTransferProtoMsg): _109.MsgTransfer;
                    toProto(message: _109.MsgTransfer): Uint8Array;
                    toProtoMsg(message: _109.MsgTransfer): _109.MsgTransferProtoMsg;
                };
                MsgTransferResponse: {
                    typeUrl: string;
                    encode(_: _109.MsgTransferResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _109.MsgTransferResponse;
                    fromPartial(_: Partial<_109.MsgTransferResponse>): _109.MsgTransferResponse;
                    fromAmino(_: _109.MsgTransferResponseAmino): _109.MsgTransferResponse;
                    toAmino(_: _109.MsgTransferResponse): _109.MsgTransferResponseAmino;
                    fromAminoMsg(object: _109.MsgTransferResponseAminoMsg): _109.MsgTransferResponse;
                    toAminoMsg(message: _109.MsgTransferResponse): _109.MsgTransferResponseAminoMsg;
                    fromProtoMsg(message: _109.MsgTransferResponseProtoMsg): _109.MsgTransferResponse;
                    toProto(message: _109.MsgTransferResponse): Uint8Array;
                    toProtoMsg(message: _109.MsgTransferResponse): _109.MsgTransferResponseProtoMsg;
                };
                DenomTrace: {
                    typeUrl: string;
                    encode(message: _108.DenomTrace, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _108.DenomTrace;
                    fromPartial(object: Partial<_108.DenomTrace>): _108.DenomTrace;
                    fromAmino(object: _108.DenomTraceAmino): _108.DenomTrace;
                    toAmino(message: _108.DenomTrace): _108.DenomTraceAmino;
                    fromAminoMsg(object: _108.DenomTraceAminoMsg): _108.DenomTrace;
                    toAminoMsg(message: _108.DenomTrace): _108.DenomTraceAminoMsg;
                    fromProtoMsg(message: _108.DenomTraceProtoMsg): _108.DenomTrace;
                    toProto(message: _108.DenomTrace): Uint8Array;
                    toProtoMsg(message: _108.DenomTrace): _108.DenomTraceProtoMsg;
                };
                Params: {
                    typeUrl: string;
                    encode(message: _108.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _108.Params;
                    fromPartial(object: Partial<_108.Params>): _108.Params;
                    fromAmino(object: _108.ParamsAmino): _108.Params;
                    toAmino(message: _108.Params): _108.ParamsAmino;
                    fromAminoMsg(object: _108.ParamsAminoMsg): _108.Params;
                    toAminoMsg(message: _108.Params): _108.ParamsAminoMsg;
                    fromProtoMsg(message: _108.ParamsProtoMsg): _108.Params;
                    toProto(message: _108.Params): Uint8Array;
                    toProtoMsg(message: _108.Params): _108.ParamsProtoMsg;
                };
                QueryDenomTraceRequest: {
                    typeUrl: string;
                    encode(message: _107.QueryDenomTraceRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _107.QueryDenomTraceRequest;
                    fromPartial(object: Partial<_107.QueryDenomTraceRequest>): _107.QueryDenomTraceRequest;
                    fromAmino(object: _107.QueryDenomTraceRequestAmino): _107.QueryDenomTraceRequest;
                    toAmino(message: _107.QueryDenomTraceRequest): _107.QueryDenomTraceRequestAmino;
                    fromAminoMsg(object: _107.QueryDenomTraceRequestAminoMsg): _107.QueryDenomTraceRequest;
                    toAminoMsg(message: _107.QueryDenomTraceRequest): _107.QueryDenomTraceRequestAminoMsg;
                    fromProtoMsg(message: _107.QueryDenomTraceRequestProtoMsg): _107.QueryDenomTraceRequest;
                    toProto(message: _107.QueryDenomTraceRequest): Uint8Array;
                    toProtoMsg(message: _107.QueryDenomTraceRequest): _107.QueryDenomTraceRequestProtoMsg;
                };
                QueryDenomTraceResponse: {
                    typeUrl: string;
                    encode(message: _107.QueryDenomTraceResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _107.QueryDenomTraceResponse;
                    fromPartial(object: Partial<_107.QueryDenomTraceResponse>): _107.QueryDenomTraceResponse;
                    fromAmino(object: _107.QueryDenomTraceResponseAmino): _107.QueryDenomTraceResponse;
                    toAmino(message: _107.QueryDenomTraceResponse): _107.QueryDenomTraceResponseAmino;
                    fromAminoMsg(object: _107.QueryDenomTraceResponseAminoMsg): _107.QueryDenomTraceResponse;
                    toAminoMsg(message: _107.QueryDenomTraceResponse): _107.QueryDenomTraceResponseAminoMsg;
                    fromProtoMsg(message: _107.QueryDenomTraceResponseProtoMsg): _107.QueryDenomTraceResponse;
                    toProto(message: _107.QueryDenomTraceResponse): Uint8Array;
                    toProtoMsg(message: _107.QueryDenomTraceResponse): _107.QueryDenomTraceResponseProtoMsg;
                };
                QueryDenomTracesRequest: {
                    typeUrl: string;
                    encode(message: _107.QueryDenomTracesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _107.QueryDenomTracesRequest;
                    fromPartial(object: Partial<_107.QueryDenomTracesRequest>): _107.QueryDenomTracesRequest;
                    fromAmino(object: _107.QueryDenomTracesRequestAmino): _107.QueryDenomTracesRequest;
                    toAmino(message: _107.QueryDenomTracesRequest): _107.QueryDenomTracesRequestAmino;
                    fromAminoMsg(object: _107.QueryDenomTracesRequestAminoMsg): _107.QueryDenomTracesRequest;
                    toAminoMsg(message: _107.QueryDenomTracesRequest): _107.QueryDenomTracesRequestAminoMsg;
                    fromProtoMsg(message: _107.QueryDenomTracesRequestProtoMsg): _107.QueryDenomTracesRequest;
                    toProto(message: _107.QueryDenomTracesRequest): Uint8Array;
                    toProtoMsg(message: _107.QueryDenomTracesRequest): _107.QueryDenomTracesRequestProtoMsg;
                };
                QueryDenomTracesResponse: {
                    typeUrl: string;
                    encode(message: _107.QueryDenomTracesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _107.QueryDenomTracesResponse;
                    fromPartial(object: Partial<_107.QueryDenomTracesResponse>): _107.QueryDenomTracesResponse;
                    fromAmino(object: _107.QueryDenomTracesResponseAmino): _107.QueryDenomTracesResponse;
                    toAmino(message: _107.QueryDenomTracesResponse): _107.QueryDenomTracesResponseAmino;
                    fromAminoMsg(object: _107.QueryDenomTracesResponseAminoMsg): _107.QueryDenomTracesResponse;
                    toAminoMsg(message: _107.QueryDenomTracesResponse): _107.QueryDenomTracesResponseAminoMsg;
                    fromProtoMsg(message: _107.QueryDenomTracesResponseProtoMsg): _107.QueryDenomTracesResponse;
                    toProto(message: _107.QueryDenomTracesResponse): Uint8Array;
                    toProtoMsg(message: _107.QueryDenomTracesResponse): _107.QueryDenomTracesResponseProtoMsg;
                };
                QueryParamsRequest: {
                    typeUrl: string;
                    encode(_: _107.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _107.QueryParamsRequest;
                    fromPartial(_: Partial<_107.QueryParamsRequest>): _107.QueryParamsRequest;
                    fromAmino(_: _107.QueryParamsRequestAmino): _107.QueryParamsRequest;
                    toAmino(_: _107.QueryParamsRequest): _107.QueryParamsRequestAmino;
                    fromAminoMsg(object: _107.QueryParamsRequestAminoMsg): _107.QueryParamsRequest;
                    toAminoMsg(message: _107.QueryParamsRequest): _107.QueryParamsRequestAminoMsg;
                    fromProtoMsg(message: _107.QueryParamsRequestProtoMsg): _107.QueryParamsRequest;
                    toProto(message: _107.QueryParamsRequest): Uint8Array;
                    toProtoMsg(message: _107.QueryParamsRequest): _107.QueryParamsRequestProtoMsg;
                };
                QueryParamsResponse: {
                    typeUrl: string;
                    encode(message: _107.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _107.QueryParamsResponse;
                    fromPartial(object: Partial<_107.QueryParamsResponse>): _107.QueryParamsResponse;
                    fromAmino(object: _107.QueryParamsResponseAmino): _107.QueryParamsResponse;
                    toAmino(message: _107.QueryParamsResponse): _107.QueryParamsResponseAmino;
                    fromAminoMsg(object: _107.QueryParamsResponseAminoMsg): _107.QueryParamsResponse;
                    toAminoMsg(message: _107.QueryParamsResponse): _107.QueryParamsResponseAminoMsg;
                    fromProtoMsg(message: _107.QueryParamsResponseProtoMsg): _107.QueryParamsResponse;
                    toProto(message: _107.QueryParamsResponse): Uint8Array;
                    toProtoMsg(message: _107.QueryParamsResponse): _107.QueryParamsResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: string;
                    encode(message: _106.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _106.GenesisState;
                    fromPartial(object: Partial<_106.GenesisState>): _106.GenesisState;
                    fromAmino(object: _106.GenesisStateAmino): _106.GenesisState;
                    toAmino(message: _106.GenesisState): _106.GenesisStateAmino;
                    fromAminoMsg(object: _106.GenesisStateAminoMsg): _106.GenesisState;
                    toAminoMsg(message: _106.GenesisState): _106.GenesisStateAminoMsg;
                    fromProtoMsg(message: _106.GenesisStateProtoMsg): _106.GenesisState;
                    toProto(message: _106.GenesisState): Uint8Array;
                    toProtoMsg(message: _106.GenesisState): _106.GenesisStateProtoMsg;
                };
            };
            const v2: {
                FungibleTokenPacketData: {
                    typeUrl: string;
                    encode(message: _110.FungibleTokenPacketData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _110.FungibleTokenPacketData;
                    fromPartial(object: Partial<_110.FungibleTokenPacketData>): _110.FungibleTokenPacketData;
                    fromAmino(object: _110.FungibleTokenPacketDataAmino): _110.FungibleTokenPacketData;
                    toAmino(message: _110.FungibleTokenPacketData): _110.FungibleTokenPacketDataAmino;
                    fromAminoMsg(object: _110.FungibleTokenPacketDataAminoMsg): _110.FungibleTokenPacketData;
                    toAminoMsg(message: _110.FungibleTokenPacketData): _110.FungibleTokenPacketDataAminoMsg;
                    fromProtoMsg(message: _110.FungibleTokenPacketDataProtoMsg): _110.FungibleTokenPacketData;
                    toProto(message: _110.FungibleTokenPacketData): Uint8Array;
                    toProtoMsg(message: _110.FungibleTokenPacketData): _110.FungibleTokenPacketDataProtoMsg;
                };
            };
        }
    }
    namespace core {
        namespace channel {
            const v1: {
                MsgClientImpl: typeof _255.MsgClientImpl;
                QueryClientImpl: typeof _251.QueryClientImpl;
                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
                    channel(request: _113.QueryChannelRequest): Promise<_113.QueryChannelResponse>;
                    channels(request?: _113.QueryChannelsRequest): Promise<_113.QueryChannelsResponse>;
                    connectionChannels(request: _113.QueryConnectionChannelsRequest): Promise<_113.QueryConnectionChannelsResponse>;
                    channelClientState(request: _113.QueryChannelClientStateRequest): Promise<_113.QueryChannelClientStateResponse>;
                    channelConsensusState(request: _113.QueryChannelConsensusStateRequest): Promise<_113.QueryChannelConsensusStateResponse>;
                    packetCommitment(request: _113.QueryPacketCommitmentRequest): Promise<_113.QueryPacketCommitmentResponse>;
                    packetCommitments(request: _113.QueryPacketCommitmentsRequest): Promise<_113.QueryPacketCommitmentsResponse>;
                    packetReceipt(request: _113.QueryPacketReceiptRequest): Promise<_113.QueryPacketReceiptResponse>;
                    packetAcknowledgement(request: _113.QueryPacketAcknowledgementRequest): Promise<_113.QueryPacketAcknowledgementResponse>;
                    packetAcknowledgements(request: _113.QueryPacketAcknowledgementsRequest): Promise<_113.QueryPacketAcknowledgementsResponse>;
                    unreceivedPackets(request: _113.QueryUnreceivedPacketsRequest): Promise<_113.QueryUnreceivedPacketsResponse>;
                    unreceivedAcks(request: _113.QueryUnreceivedAcksRequest): Promise<_113.QueryUnreceivedAcksResponse>;
                    nextSequenceReceive(request: _113.QueryNextSequenceReceiveRequest): Promise<_113.QueryNextSequenceReceiveResponse>;
                };
                LCDQueryClient: typeof _247.LCDQueryClient;
                registry: ReadonlyArray<[string, import("@cosmjs/proto-signing").GeneratedType]>;
                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
                MessageComposer: {
                    encoded: {
                        channelOpenInit(value: _114.MsgChannelOpenInit): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        channelOpenTry(value: _114.MsgChannelOpenTry): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        channelOpenAck(value: _114.MsgChannelOpenAck): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        channelOpenConfirm(value: _114.MsgChannelOpenConfirm): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        channelCloseInit(value: _114.MsgChannelCloseInit): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        channelCloseConfirm(value: _114.MsgChannelCloseConfirm): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        recvPacket(value: _114.MsgRecvPacket): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        timeout(value: _114.MsgTimeout): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        timeoutOnClose(value: _114.MsgTimeoutOnClose): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        acknowledgement(value: _114.MsgAcknowledgement): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                    };
                    withTypeUrl: {
                        channelOpenInit(value: _114.MsgChannelOpenInit): {
                            typeUrl: string;
                            value: _114.MsgChannelOpenInit;
                        };
                        channelOpenTry(value: _114.MsgChannelOpenTry): {
                            typeUrl: string;
                            value: _114.MsgChannelOpenTry;
                        };
                        channelOpenAck(value: _114.MsgChannelOpenAck): {
                            typeUrl: string;
                            value: _114.MsgChannelOpenAck;
                        };
                        channelOpenConfirm(value: _114.MsgChannelOpenConfirm): {
                            typeUrl: string;
                            value: _114.MsgChannelOpenConfirm;
                        };
                        channelCloseInit(value: _114.MsgChannelCloseInit): {
                            typeUrl: string;
                            value: _114.MsgChannelCloseInit;
                        };
                        channelCloseConfirm(value: _114.MsgChannelCloseConfirm): {
                            typeUrl: string;
                            value: _114.MsgChannelCloseConfirm;
                        };
                        recvPacket(value: _114.MsgRecvPacket): {
                            typeUrl: string;
                            value: _114.MsgRecvPacket;
                        };
                        timeout(value: _114.MsgTimeout): {
                            typeUrl: string;
                            value: _114.MsgTimeout;
                        };
                        timeoutOnClose(value: _114.MsgTimeoutOnClose): {
                            typeUrl: string;
                            value: _114.MsgTimeoutOnClose;
                        };
                        acknowledgement(value: _114.MsgAcknowledgement): {
                            typeUrl: string;
                            value: _114.MsgAcknowledgement;
                        };
                    };
                    fromPartial: {
                        channelOpenInit(value: _114.MsgChannelOpenInit): {
                            typeUrl: string;
                            value: _114.MsgChannelOpenInit;
                        };
                        channelOpenTry(value: _114.MsgChannelOpenTry): {
                            typeUrl: string;
                            value: _114.MsgChannelOpenTry;
                        };
                        channelOpenAck(value: _114.MsgChannelOpenAck): {
                            typeUrl: string;
                            value: _114.MsgChannelOpenAck;
                        };
                        channelOpenConfirm(value: _114.MsgChannelOpenConfirm): {
                            typeUrl: string;
                            value: _114.MsgChannelOpenConfirm;
                        };
                        channelCloseInit(value: _114.MsgChannelCloseInit): {
                            typeUrl: string;
                            value: _114.MsgChannelCloseInit;
                        };
                        channelCloseConfirm(value: _114.MsgChannelCloseConfirm): {
                            typeUrl: string;
                            value: _114.MsgChannelCloseConfirm;
                        };
                        recvPacket(value: _114.MsgRecvPacket): {
                            typeUrl: string;
                            value: _114.MsgRecvPacket;
                        };
                        timeout(value: _114.MsgTimeout): {
                            typeUrl: string;
                            value: _114.MsgTimeout;
                        };
                        timeoutOnClose(value: _114.MsgTimeoutOnClose): {
                            typeUrl: string;
                            value: _114.MsgTimeoutOnClose;
                        };
                        acknowledgement(value: _114.MsgAcknowledgement): {
                            typeUrl: string;
                            value: _114.MsgAcknowledgement;
                        };
                    };
                };
                AminoConverter: {
                    "/ibc.core.channel.v1.MsgChannelOpenInit": {
                        aminoType: string;
                        toAmino: (message: _114.MsgChannelOpenInit) => _114.MsgChannelOpenInitAmino;
                        fromAmino: (object: _114.MsgChannelOpenInitAmino) => _114.MsgChannelOpenInit;
                    };
                    "/ibc.core.channel.v1.MsgChannelOpenTry": {
                        aminoType: string;
                        toAmino: (message: _114.MsgChannelOpenTry) => _114.MsgChannelOpenTryAmino;
                        fromAmino: (object: _114.MsgChannelOpenTryAmino) => _114.MsgChannelOpenTry;
                    };
                    "/ibc.core.channel.v1.MsgChannelOpenAck": {
                        aminoType: string;
                        toAmino: (message: _114.MsgChannelOpenAck) => _114.MsgChannelOpenAckAmino;
                        fromAmino: (object: _114.MsgChannelOpenAckAmino) => _114.MsgChannelOpenAck;
                    };
                    "/ibc.core.channel.v1.MsgChannelOpenConfirm": {
                        aminoType: string;
                        toAmino: (message: _114.MsgChannelOpenConfirm) => _114.MsgChannelOpenConfirmAmino;
                        fromAmino: (object: _114.MsgChannelOpenConfirmAmino) => _114.MsgChannelOpenConfirm;
                    };
                    "/ibc.core.channel.v1.MsgChannelCloseInit": {
                        aminoType: string;
                        toAmino: (message: _114.MsgChannelCloseInit) => _114.MsgChannelCloseInitAmino;
                        fromAmino: (object: _114.MsgChannelCloseInitAmino) => _114.MsgChannelCloseInit;
                    };
                    "/ibc.core.channel.v1.MsgChannelCloseConfirm": {
                        aminoType: string;
                        toAmino: (message: _114.MsgChannelCloseConfirm) => _114.MsgChannelCloseConfirmAmino;
                        fromAmino: (object: _114.MsgChannelCloseConfirmAmino) => _114.MsgChannelCloseConfirm;
                    };
                    "/ibc.core.channel.v1.MsgRecvPacket": {
                        aminoType: string;
                        toAmino: (message: _114.MsgRecvPacket) => _114.MsgRecvPacketAmino;
                        fromAmino: (object: _114.MsgRecvPacketAmino) => _114.MsgRecvPacket;
                    };
                    "/ibc.core.channel.v1.MsgTimeout": {
                        aminoType: string;
                        toAmino: (message: _114.MsgTimeout) => _114.MsgTimeoutAmino;
                        fromAmino: (object: _114.MsgTimeoutAmino) => _114.MsgTimeout;
                    };
                    "/ibc.core.channel.v1.MsgTimeoutOnClose": {
                        aminoType: string;
                        toAmino: (message: _114.MsgTimeoutOnClose) => _114.MsgTimeoutOnCloseAmino;
                        fromAmino: (object: _114.MsgTimeoutOnCloseAmino) => _114.MsgTimeoutOnClose;
                    };
                    "/ibc.core.channel.v1.MsgAcknowledgement": {
                        aminoType: string;
                        toAmino: (message: _114.MsgAcknowledgement) => _114.MsgAcknowledgementAmino;
                        fromAmino: (object: _114.MsgAcknowledgementAmino) => _114.MsgAcknowledgement;
                    };
                };
                MsgChannelOpenInit: {
                    typeUrl: string;
                    encode(message: _114.MsgChannelOpenInit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelOpenInit;
                    fromPartial(object: Partial<_114.MsgChannelOpenInit>): _114.MsgChannelOpenInit;
                    fromAmino(object: _114.MsgChannelOpenInitAmino): _114.MsgChannelOpenInit;
                    toAmino(message: _114.MsgChannelOpenInit): _114.MsgChannelOpenInitAmino;
                    fromAminoMsg(object: _114.MsgChannelOpenInitAminoMsg): _114.MsgChannelOpenInit;
                    toAminoMsg(message: _114.MsgChannelOpenInit): _114.MsgChannelOpenInitAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelOpenInitProtoMsg): _114.MsgChannelOpenInit;
                    toProto(message: _114.MsgChannelOpenInit): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelOpenInit): _114.MsgChannelOpenInitProtoMsg;
                };
                MsgChannelOpenInitResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgChannelOpenInitResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelOpenInitResponse;
                    fromPartial(_: Partial<_114.MsgChannelOpenInitResponse>): _114.MsgChannelOpenInitResponse;
                    fromAmino(_: _114.MsgChannelOpenInitResponseAmino): _114.MsgChannelOpenInitResponse;
                    toAmino(_: _114.MsgChannelOpenInitResponse): _114.MsgChannelOpenInitResponseAmino;
                    fromAminoMsg(object: _114.MsgChannelOpenInitResponseAminoMsg): _114.MsgChannelOpenInitResponse;
                    toAminoMsg(message: _114.MsgChannelOpenInitResponse): _114.MsgChannelOpenInitResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelOpenInitResponseProtoMsg): _114.MsgChannelOpenInitResponse;
                    toProto(message: _114.MsgChannelOpenInitResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelOpenInitResponse): _114.MsgChannelOpenInitResponseProtoMsg;
                };
                MsgChannelOpenTry: {
                    typeUrl: string;
                    encode(message: _114.MsgChannelOpenTry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelOpenTry;
                    fromPartial(object: Partial<_114.MsgChannelOpenTry>): _114.MsgChannelOpenTry;
                    fromAmino(object: _114.MsgChannelOpenTryAmino): _114.MsgChannelOpenTry;
                    toAmino(message: _114.MsgChannelOpenTry): _114.MsgChannelOpenTryAmino;
                    fromAminoMsg(object: _114.MsgChannelOpenTryAminoMsg): _114.MsgChannelOpenTry;
                    toAminoMsg(message: _114.MsgChannelOpenTry): _114.MsgChannelOpenTryAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelOpenTryProtoMsg): _114.MsgChannelOpenTry;
                    toProto(message: _114.MsgChannelOpenTry): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelOpenTry): _114.MsgChannelOpenTryProtoMsg;
                };
                MsgChannelOpenTryResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgChannelOpenTryResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelOpenTryResponse;
                    fromPartial(_: Partial<_114.MsgChannelOpenTryResponse>): _114.MsgChannelOpenTryResponse;
                    fromAmino(_: _114.MsgChannelOpenTryResponseAmino): _114.MsgChannelOpenTryResponse;
                    toAmino(_: _114.MsgChannelOpenTryResponse): _114.MsgChannelOpenTryResponseAmino;
                    fromAminoMsg(object: _114.MsgChannelOpenTryResponseAminoMsg): _114.MsgChannelOpenTryResponse;
                    toAminoMsg(message: _114.MsgChannelOpenTryResponse): _114.MsgChannelOpenTryResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelOpenTryResponseProtoMsg): _114.MsgChannelOpenTryResponse;
                    toProto(message: _114.MsgChannelOpenTryResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelOpenTryResponse): _114.MsgChannelOpenTryResponseProtoMsg;
                };
                MsgChannelOpenAck: {
                    typeUrl: string;
                    encode(message: _114.MsgChannelOpenAck, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelOpenAck;
                    fromPartial(object: Partial<_114.MsgChannelOpenAck>): _114.MsgChannelOpenAck;
                    fromAmino(object: _114.MsgChannelOpenAckAmino): _114.MsgChannelOpenAck;
                    toAmino(message: _114.MsgChannelOpenAck): _114.MsgChannelOpenAckAmino;
                    fromAminoMsg(object: _114.MsgChannelOpenAckAminoMsg): _114.MsgChannelOpenAck;
                    toAminoMsg(message: _114.MsgChannelOpenAck): _114.MsgChannelOpenAckAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelOpenAckProtoMsg): _114.MsgChannelOpenAck;
                    toProto(message: _114.MsgChannelOpenAck): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelOpenAck): _114.MsgChannelOpenAckProtoMsg;
                };
                MsgChannelOpenAckResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgChannelOpenAckResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelOpenAckResponse;
                    fromPartial(_: Partial<_114.MsgChannelOpenAckResponse>): _114.MsgChannelOpenAckResponse;
                    fromAmino(_: _114.MsgChannelOpenAckResponseAmino): _114.MsgChannelOpenAckResponse;
                    toAmino(_: _114.MsgChannelOpenAckResponse): _114.MsgChannelOpenAckResponseAmino;
                    fromAminoMsg(object: _114.MsgChannelOpenAckResponseAminoMsg): _114.MsgChannelOpenAckResponse;
                    toAminoMsg(message: _114.MsgChannelOpenAckResponse): _114.MsgChannelOpenAckResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelOpenAckResponseProtoMsg): _114.MsgChannelOpenAckResponse;
                    toProto(message: _114.MsgChannelOpenAckResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelOpenAckResponse): _114.MsgChannelOpenAckResponseProtoMsg;
                };
                MsgChannelOpenConfirm: {
                    typeUrl: string;
                    encode(message: _114.MsgChannelOpenConfirm, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelOpenConfirm;
                    fromPartial(object: Partial<_114.MsgChannelOpenConfirm>): _114.MsgChannelOpenConfirm;
                    fromAmino(object: _114.MsgChannelOpenConfirmAmino): _114.MsgChannelOpenConfirm;
                    toAmino(message: _114.MsgChannelOpenConfirm): _114.MsgChannelOpenConfirmAmino;
                    fromAminoMsg(object: _114.MsgChannelOpenConfirmAminoMsg): _114.MsgChannelOpenConfirm;
                    toAminoMsg(message: _114.MsgChannelOpenConfirm): _114.MsgChannelOpenConfirmAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelOpenConfirmProtoMsg): _114.MsgChannelOpenConfirm;
                    toProto(message: _114.MsgChannelOpenConfirm): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelOpenConfirm): _114.MsgChannelOpenConfirmProtoMsg;
                };
                MsgChannelOpenConfirmResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgChannelOpenConfirmResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelOpenConfirmResponse;
                    fromPartial(_: Partial<_114.MsgChannelOpenConfirmResponse>): _114.MsgChannelOpenConfirmResponse;
                    fromAmino(_: _114.MsgChannelOpenConfirmResponseAmino): _114.MsgChannelOpenConfirmResponse;
                    toAmino(_: _114.MsgChannelOpenConfirmResponse): _114.MsgChannelOpenConfirmResponseAmino;
                    fromAminoMsg(object: _114.MsgChannelOpenConfirmResponseAminoMsg): _114.MsgChannelOpenConfirmResponse;
                    toAminoMsg(message: _114.MsgChannelOpenConfirmResponse): _114.MsgChannelOpenConfirmResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelOpenConfirmResponseProtoMsg): _114.MsgChannelOpenConfirmResponse;
                    toProto(message: _114.MsgChannelOpenConfirmResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelOpenConfirmResponse): _114.MsgChannelOpenConfirmResponseProtoMsg;
                };
                MsgChannelCloseInit: {
                    typeUrl: string;
                    encode(message: _114.MsgChannelCloseInit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelCloseInit;
                    fromPartial(object: Partial<_114.MsgChannelCloseInit>): _114.MsgChannelCloseInit;
                    fromAmino(object: _114.MsgChannelCloseInitAmino): _114.MsgChannelCloseInit;
                    toAmino(message: _114.MsgChannelCloseInit): _114.MsgChannelCloseInitAmino;
                    fromAminoMsg(object: _114.MsgChannelCloseInitAminoMsg): _114.MsgChannelCloseInit;
                    toAminoMsg(message: _114.MsgChannelCloseInit): _114.MsgChannelCloseInitAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelCloseInitProtoMsg): _114.MsgChannelCloseInit;
                    toProto(message: _114.MsgChannelCloseInit): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelCloseInit): _114.MsgChannelCloseInitProtoMsg;
                };
                MsgChannelCloseInitResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgChannelCloseInitResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelCloseInitResponse;
                    fromPartial(_: Partial<_114.MsgChannelCloseInitResponse>): _114.MsgChannelCloseInitResponse;
                    fromAmino(_: _114.MsgChannelCloseInitResponseAmino): _114.MsgChannelCloseInitResponse;
                    toAmino(_: _114.MsgChannelCloseInitResponse): _114.MsgChannelCloseInitResponseAmino;
                    fromAminoMsg(object: _114.MsgChannelCloseInitResponseAminoMsg): _114.MsgChannelCloseInitResponse;
                    toAminoMsg(message: _114.MsgChannelCloseInitResponse): _114.MsgChannelCloseInitResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelCloseInitResponseProtoMsg): _114.MsgChannelCloseInitResponse;
                    toProto(message: _114.MsgChannelCloseInitResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelCloseInitResponse): _114.MsgChannelCloseInitResponseProtoMsg;
                };
                MsgChannelCloseConfirm: {
                    typeUrl: string;
                    encode(message: _114.MsgChannelCloseConfirm, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelCloseConfirm;
                    fromPartial(object: Partial<_114.MsgChannelCloseConfirm>): _114.MsgChannelCloseConfirm;
                    fromAmino(object: _114.MsgChannelCloseConfirmAmino): _114.MsgChannelCloseConfirm;
                    toAmino(message: _114.MsgChannelCloseConfirm): _114.MsgChannelCloseConfirmAmino;
                    fromAminoMsg(object: _114.MsgChannelCloseConfirmAminoMsg): _114.MsgChannelCloseConfirm;
                    toAminoMsg(message: _114.MsgChannelCloseConfirm): _114.MsgChannelCloseConfirmAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelCloseConfirmProtoMsg): _114.MsgChannelCloseConfirm;
                    toProto(message: _114.MsgChannelCloseConfirm): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelCloseConfirm): _114.MsgChannelCloseConfirmProtoMsg;
                };
                MsgChannelCloseConfirmResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgChannelCloseConfirmResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgChannelCloseConfirmResponse;
                    fromPartial(_: Partial<_114.MsgChannelCloseConfirmResponse>): _114.MsgChannelCloseConfirmResponse;
                    fromAmino(_: _114.MsgChannelCloseConfirmResponseAmino): _114.MsgChannelCloseConfirmResponse;
                    toAmino(_: _114.MsgChannelCloseConfirmResponse): _114.MsgChannelCloseConfirmResponseAmino;
                    fromAminoMsg(object: _114.MsgChannelCloseConfirmResponseAminoMsg): _114.MsgChannelCloseConfirmResponse;
                    toAminoMsg(message: _114.MsgChannelCloseConfirmResponse): _114.MsgChannelCloseConfirmResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgChannelCloseConfirmResponseProtoMsg): _114.MsgChannelCloseConfirmResponse;
                    toProto(message: _114.MsgChannelCloseConfirmResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgChannelCloseConfirmResponse): _114.MsgChannelCloseConfirmResponseProtoMsg;
                };
                MsgRecvPacket: {
                    typeUrl: string;
                    encode(message: _114.MsgRecvPacket, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgRecvPacket;
                    fromPartial(object: Partial<_114.MsgRecvPacket>): _114.MsgRecvPacket;
                    fromAmino(object: _114.MsgRecvPacketAmino): _114.MsgRecvPacket;
                    toAmino(message: _114.MsgRecvPacket): _114.MsgRecvPacketAmino;
                    fromAminoMsg(object: _114.MsgRecvPacketAminoMsg): _114.MsgRecvPacket;
                    toAminoMsg(message: _114.MsgRecvPacket): _114.MsgRecvPacketAminoMsg;
                    fromProtoMsg(message: _114.MsgRecvPacketProtoMsg): _114.MsgRecvPacket;
                    toProto(message: _114.MsgRecvPacket): Uint8Array;
                    toProtoMsg(message: _114.MsgRecvPacket): _114.MsgRecvPacketProtoMsg;
                };
                MsgRecvPacketResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgRecvPacketResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgRecvPacketResponse;
                    fromPartial(_: Partial<_114.MsgRecvPacketResponse>): _114.MsgRecvPacketResponse;
                    fromAmino(_: _114.MsgRecvPacketResponseAmino): _114.MsgRecvPacketResponse;
                    toAmino(_: _114.MsgRecvPacketResponse): _114.MsgRecvPacketResponseAmino;
                    fromAminoMsg(object: _114.MsgRecvPacketResponseAminoMsg): _114.MsgRecvPacketResponse;
                    toAminoMsg(message: _114.MsgRecvPacketResponse): _114.MsgRecvPacketResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgRecvPacketResponseProtoMsg): _114.MsgRecvPacketResponse;
                    toProto(message: _114.MsgRecvPacketResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgRecvPacketResponse): _114.MsgRecvPacketResponseProtoMsg;
                };
                MsgTimeout: {
                    typeUrl: string;
                    encode(message: _114.MsgTimeout, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgTimeout;
                    fromPartial(object: Partial<_114.MsgTimeout>): _114.MsgTimeout;
                    fromAmino(object: _114.MsgTimeoutAmino): _114.MsgTimeout;
                    toAmino(message: _114.MsgTimeout): _114.MsgTimeoutAmino;
                    fromAminoMsg(object: _114.MsgTimeoutAminoMsg): _114.MsgTimeout;
                    toAminoMsg(message: _114.MsgTimeout): _114.MsgTimeoutAminoMsg;
                    fromProtoMsg(message: _114.MsgTimeoutProtoMsg): _114.MsgTimeout;
                    toProto(message: _114.MsgTimeout): Uint8Array;
                    toProtoMsg(message: _114.MsgTimeout): _114.MsgTimeoutProtoMsg;
                };
                MsgTimeoutResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgTimeoutResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgTimeoutResponse;
                    fromPartial(_: Partial<_114.MsgTimeoutResponse>): _114.MsgTimeoutResponse;
                    fromAmino(_: _114.MsgTimeoutResponseAmino): _114.MsgTimeoutResponse;
                    toAmino(_: _114.MsgTimeoutResponse): _114.MsgTimeoutResponseAmino;
                    fromAminoMsg(object: _114.MsgTimeoutResponseAminoMsg): _114.MsgTimeoutResponse;
                    toAminoMsg(message: _114.MsgTimeoutResponse): _114.MsgTimeoutResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgTimeoutResponseProtoMsg): _114.MsgTimeoutResponse;
                    toProto(message: _114.MsgTimeoutResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgTimeoutResponse): _114.MsgTimeoutResponseProtoMsg;
                };
                MsgTimeoutOnClose: {
                    typeUrl: string;
                    encode(message: _114.MsgTimeoutOnClose, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgTimeoutOnClose;
                    fromPartial(object: Partial<_114.MsgTimeoutOnClose>): _114.MsgTimeoutOnClose;
                    fromAmino(object: _114.MsgTimeoutOnCloseAmino): _114.MsgTimeoutOnClose;
                    toAmino(message: _114.MsgTimeoutOnClose): _114.MsgTimeoutOnCloseAmino;
                    fromAminoMsg(object: _114.MsgTimeoutOnCloseAminoMsg): _114.MsgTimeoutOnClose;
                    toAminoMsg(message: _114.MsgTimeoutOnClose): _114.MsgTimeoutOnCloseAminoMsg;
                    fromProtoMsg(message: _114.MsgTimeoutOnCloseProtoMsg): _114.MsgTimeoutOnClose;
                    toProto(message: _114.MsgTimeoutOnClose): Uint8Array;
                    toProtoMsg(message: _114.MsgTimeoutOnClose): _114.MsgTimeoutOnCloseProtoMsg;
                };
                MsgTimeoutOnCloseResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgTimeoutOnCloseResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgTimeoutOnCloseResponse;
                    fromPartial(_: Partial<_114.MsgTimeoutOnCloseResponse>): _114.MsgTimeoutOnCloseResponse;
                    fromAmino(_: _114.MsgTimeoutOnCloseResponseAmino): _114.MsgTimeoutOnCloseResponse;
                    toAmino(_: _114.MsgTimeoutOnCloseResponse): _114.MsgTimeoutOnCloseResponseAmino;
                    fromAminoMsg(object: _114.MsgTimeoutOnCloseResponseAminoMsg): _114.MsgTimeoutOnCloseResponse;
                    toAminoMsg(message: _114.MsgTimeoutOnCloseResponse): _114.MsgTimeoutOnCloseResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgTimeoutOnCloseResponseProtoMsg): _114.MsgTimeoutOnCloseResponse;
                    toProto(message: _114.MsgTimeoutOnCloseResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgTimeoutOnCloseResponse): _114.MsgTimeoutOnCloseResponseProtoMsg;
                };
                MsgAcknowledgement: {
                    typeUrl: string;
                    encode(message: _114.MsgAcknowledgement, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgAcknowledgement;
                    fromPartial(object: Partial<_114.MsgAcknowledgement>): _114.MsgAcknowledgement;
                    fromAmino(object: _114.MsgAcknowledgementAmino): _114.MsgAcknowledgement;
                    toAmino(message: _114.MsgAcknowledgement): _114.MsgAcknowledgementAmino;
                    fromAminoMsg(object: _114.MsgAcknowledgementAminoMsg): _114.MsgAcknowledgement;
                    toAminoMsg(message: _114.MsgAcknowledgement): _114.MsgAcknowledgementAminoMsg;
                    fromProtoMsg(message: _114.MsgAcknowledgementProtoMsg): _114.MsgAcknowledgement;
                    toProto(message: _114.MsgAcknowledgement): Uint8Array;
                    toProtoMsg(message: _114.MsgAcknowledgement): _114.MsgAcknowledgementProtoMsg;
                };
                MsgAcknowledgementResponse: {
                    typeUrl: string;
                    encode(_: _114.MsgAcknowledgementResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _114.MsgAcknowledgementResponse;
                    fromPartial(_: Partial<_114.MsgAcknowledgementResponse>): _114.MsgAcknowledgementResponse;
                    fromAmino(_: _114.MsgAcknowledgementResponseAmino): _114.MsgAcknowledgementResponse;
                    toAmino(_: _114.MsgAcknowledgementResponse): _114.MsgAcknowledgementResponseAmino;
                    fromAminoMsg(object: _114.MsgAcknowledgementResponseAminoMsg): _114.MsgAcknowledgementResponse;
                    toAminoMsg(message: _114.MsgAcknowledgementResponse): _114.MsgAcknowledgementResponseAminoMsg;
                    fromProtoMsg(message: _114.MsgAcknowledgementResponseProtoMsg): _114.MsgAcknowledgementResponse;
                    toProto(message: _114.MsgAcknowledgementResponse): Uint8Array;
                    toProtoMsg(message: _114.MsgAcknowledgementResponse): _114.MsgAcknowledgementResponseProtoMsg;
                };
                QueryChannelRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryChannelRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryChannelRequest;
                    fromPartial(object: Partial<_113.QueryChannelRequest>): _113.QueryChannelRequest;
                    fromAmino(object: _113.QueryChannelRequestAmino): _113.QueryChannelRequest;
                    toAmino(message: _113.QueryChannelRequest): _113.QueryChannelRequestAmino;
                    fromAminoMsg(object: _113.QueryChannelRequestAminoMsg): _113.QueryChannelRequest;
                    toAminoMsg(message: _113.QueryChannelRequest): _113.QueryChannelRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryChannelRequestProtoMsg): _113.QueryChannelRequest;
                    toProto(message: _113.QueryChannelRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryChannelRequest): _113.QueryChannelRequestProtoMsg;
                };
                QueryChannelResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryChannelResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryChannelResponse;
                    fromPartial(object: Partial<_113.QueryChannelResponse>): _113.QueryChannelResponse;
                    fromAmino(object: _113.QueryChannelResponseAmino): _113.QueryChannelResponse;
                    toAmino(message: _113.QueryChannelResponse): _113.QueryChannelResponseAmino;
                    fromAminoMsg(object: _113.QueryChannelResponseAminoMsg): _113.QueryChannelResponse;
                    toAminoMsg(message: _113.QueryChannelResponse): _113.QueryChannelResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryChannelResponseProtoMsg): _113.QueryChannelResponse;
                    toProto(message: _113.QueryChannelResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryChannelResponse): _113.QueryChannelResponseProtoMsg;
                };
                QueryChannelsRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryChannelsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryChannelsRequest;
                    fromPartial(object: Partial<_113.QueryChannelsRequest>): _113.QueryChannelsRequest;
                    fromAmino(object: _113.QueryChannelsRequestAmino): _113.QueryChannelsRequest;
                    toAmino(message: _113.QueryChannelsRequest): _113.QueryChannelsRequestAmino;
                    fromAminoMsg(object: _113.QueryChannelsRequestAminoMsg): _113.QueryChannelsRequest;
                    toAminoMsg(message: _113.QueryChannelsRequest): _113.QueryChannelsRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryChannelsRequestProtoMsg): _113.QueryChannelsRequest;
                    toProto(message: _113.QueryChannelsRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryChannelsRequest): _113.QueryChannelsRequestProtoMsg;
                };
                QueryChannelsResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryChannelsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryChannelsResponse;
                    fromPartial(object: Partial<_113.QueryChannelsResponse>): _113.QueryChannelsResponse;
                    fromAmino(object: _113.QueryChannelsResponseAmino): _113.QueryChannelsResponse;
                    toAmino(message: _113.QueryChannelsResponse): _113.QueryChannelsResponseAmino;
                    fromAminoMsg(object: _113.QueryChannelsResponseAminoMsg): _113.QueryChannelsResponse;
                    toAminoMsg(message: _113.QueryChannelsResponse): _113.QueryChannelsResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryChannelsResponseProtoMsg): _113.QueryChannelsResponse;
                    toProto(message: _113.QueryChannelsResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryChannelsResponse): _113.QueryChannelsResponseProtoMsg;
                };
                QueryConnectionChannelsRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryConnectionChannelsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryConnectionChannelsRequest;
                    fromPartial(object: Partial<_113.QueryConnectionChannelsRequest>): _113.QueryConnectionChannelsRequest;
                    fromAmino(object: _113.QueryConnectionChannelsRequestAmino): _113.QueryConnectionChannelsRequest;
                    toAmino(message: _113.QueryConnectionChannelsRequest): _113.QueryConnectionChannelsRequestAmino;
                    fromAminoMsg(object: _113.QueryConnectionChannelsRequestAminoMsg): _113.QueryConnectionChannelsRequest;
                    toAminoMsg(message: _113.QueryConnectionChannelsRequest): _113.QueryConnectionChannelsRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryConnectionChannelsRequestProtoMsg): _113.QueryConnectionChannelsRequest;
                    toProto(message: _113.QueryConnectionChannelsRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryConnectionChannelsRequest): _113.QueryConnectionChannelsRequestProtoMsg;
                };
                QueryConnectionChannelsResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryConnectionChannelsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryConnectionChannelsResponse;
                    fromPartial(object: Partial<_113.QueryConnectionChannelsResponse>): _113.QueryConnectionChannelsResponse;
                    fromAmino(object: _113.QueryConnectionChannelsResponseAmino): _113.QueryConnectionChannelsResponse;
                    toAmino(message: _113.QueryConnectionChannelsResponse): _113.QueryConnectionChannelsResponseAmino;
                    fromAminoMsg(object: _113.QueryConnectionChannelsResponseAminoMsg): _113.QueryConnectionChannelsResponse;
                    toAminoMsg(message: _113.QueryConnectionChannelsResponse): _113.QueryConnectionChannelsResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryConnectionChannelsResponseProtoMsg): _113.QueryConnectionChannelsResponse;
                    toProto(message: _113.QueryConnectionChannelsResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryConnectionChannelsResponse): _113.QueryConnectionChannelsResponseProtoMsg;
                };
                QueryChannelClientStateRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryChannelClientStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryChannelClientStateRequest;
                    fromPartial(object: Partial<_113.QueryChannelClientStateRequest>): _113.QueryChannelClientStateRequest;
                    fromAmino(object: _113.QueryChannelClientStateRequestAmino): _113.QueryChannelClientStateRequest;
                    toAmino(message: _113.QueryChannelClientStateRequest): _113.QueryChannelClientStateRequestAmino;
                    fromAminoMsg(object: _113.QueryChannelClientStateRequestAminoMsg): _113.QueryChannelClientStateRequest;
                    toAminoMsg(message: _113.QueryChannelClientStateRequest): _113.QueryChannelClientStateRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryChannelClientStateRequestProtoMsg): _113.QueryChannelClientStateRequest;
                    toProto(message: _113.QueryChannelClientStateRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryChannelClientStateRequest): _113.QueryChannelClientStateRequestProtoMsg;
                };
                QueryChannelClientStateResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryChannelClientStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryChannelClientStateResponse;
                    fromPartial(object: Partial<_113.QueryChannelClientStateResponse>): _113.QueryChannelClientStateResponse;
                    fromAmino(object: _113.QueryChannelClientStateResponseAmino): _113.QueryChannelClientStateResponse;
                    toAmino(message: _113.QueryChannelClientStateResponse): _113.QueryChannelClientStateResponseAmino;
                    fromAminoMsg(object: _113.QueryChannelClientStateResponseAminoMsg): _113.QueryChannelClientStateResponse;
                    toAminoMsg(message: _113.QueryChannelClientStateResponse): _113.QueryChannelClientStateResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryChannelClientStateResponseProtoMsg): _113.QueryChannelClientStateResponse;
                    toProto(message: _113.QueryChannelClientStateResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryChannelClientStateResponse): _113.QueryChannelClientStateResponseProtoMsg;
                };
                QueryChannelConsensusStateRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryChannelConsensusStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryChannelConsensusStateRequest;
                    fromPartial(object: Partial<_113.QueryChannelConsensusStateRequest>): _113.QueryChannelConsensusStateRequest;
                    fromAmino(object: _113.QueryChannelConsensusStateRequestAmino): _113.QueryChannelConsensusStateRequest;
                    toAmino(message: _113.QueryChannelConsensusStateRequest): _113.QueryChannelConsensusStateRequestAmino;
                    fromAminoMsg(object: _113.QueryChannelConsensusStateRequestAminoMsg): _113.QueryChannelConsensusStateRequest;
                    toAminoMsg(message: _113.QueryChannelConsensusStateRequest): _113.QueryChannelConsensusStateRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryChannelConsensusStateRequestProtoMsg): _113.QueryChannelConsensusStateRequest;
                    toProto(message: _113.QueryChannelConsensusStateRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryChannelConsensusStateRequest): _113.QueryChannelConsensusStateRequestProtoMsg;
                };
                QueryChannelConsensusStateResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryChannelConsensusStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryChannelConsensusStateResponse;
                    fromPartial(object: Partial<_113.QueryChannelConsensusStateResponse>): _113.QueryChannelConsensusStateResponse;
                    fromAmino(object: _113.QueryChannelConsensusStateResponseAmino): _113.QueryChannelConsensusStateResponse;
                    toAmino(message: _113.QueryChannelConsensusStateResponse): _113.QueryChannelConsensusStateResponseAmino;
                    fromAminoMsg(object: _113.QueryChannelConsensusStateResponseAminoMsg): _113.QueryChannelConsensusStateResponse;
                    toAminoMsg(message: _113.QueryChannelConsensusStateResponse): _113.QueryChannelConsensusStateResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryChannelConsensusStateResponseProtoMsg): _113.QueryChannelConsensusStateResponse;
                    toProto(message: _113.QueryChannelConsensusStateResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryChannelConsensusStateResponse): _113.QueryChannelConsensusStateResponseProtoMsg;
                };
                QueryPacketCommitmentRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketCommitmentRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketCommitmentRequest;
                    fromPartial(object: Partial<_113.QueryPacketCommitmentRequest>): _113.QueryPacketCommitmentRequest;
                    fromAmino(object: _113.QueryPacketCommitmentRequestAmino): _113.QueryPacketCommitmentRequest;
                    toAmino(message: _113.QueryPacketCommitmentRequest): _113.QueryPacketCommitmentRequestAmino;
                    fromAminoMsg(object: _113.QueryPacketCommitmentRequestAminoMsg): _113.QueryPacketCommitmentRequest;
                    toAminoMsg(message: _113.QueryPacketCommitmentRequest): _113.QueryPacketCommitmentRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketCommitmentRequestProtoMsg): _113.QueryPacketCommitmentRequest;
                    toProto(message: _113.QueryPacketCommitmentRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketCommitmentRequest): _113.QueryPacketCommitmentRequestProtoMsg;
                };
                QueryPacketCommitmentResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketCommitmentResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketCommitmentResponse;
                    fromPartial(object: Partial<_113.QueryPacketCommitmentResponse>): _113.QueryPacketCommitmentResponse;
                    fromAmino(object: _113.QueryPacketCommitmentResponseAmino): _113.QueryPacketCommitmentResponse;
                    toAmino(message: _113.QueryPacketCommitmentResponse): _113.QueryPacketCommitmentResponseAmino;
                    fromAminoMsg(object: _113.QueryPacketCommitmentResponseAminoMsg): _113.QueryPacketCommitmentResponse;
                    toAminoMsg(message: _113.QueryPacketCommitmentResponse): _113.QueryPacketCommitmentResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketCommitmentResponseProtoMsg): _113.QueryPacketCommitmentResponse;
                    toProto(message: _113.QueryPacketCommitmentResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketCommitmentResponse): _113.QueryPacketCommitmentResponseProtoMsg;
                };
                QueryPacketCommitmentsRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketCommitmentsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketCommitmentsRequest;
                    fromPartial(object: Partial<_113.QueryPacketCommitmentsRequest>): _113.QueryPacketCommitmentsRequest;
                    fromAmino(object: _113.QueryPacketCommitmentsRequestAmino): _113.QueryPacketCommitmentsRequest;
                    toAmino(message: _113.QueryPacketCommitmentsRequest): _113.QueryPacketCommitmentsRequestAmino;
                    fromAminoMsg(object: _113.QueryPacketCommitmentsRequestAminoMsg): _113.QueryPacketCommitmentsRequest;
                    toAminoMsg(message: _113.QueryPacketCommitmentsRequest): _113.QueryPacketCommitmentsRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketCommitmentsRequestProtoMsg): _113.QueryPacketCommitmentsRequest;
                    toProto(message: _113.QueryPacketCommitmentsRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketCommitmentsRequest): _113.QueryPacketCommitmentsRequestProtoMsg;
                };
                QueryPacketCommitmentsResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketCommitmentsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketCommitmentsResponse;
                    fromPartial(object: Partial<_113.QueryPacketCommitmentsResponse>): _113.QueryPacketCommitmentsResponse;
                    fromAmino(object: _113.QueryPacketCommitmentsResponseAmino): _113.QueryPacketCommitmentsResponse;
                    toAmino(message: _113.QueryPacketCommitmentsResponse): _113.QueryPacketCommitmentsResponseAmino;
                    fromAminoMsg(object: _113.QueryPacketCommitmentsResponseAminoMsg): _113.QueryPacketCommitmentsResponse;
                    toAminoMsg(message: _113.QueryPacketCommitmentsResponse): _113.QueryPacketCommitmentsResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketCommitmentsResponseProtoMsg): _113.QueryPacketCommitmentsResponse;
                    toProto(message: _113.QueryPacketCommitmentsResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketCommitmentsResponse): _113.QueryPacketCommitmentsResponseProtoMsg;
                };
                QueryPacketReceiptRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketReceiptRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketReceiptRequest;
                    fromPartial(object: Partial<_113.QueryPacketReceiptRequest>): _113.QueryPacketReceiptRequest;
                    fromAmino(object: _113.QueryPacketReceiptRequestAmino): _113.QueryPacketReceiptRequest;
                    toAmino(message: _113.QueryPacketReceiptRequest): _113.QueryPacketReceiptRequestAmino;
                    fromAminoMsg(object: _113.QueryPacketReceiptRequestAminoMsg): _113.QueryPacketReceiptRequest;
                    toAminoMsg(message: _113.QueryPacketReceiptRequest): _113.QueryPacketReceiptRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketReceiptRequestProtoMsg): _113.QueryPacketReceiptRequest;
                    toProto(message: _113.QueryPacketReceiptRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketReceiptRequest): _113.QueryPacketReceiptRequestProtoMsg;
                };
                QueryPacketReceiptResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketReceiptResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketReceiptResponse;
                    fromPartial(object: Partial<_113.QueryPacketReceiptResponse>): _113.QueryPacketReceiptResponse;
                    fromAmino(object: _113.QueryPacketReceiptResponseAmino): _113.QueryPacketReceiptResponse;
                    toAmino(message: _113.QueryPacketReceiptResponse): _113.QueryPacketReceiptResponseAmino;
                    fromAminoMsg(object: _113.QueryPacketReceiptResponseAminoMsg): _113.QueryPacketReceiptResponse;
                    toAminoMsg(message: _113.QueryPacketReceiptResponse): _113.QueryPacketReceiptResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketReceiptResponseProtoMsg): _113.QueryPacketReceiptResponse;
                    toProto(message: _113.QueryPacketReceiptResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketReceiptResponse): _113.QueryPacketReceiptResponseProtoMsg;
                };
                QueryPacketAcknowledgementRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketAcknowledgementRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketAcknowledgementRequest;
                    fromPartial(object: Partial<_113.QueryPacketAcknowledgementRequest>): _113.QueryPacketAcknowledgementRequest;
                    fromAmino(object: _113.QueryPacketAcknowledgementRequestAmino): _113.QueryPacketAcknowledgementRequest;
                    toAmino(message: _113.QueryPacketAcknowledgementRequest): _113.QueryPacketAcknowledgementRequestAmino;
                    fromAminoMsg(object: _113.QueryPacketAcknowledgementRequestAminoMsg): _113.QueryPacketAcknowledgementRequest;
                    toAminoMsg(message: _113.QueryPacketAcknowledgementRequest): _113.QueryPacketAcknowledgementRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketAcknowledgementRequestProtoMsg): _113.QueryPacketAcknowledgementRequest;
                    toProto(message: _113.QueryPacketAcknowledgementRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketAcknowledgementRequest): _113.QueryPacketAcknowledgementRequestProtoMsg;
                };
                QueryPacketAcknowledgementResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketAcknowledgementResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketAcknowledgementResponse;
                    fromPartial(object: Partial<_113.QueryPacketAcknowledgementResponse>): _113.QueryPacketAcknowledgementResponse;
                    fromAmino(object: _113.QueryPacketAcknowledgementResponseAmino): _113.QueryPacketAcknowledgementResponse;
                    toAmino(message: _113.QueryPacketAcknowledgementResponse): _113.QueryPacketAcknowledgementResponseAmino;
                    fromAminoMsg(object: _113.QueryPacketAcknowledgementResponseAminoMsg): _113.QueryPacketAcknowledgementResponse;
                    toAminoMsg(message: _113.QueryPacketAcknowledgementResponse): _113.QueryPacketAcknowledgementResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketAcknowledgementResponseProtoMsg): _113.QueryPacketAcknowledgementResponse;
                    toProto(message: _113.QueryPacketAcknowledgementResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketAcknowledgementResponse): _113.QueryPacketAcknowledgementResponseProtoMsg;
                };
                QueryPacketAcknowledgementsRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketAcknowledgementsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketAcknowledgementsRequest;
                    fromPartial(object: Partial<_113.QueryPacketAcknowledgementsRequest>): _113.QueryPacketAcknowledgementsRequest;
                    fromAmino(object: _113.QueryPacketAcknowledgementsRequestAmino): _113.QueryPacketAcknowledgementsRequest;
                    toAmino(message: _113.QueryPacketAcknowledgementsRequest): _113.QueryPacketAcknowledgementsRequestAmino;
                    fromAminoMsg(object: _113.QueryPacketAcknowledgementsRequestAminoMsg): _113.QueryPacketAcknowledgementsRequest;
                    toAminoMsg(message: _113.QueryPacketAcknowledgementsRequest): _113.QueryPacketAcknowledgementsRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketAcknowledgementsRequestProtoMsg): _113.QueryPacketAcknowledgementsRequest;
                    toProto(message: _113.QueryPacketAcknowledgementsRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketAcknowledgementsRequest): _113.QueryPacketAcknowledgementsRequestProtoMsg;
                };
                QueryPacketAcknowledgementsResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryPacketAcknowledgementsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryPacketAcknowledgementsResponse;
                    fromPartial(object: Partial<_113.QueryPacketAcknowledgementsResponse>): _113.QueryPacketAcknowledgementsResponse;
                    fromAmino(object: _113.QueryPacketAcknowledgementsResponseAmino): _113.QueryPacketAcknowledgementsResponse;
                    toAmino(message: _113.QueryPacketAcknowledgementsResponse): _113.QueryPacketAcknowledgementsResponseAmino;
                    fromAminoMsg(object: _113.QueryPacketAcknowledgementsResponseAminoMsg): _113.QueryPacketAcknowledgementsResponse;
                    toAminoMsg(message: _113.QueryPacketAcknowledgementsResponse): _113.QueryPacketAcknowledgementsResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryPacketAcknowledgementsResponseProtoMsg): _113.QueryPacketAcknowledgementsResponse;
                    toProto(message: _113.QueryPacketAcknowledgementsResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryPacketAcknowledgementsResponse): _113.QueryPacketAcknowledgementsResponseProtoMsg;
                };
                QueryUnreceivedPacketsRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryUnreceivedPacketsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryUnreceivedPacketsRequest;
                    fromPartial(object: Partial<_113.QueryUnreceivedPacketsRequest>): _113.QueryUnreceivedPacketsRequest;
                    fromAmino(object: _113.QueryUnreceivedPacketsRequestAmino): _113.QueryUnreceivedPacketsRequest;
                    toAmino(message: _113.QueryUnreceivedPacketsRequest): _113.QueryUnreceivedPacketsRequestAmino;
                    fromAminoMsg(object: _113.QueryUnreceivedPacketsRequestAminoMsg): _113.QueryUnreceivedPacketsRequest;
                    toAminoMsg(message: _113.QueryUnreceivedPacketsRequest): _113.QueryUnreceivedPacketsRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryUnreceivedPacketsRequestProtoMsg): _113.QueryUnreceivedPacketsRequest;
                    toProto(message: _113.QueryUnreceivedPacketsRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryUnreceivedPacketsRequest): _113.QueryUnreceivedPacketsRequestProtoMsg;
                };
                QueryUnreceivedPacketsResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryUnreceivedPacketsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryUnreceivedPacketsResponse;
                    fromPartial(object: Partial<_113.QueryUnreceivedPacketsResponse>): _113.QueryUnreceivedPacketsResponse;
                    fromAmino(object: _113.QueryUnreceivedPacketsResponseAmino): _113.QueryUnreceivedPacketsResponse;
                    toAmino(message: _113.QueryUnreceivedPacketsResponse): _113.QueryUnreceivedPacketsResponseAmino;
                    fromAminoMsg(object: _113.QueryUnreceivedPacketsResponseAminoMsg): _113.QueryUnreceivedPacketsResponse;
                    toAminoMsg(message: _113.QueryUnreceivedPacketsResponse): _113.QueryUnreceivedPacketsResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryUnreceivedPacketsResponseProtoMsg): _113.QueryUnreceivedPacketsResponse;
                    toProto(message: _113.QueryUnreceivedPacketsResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryUnreceivedPacketsResponse): _113.QueryUnreceivedPacketsResponseProtoMsg;
                };
                QueryUnreceivedAcksRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryUnreceivedAcksRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryUnreceivedAcksRequest;
                    fromPartial(object: Partial<_113.QueryUnreceivedAcksRequest>): _113.QueryUnreceivedAcksRequest;
                    fromAmino(object: _113.QueryUnreceivedAcksRequestAmino): _113.QueryUnreceivedAcksRequest;
                    toAmino(message: _113.QueryUnreceivedAcksRequest): _113.QueryUnreceivedAcksRequestAmino;
                    fromAminoMsg(object: _113.QueryUnreceivedAcksRequestAminoMsg): _113.QueryUnreceivedAcksRequest;
                    toAminoMsg(message: _113.QueryUnreceivedAcksRequest): _113.QueryUnreceivedAcksRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryUnreceivedAcksRequestProtoMsg): _113.QueryUnreceivedAcksRequest;
                    toProto(message: _113.QueryUnreceivedAcksRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryUnreceivedAcksRequest): _113.QueryUnreceivedAcksRequestProtoMsg;
                };
                QueryUnreceivedAcksResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryUnreceivedAcksResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryUnreceivedAcksResponse;
                    fromPartial(object: Partial<_113.QueryUnreceivedAcksResponse>): _113.QueryUnreceivedAcksResponse;
                    fromAmino(object: _113.QueryUnreceivedAcksResponseAmino): _113.QueryUnreceivedAcksResponse;
                    toAmino(message: _113.QueryUnreceivedAcksResponse): _113.QueryUnreceivedAcksResponseAmino;
                    fromAminoMsg(object: _113.QueryUnreceivedAcksResponseAminoMsg): _113.QueryUnreceivedAcksResponse;
                    toAminoMsg(message: _113.QueryUnreceivedAcksResponse): _113.QueryUnreceivedAcksResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryUnreceivedAcksResponseProtoMsg): _113.QueryUnreceivedAcksResponse;
                    toProto(message: _113.QueryUnreceivedAcksResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryUnreceivedAcksResponse): _113.QueryUnreceivedAcksResponseProtoMsg;
                };
                QueryNextSequenceReceiveRequest: {
                    typeUrl: string;
                    encode(message: _113.QueryNextSequenceReceiveRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryNextSequenceReceiveRequest;
                    fromPartial(object: Partial<_113.QueryNextSequenceReceiveRequest>): _113.QueryNextSequenceReceiveRequest;
                    fromAmino(object: _113.QueryNextSequenceReceiveRequestAmino): _113.QueryNextSequenceReceiveRequest;
                    toAmino(message: _113.QueryNextSequenceReceiveRequest): _113.QueryNextSequenceReceiveRequestAmino;
                    fromAminoMsg(object: _113.QueryNextSequenceReceiveRequestAminoMsg): _113.QueryNextSequenceReceiveRequest;
                    toAminoMsg(message: _113.QueryNextSequenceReceiveRequest): _113.QueryNextSequenceReceiveRequestAminoMsg;
                    fromProtoMsg(message: _113.QueryNextSequenceReceiveRequestProtoMsg): _113.QueryNextSequenceReceiveRequest;
                    toProto(message: _113.QueryNextSequenceReceiveRequest): Uint8Array;
                    toProtoMsg(message: _113.QueryNextSequenceReceiveRequest): _113.QueryNextSequenceReceiveRequestProtoMsg;
                };
                QueryNextSequenceReceiveResponse: {
                    typeUrl: string;
                    encode(message: _113.QueryNextSequenceReceiveResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.QueryNextSequenceReceiveResponse;
                    fromPartial(object: Partial<_113.QueryNextSequenceReceiveResponse>): _113.QueryNextSequenceReceiveResponse;
                    fromAmino(object: _113.QueryNextSequenceReceiveResponseAmino): _113.QueryNextSequenceReceiveResponse;
                    toAmino(message: _113.QueryNextSequenceReceiveResponse): _113.QueryNextSequenceReceiveResponseAmino;
                    fromAminoMsg(object: _113.QueryNextSequenceReceiveResponseAminoMsg): _113.QueryNextSequenceReceiveResponse;
                    toAminoMsg(message: _113.QueryNextSequenceReceiveResponse): _113.QueryNextSequenceReceiveResponseAminoMsg;
                    fromProtoMsg(message: _113.QueryNextSequenceReceiveResponseProtoMsg): _113.QueryNextSequenceReceiveResponse;
                    toProto(message: _113.QueryNextSequenceReceiveResponse): Uint8Array;
                    toProtoMsg(message: _113.QueryNextSequenceReceiveResponse): _113.QueryNextSequenceReceiveResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: string;
                    encode(message: _112.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _112.GenesisState;
                    fromPartial(object: Partial<_112.GenesisState>): _112.GenesisState;
                    fromAmino(object: _112.GenesisStateAmino): _112.GenesisState;
                    toAmino(message: _112.GenesisState): _112.GenesisStateAmino;
                    fromAminoMsg(object: _112.GenesisStateAminoMsg): _112.GenesisState;
                    toAminoMsg(message: _112.GenesisState): _112.GenesisStateAminoMsg;
                    fromProtoMsg(message: _112.GenesisStateProtoMsg): _112.GenesisState;
                    toProto(message: _112.GenesisState): Uint8Array;
                    toProtoMsg(message: _112.GenesisState): _112.GenesisStateProtoMsg;
                };
                PacketSequence: {
                    typeUrl: string;
                    encode(message: _112.PacketSequence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _112.PacketSequence;
                    fromPartial(object: Partial<_112.PacketSequence>): _112.PacketSequence;
                    fromAmino(object: _112.PacketSequenceAmino): _112.PacketSequence;
                    toAmino(message: _112.PacketSequence): _112.PacketSequenceAmino;
                    fromAminoMsg(object: _112.PacketSequenceAminoMsg): _112.PacketSequence;
                    toAminoMsg(message: _112.PacketSequence): _112.PacketSequenceAminoMsg;
                    fromProtoMsg(message: _112.PacketSequenceProtoMsg): _112.PacketSequence;
                    toProto(message: _112.PacketSequence): Uint8Array;
                    toProtoMsg(message: _112.PacketSequence): _112.PacketSequenceProtoMsg;
                };
                stateFromJSON(object: any): _111.State;
                stateToJSON(object: _111.State): string;
                orderFromJSON(object: any): _111.Order;
                orderToJSON(object: _111.Order): string;
                State: typeof _111.State;
                StateSDKType: typeof _111.State;
                StateAmino: typeof _111.State;
                Order: typeof _111.Order;
                OrderSDKType: typeof _111.Order;
                OrderAmino: typeof _111.Order;
                Channel: {
                    typeUrl: string;
                    encode(message: _111.Channel, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _111.Channel;
                    fromPartial(object: Partial<_111.Channel>): _111.Channel;
                    fromAmino(object: _111.ChannelAmino): _111.Channel;
                    toAmino(message: _111.Channel): _111.ChannelAmino;
                    fromAminoMsg(object: _111.ChannelAminoMsg): _111.Channel;
                    toAminoMsg(message: _111.Channel): _111.ChannelAminoMsg;
                    fromProtoMsg(message: _111.ChannelProtoMsg): _111.Channel;
                    toProto(message: _111.Channel): Uint8Array;
                    toProtoMsg(message: _111.Channel): _111.ChannelProtoMsg;
                };
                IdentifiedChannel: {
                    typeUrl: string;
                    encode(message: _111.IdentifiedChannel, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _111.IdentifiedChannel;
                    fromPartial(object: Partial<_111.IdentifiedChannel>): _111.IdentifiedChannel;
                    fromAmino(object: _111.IdentifiedChannelAmino): _111.IdentifiedChannel;
                    toAmino(message: _111.IdentifiedChannel): _111.IdentifiedChannelAmino;
                    fromAminoMsg(object: _111.IdentifiedChannelAminoMsg): _111.IdentifiedChannel;
                    toAminoMsg(message: _111.IdentifiedChannel): _111.IdentifiedChannelAminoMsg;
                    fromProtoMsg(message: _111.IdentifiedChannelProtoMsg): _111.IdentifiedChannel;
                    toProto(message: _111.IdentifiedChannel): Uint8Array;
                    toProtoMsg(message: _111.IdentifiedChannel): _111.IdentifiedChannelProtoMsg;
                };
                Counterparty: {
                    typeUrl: string;
                    encode(message: _111.Counterparty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _111.Counterparty;
                    fromPartial(object: Partial<_111.Counterparty>): _111.Counterparty;
                    fromAmino(object: _111.CounterpartyAmino): _111.Counterparty;
                    toAmino(message: _111.Counterparty): _111.CounterpartyAmino;
                    fromAminoMsg(object: _111.CounterpartyAminoMsg): _111.Counterparty;
                    toAminoMsg(message: _111.Counterparty): _111.CounterpartyAminoMsg;
                    fromProtoMsg(message: _111.CounterpartyProtoMsg): _111.Counterparty;
                    toProto(message: _111.Counterparty): Uint8Array;
                    toProtoMsg(message: _111.Counterparty): _111.CounterpartyProtoMsg;
                };
                Packet: {
                    typeUrl: string;
                    encode(message: _111.Packet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _111.Packet;
                    fromPartial(object: Partial<_111.Packet>): _111.Packet;
                    fromAmino(object: _111.PacketAmino): _111.Packet;
                    toAmino(message: _111.Packet): _111.PacketAmino;
                    fromAminoMsg(object: _111.PacketAminoMsg): _111.Packet;
                    toAminoMsg(message: _111.Packet): _111.PacketAminoMsg;
                    fromProtoMsg(message: _111.PacketProtoMsg): _111.Packet;
                    toProto(message: _111.Packet): Uint8Array;
                    toProtoMsg(message: _111.Packet): _111.PacketProtoMsg;
                };
                PacketState: {
                    typeUrl: string;
                    encode(message: _111.PacketState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _111.PacketState;
                    fromPartial(object: Partial<_111.PacketState>): _111.PacketState;
                    fromAmino(object: _111.PacketStateAmino): _111.PacketState;
                    toAmino(message: _111.PacketState): _111.PacketStateAmino;
                    fromAminoMsg(object: _111.PacketStateAminoMsg): _111.PacketState;
                    toAminoMsg(message: _111.PacketState): _111.PacketStateAminoMsg;
                    fromProtoMsg(message: _111.PacketStateProtoMsg): _111.PacketState;
                    toProto(message: _111.PacketState): Uint8Array;
                    toProtoMsg(message: _111.PacketState): _111.PacketStateProtoMsg;
                };
                Acknowledgement: {
                    typeUrl: string;
                    encode(message: _111.Acknowledgement, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _111.Acknowledgement;
                    fromPartial(object: Partial<_111.Acknowledgement>): _111.Acknowledgement;
                    fromAmino(object: _111.AcknowledgementAmino): _111.Acknowledgement;
                    toAmino(message: _111.Acknowledgement): _111.AcknowledgementAmino;
                    fromAminoMsg(object: _111.AcknowledgementAminoMsg): _111.Acknowledgement;
                    toAminoMsg(message: _111.Acknowledgement): _111.AcknowledgementAminoMsg;
                    fromProtoMsg(message: _111.AcknowledgementProtoMsg): _111.Acknowledgement;
                    toProto(message: _111.Acknowledgement): Uint8Array;
                    toProtoMsg(message: _111.Acknowledgement): _111.AcknowledgementProtoMsg;
                };
            };
        }
        namespace client {
            const v1: {
                MsgClientImpl: typeof _256.MsgClientImpl;
                QueryClientImpl: typeof _252.QueryClientImpl;
                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
                    clientState(request: _117.QueryClientStateRequest): Promise<_117.QueryClientStateResponse>;
                    clientStates(request?: _117.QueryClientStatesRequest): Promise<_117.QueryClientStatesResponse>;
                    consensusState(request: _117.QueryConsensusStateRequest): Promise<_117.QueryConsensusStateResponse>;
                    consensusStates(request: _117.QueryConsensusStatesRequest): Promise<_117.QueryConsensusStatesResponse>;
                    clientStatus(request: _117.QueryClientStatusRequest): Promise<_117.QueryClientStatusResponse>;
                    clientParams(request?: _117.QueryClientParamsRequest): Promise<_117.QueryClientParamsResponse>;
                    upgradedClientState(request?: _117.QueryUpgradedClientStateRequest): Promise<_117.QueryUpgradedClientStateResponse>;
                    upgradedConsensusState(request?: _117.QueryUpgradedConsensusStateRequest): Promise<_117.QueryUpgradedConsensusStateResponse>;
                };
                LCDQueryClient: typeof _248.LCDQueryClient;
                registry: ReadonlyArray<[string, import("@cosmjs/proto-signing").GeneratedType]>;
                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
                MessageComposer: {
                    encoded: {
                        createClient(value: _118.MsgCreateClient): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        updateClient(value: _118.MsgUpdateClient): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        upgradeClient(value: _118.MsgUpgradeClient): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        submitMisbehaviour(value: _118.MsgSubmitMisbehaviour): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                    };
                    withTypeUrl: {
                        createClient(value: _118.MsgCreateClient): {
                            typeUrl: string;
                            value: _118.MsgCreateClient;
                        };
                        updateClient(value: _118.MsgUpdateClient): {
                            typeUrl: string;
                            value: _118.MsgUpdateClient;
                        };
                        upgradeClient(value: _118.MsgUpgradeClient): {
                            typeUrl: string;
                            value: _118.MsgUpgradeClient;
                        };
                        submitMisbehaviour(value: _118.MsgSubmitMisbehaviour): {
                            typeUrl: string;
                            value: _118.MsgSubmitMisbehaviour;
                        };
                    };
                    fromPartial: {
                        createClient(value: _118.MsgCreateClient): {
                            typeUrl: string;
                            value: _118.MsgCreateClient;
                        };
                        updateClient(value: _118.MsgUpdateClient): {
                            typeUrl: string;
                            value: _118.MsgUpdateClient;
                        };
                        upgradeClient(value: _118.MsgUpgradeClient): {
                            typeUrl: string;
                            value: _118.MsgUpgradeClient;
                        };
                        submitMisbehaviour(value: _118.MsgSubmitMisbehaviour): {
                            typeUrl: string;
                            value: _118.MsgSubmitMisbehaviour;
                        };
                    };
                };
                AminoConverter: {
                    "/ibc.core.client.v1.MsgCreateClient": {
                        aminoType: string;
                        toAmino: (message: _118.MsgCreateClient) => _118.MsgCreateClientAmino;
                        fromAmino: (object: _118.MsgCreateClientAmino) => _118.MsgCreateClient;
                    };
                    "/ibc.core.client.v1.MsgUpdateClient": {
                        aminoType: string;
                        toAmino: (message: _118.MsgUpdateClient) => _118.MsgUpdateClientAmino;
                        fromAmino: (object: _118.MsgUpdateClientAmino) => _118.MsgUpdateClient;
                    };
                    "/ibc.core.client.v1.MsgUpgradeClient": {
                        aminoType: string;
                        toAmino: (message: _118.MsgUpgradeClient) => _118.MsgUpgradeClientAmino;
                        fromAmino: (object: _118.MsgUpgradeClientAmino) => _118.MsgUpgradeClient;
                    };
                    "/ibc.core.client.v1.MsgSubmitMisbehaviour": {
                        aminoType: string;
                        toAmino: (message: _118.MsgSubmitMisbehaviour) => _118.MsgSubmitMisbehaviourAmino;
                        fromAmino: (object: _118.MsgSubmitMisbehaviourAmino) => _118.MsgSubmitMisbehaviour;
                    };
                };
                MsgCreateClient: {
                    typeUrl: string;
                    encode(message: _118.MsgCreateClient, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _118.MsgCreateClient;
                    fromPartial(object: Partial<_118.MsgCreateClient>): _118.MsgCreateClient;
                    fromAmino(object: _118.MsgCreateClientAmino): _118.MsgCreateClient;
                    toAmino(message: _118.MsgCreateClient): _118.MsgCreateClientAmino;
                    fromAminoMsg(object: _118.MsgCreateClientAminoMsg): _118.MsgCreateClient;
                    toAminoMsg(message: _118.MsgCreateClient): _118.MsgCreateClientAminoMsg;
                    fromProtoMsg(message: _118.MsgCreateClientProtoMsg): _118.MsgCreateClient;
                    toProto(message: _118.MsgCreateClient): Uint8Array;
                    toProtoMsg(message: _118.MsgCreateClient): _118.MsgCreateClientProtoMsg;
                };
                MsgCreateClientResponse: {
                    typeUrl: string;
                    encode(_: _118.MsgCreateClientResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _118.MsgCreateClientResponse;
                    fromPartial(_: Partial<_118.MsgCreateClientResponse>): _118.MsgCreateClientResponse;
                    fromAmino(_: _118.MsgCreateClientResponseAmino): _118.MsgCreateClientResponse;
                    toAmino(_: _118.MsgCreateClientResponse): _118.MsgCreateClientResponseAmino;
                    fromAminoMsg(object: _118.MsgCreateClientResponseAminoMsg): _118.MsgCreateClientResponse;
                    toAminoMsg(message: _118.MsgCreateClientResponse): _118.MsgCreateClientResponseAminoMsg;
                    fromProtoMsg(message: _118.MsgCreateClientResponseProtoMsg): _118.MsgCreateClientResponse;
                    toProto(message: _118.MsgCreateClientResponse): Uint8Array;
                    toProtoMsg(message: _118.MsgCreateClientResponse): _118.MsgCreateClientResponseProtoMsg;
                };
                MsgUpdateClient: {
                    typeUrl: string;
                    encode(message: _118.MsgUpdateClient, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _118.MsgUpdateClient;
                    fromPartial(object: Partial<_118.MsgUpdateClient>): _118.MsgUpdateClient;
                    fromAmino(object: _118.MsgUpdateClientAmino): _118.MsgUpdateClient;
                    toAmino(message: _118.MsgUpdateClient): _118.MsgUpdateClientAmino;
                    fromAminoMsg(object: _118.MsgUpdateClientAminoMsg): _118.MsgUpdateClient;
                    toAminoMsg(message: _118.MsgUpdateClient): _118.MsgUpdateClientAminoMsg;
                    fromProtoMsg(message: _118.MsgUpdateClientProtoMsg): _118.MsgUpdateClient;
                    toProto(message: _118.MsgUpdateClient): Uint8Array;
                    toProtoMsg(message: _118.MsgUpdateClient): _118.MsgUpdateClientProtoMsg;
                };
                MsgUpdateClientResponse: {
                    typeUrl: string;
                    encode(_: _118.MsgUpdateClientResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _118.MsgUpdateClientResponse;
                    fromPartial(_: Partial<_118.MsgUpdateClientResponse>): _118.MsgUpdateClientResponse;
                    fromAmino(_: _118.MsgUpdateClientResponseAmino): _118.MsgUpdateClientResponse;
                    toAmino(_: _118.MsgUpdateClientResponse): _118.MsgUpdateClientResponseAmino;
                    fromAminoMsg(object: _118.MsgUpdateClientResponseAminoMsg): _118.MsgUpdateClientResponse;
                    toAminoMsg(message: _118.MsgUpdateClientResponse): _118.MsgUpdateClientResponseAminoMsg;
                    fromProtoMsg(message: _118.MsgUpdateClientResponseProtoMsg): _118.MsgUpdateClientResponse;
                    toProto(message: _118.MsgUpdateClientResponse): Uint8Array;
                    toProtoMsg(message: _118.MsgUpdateClientResponse): _118.MsgUpdateClientResponseProtoMsg;
                };
                MsgUpgradeClient: {
                    typeUrl: string;
                    encode(message: _118.MsgUpgradeClient, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _118.MsgUpgradeClient;
                    fromPartial(object: Partial<_118.MsgUpgradeClient>): _118.MsgUpgradeClient;
                    fromAmino(object: _118.MsgUpgradeClientAmino): _118.MsgUpgradeClient;
                    toAmino(message: _118.MsgUpgradeClient): _118.MsgUpgradeClientAmino;
                    fromAminoMsg(object: _118.MsgUpgradeClientAminoMsg): _118.MsgUpgradeClient;
                    toAminoMsg(message: _118.MsgUpgradeClient): _118.MsgUpgradeClientAminoMsg;
                    fromProtoMsg(message: _118.MsgUpgradeClientProtoMsg): _118.MsgUpgradeClient;
                    toProto(message: _118.MsgUpgradeClient): Uint8Array;
                    toProtoMsg(message: _118.MsgUpgradeClient): _118.MsgUpgradeClientProtoMsg;
                };
                MsgUpgradeClientResponse: {
                    typeUrl: string;
                    encode(_: _118.MsgUpgradeClientResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _118.MsgUpgradeClientResponse;
                    fromPartial(_: Partial<_118.MsgUpgradeClientResponse>): _118.MsgUpgradeClientResponse;
                    fromAmino(_: _118.MsgUpgradeClientResponseAmino): _118.MsgUpgradeClientResponse;
                    toAmino(_: _118.MsgUpgradeClientResponse): _118.MsgUpgradeClientResponseAmino;
                    fromAminoMsg(object: _118.MsgUpgradeClientResponseAminoMsg): _118.MsgUpgradeClientResponse;
                    toAminoMsg(message: _118.MsgUpgradeClientResponse): _118.MsgUpgradeClientResponseAminoMsg;
                    fromProtoMsg(message: _118.MsgUpgradeClientResponseProtoMsg): _118.MsgUpgradeClientResponse;
                    toProto(message: _118.MsgUpgradeClientResponse): Uint8Array;
                    toProtoMsg(message: _118.MsgUpgradeClientResponse): _118.MsgUpgradeClientResponseProtoMsg;
                };
                MsgSubmitMisbehaviour: {
                    typeUrl: string;
                    encode(message: _118.MsgSubmitMisbehaviour, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _118.MsgSubmitMisbehaviour;
                    fromPartial(object: Partial<_118.MsgSubmitMisbehaviour>): _118.MsgSubmitMisbehaviour;
                    fromAmino(object: _118.MsgSubmitMisbehaviourAmino): _118.MsgSubmitMisbehaviour;
                    toAmino(message: _118.MsgSubmitMisbehaviour): _118.MsgSubmitMisbehaviourAmino;
                    fromAminoMsg(object: _118.MsgSubmitMisbehaviourAminoMsg): _118.MsgSubmitMisbehaviour;
                    toAminoMsg(message: _118.MsgSubmitMisbehaviour): _118.MsgSubmitMisbehaviourAminoMsg;
                    fromProtoMsg(message: _118.MsgSubmitMisbehaviourProtoMsg): _118.MsgSubmitMisbehaviour;
                    toProto(message: _118.MsgSubmitMisbehaviour): Uint8Array;
                    toProtoMsg(message: _118.MsgSubmitMisbehaviour): _118.MsgSubmitMisbehaviourProtoMsg;
                };
                MsgSubmitMisbehaviourResponse: {
                    typeUrl: string;
                    encode(_: _118.MsgSubmitMisbehaviourResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _118.MsgSubmitMisbehaviourResponse;
                    fromPartial(_: Partial<_118.MsgSubmitMisbehaviourResponse>): _118.MsgSubmitMisbehaviourResponse;
                    fromAmino(_: _118.MsgSubmitMisbehaviourResponseAmino): _118.MsgSubmitMisbehaviourResponse;
                    toAmino(_: _118.MsgSubmitMisbehaviourResponse): _118.MsgSubmitMisbehaviourResponseAmino;
                    fromAminoMsg(object: _118.MsgSubmitMisbehaviourResponseAminoMsg): _118.MsgSubmitMisbehaviourResponse;
                    toAminoMsg(message: _118.MsgSubmitMisbehaviourResponse): _118.MsgSubmitMisbehaviourResponseAminoMsg;
                    fromProtoMsg(message: _118.MsgSubmitMisbehaviourResponseProtoMsg): _118.MsgSubmitMisbehaviourResponse;
                    toProto(message: _118.MsgSubmitMisbehaviourResponse): Uint8Array;
                    toProtoMsg(message: _118.MsgSubmitMisbehaviourResponse): _118.MsgSubmitMisbehaviourResponseProtoMsg;
                };
                QueryClientStateRequest: {
                    typeUrl: string;
                    encode(message: _117.QueryClientStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryClientStateRequest;
                    fromPartial(object: Partial<_117.QueryClientStateRequest>): _117.QueryClientStateRequest;
                    fromAmino(object: _117.QueryClientStateRequestAmino): _117.QueryClientStateRequest;
                    toAmino(message: _117.QueryClientStateRequest): _117.QueryClientStateRequestAmino;
                    fromAminoMsg(object: _117.QueryClientStateRequestAminoMsg): _117.QueryClientStateRequest;
                    toAminoMsg(message: _117.QueryClientStateRequest): _117.QueryClientStateRequestAminoMsg;
                    fromProtoMsg(message: _117.QueryClientStateRequestProtoMsg): _117.QueryClientStateRequest;
                    toProto(message: _117.QueryClientStateRequest): Uint8Array;
                    toProtoMsg(message: _117.QueryClientStateRequest): _117.QueryClientStateRequestProtoMsg;
                };
                QueryClientStateResponse: {
                    typeUrl: string;
                    encode(message: _117.QueryClientStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryClientStateResponse;
                    fromPartial(object: Partial<_117.QueryClientStateResponse>): _117.QueryClientStateResponse;
                    fromAmino(object: _117.QueryClientStateResponseAmino): _117.QueryClientStateResponse;
                    toAmino(message: _117.QueryClientStateResponse): _117.QueryClientStateResponseAmino;
                    fromAminoMsg(object: _117.QueryClientStateResponseAminoMsg): _117.QueryClientStateResponse;
                    toAminoMsg(message: _117.QueryClientStateResponse): _117.QueryClientStateResponseAminoMsg;
                    fromProtoMsg(message: _117.QueryClientStateResponseProtoMsg): _117.QueryClientStateResponse;
                    toProto(message: _117.QueryClientStateResponse): Uint8Array;
                    toProtoMsg(message: _117.QueryClientStateResponse): _117.QueryClientStateResponseProtoMsg;
                };
                QueryClientStatesRequest: {
                    typeUrl: string;
                    encode(message: _117.QueryClientStatesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryClientStatesRequest;
                    fromPartial(object: Partial<_117.QueryClientStatesRequest>): _117.QueryClientStatesRequest;
                    fromAmino(object: _117.QueryClientStatesRequestAmino): _117.QueryClientStatesRequest;
                    toAmino(message: _117.QueryClientStatesRequest): _117.QueryClientStatesRequestAmino;
                    fromAminoMsg(object: _117.QueryClientStatesRequestAminoMsg): _117.QueryClientStatesRequest;
                    toAminoMsg(message: _117.QueryClientStatesRequest): _117.QueryClientStatesRequestAminoMsg;
                    fromProtoMsg(message: _117.QueryClientStatesRequestProtoMsg): _117.QueryClientStatesRequest;
                    toProto(message: _117.QueryClientStatesRequest): Uint8Array;
                    toProtoMsg(message: _117.QueryClientStatesRequest): _117.QueryClientStatesRequestProtoMsg;
                };
                QueryClientStatesResponse: {
                    typeUrl: string;
                    encode(message: _117.QueryClientStatesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryClientStatesResponse;
                    fromPartial(object: Partial<_117.QueryClientStatesResponse>): _117.QueryClientStatesResponse;
                    fromAmino(object: _117.QueryClientStatesResponseAmino): _117.QueryClientStatesResponse;
                    toAmino(message: _117.QueryClientStatesResponse): _117.QueryClientStatesResponseAmino;
                    fromAminoMsg(object: _117.QueryClientStatesResponseAminoMsg): _117.QueryClientStatesResponse;
                    toAminoMsg(message: _117.QueryClientStatesResponse): _117.QueryClientStatesResponseAminoMsg;
                    fromProtoMsg(message: _117.QueryClientStatesResponseProtoMsg): _117.QueryClientStatesResponse;
                    toProto(message: _117.QueryClientStatesResponse): Uint8Array;
                    toProtoMsg(message: _117.QueryClientStatesResponse): _117.QueryClientStatesResponseProtoMsg;
                };
                QueryConsensusStateRequest: {
                    typeUrl: string;
                    encode(message: _117.QueryConsensusStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryConsensusStateRequest;
                    fromPartial(object: Partial<_117.QueryConsensusStateRequest>): _117.QueryConsensusStateRequest;
                    fromAmino(object: _117.QueryConsensusStateRequestAmino): _117.QueryConsensusStateRequest;
                    toAmino(message: _117.QueryConsensusStateRequest): _117.QueryConsensusStateRequestAmino;
                    fromAminoMsg(object: _117.QueryConsensusStateRequestAminoMsg): _117.QueryConsensusStateRequest;
                    toAminoMsg(message: _117.QueryConsensusStateRequest): _117.QueryConsensusStateRequestAminoMsg;
                    fromProtoMsg(message: _117.QueryConsensusStateRequestProtoMsg): _117.QueryConsensusStateRequest;
                    toProto(message: _117.QueryConsensusStateRequest): Uint8Array;
                    toProtoMsg(message: _117.QueryConsensusStateRequest): _117.QueryConsensusStateRequestProtoMsg;
                };
                QueryConsensusStateResponse: {
                    typeUrl: string;
                    encode(message: _117.QueryConsensusStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryConsensusStateResponse;
                    fromPartial(object: Partial<_117.QueryConsensusStateResponse>): _117.QueryConsensusStateResponse;
                    fromAmino(object: _117.QueryConsensusStateResponseAmino): _117.QueryConsensusStateResponse;
                    toAmino(message: _117.QueryConsensusStateResponse): _117.QueryConsensusStateResponseAmino;
                    fromAminoMsg(object: _117.QueryConsensusStateResponseAminoMsg): _117.QueryConsensusStateResponse;
                    toAminoMsg(message: _117.QueryConsensusStateResponse): _117.QueryConsensusStateResponseAminoMsg;
                    fromProtoMsg(message: _117.QueryConsensusStateResponseProtoMsg): _117.QueryConsensusStateResponse;
                    toProto(message: _117.QueryConsensusStateResponse): Uint8Array;
                    toProtoMsg(message: _117.QueryConsensusStateResponse): _117.QueryConsensusStateResponseProtoMsg;
                };
                QueryConsensusStatesRequest: {
                    typeUrl: string;
                    encode(message: _117.QueryConsensusStatesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryConsensusStatesRequest;
                    fromPartial(object: Partial<_117.QueryConsensusStatesRequest>): _117.QueryConsensusStatesRequest;
                    fromAmino(object: _117.QueryConsensusStatesRequestAmino): _117.QueryConsensusStatesRequest;
                    toAmino(message: _117.QueryConsensusStatesRequest): _117.QueryConsensusStatesRequestAmino;
                    fromAminoMsg(object: _117.QueryConsensusStatesRequestAminoMsg): _117.QueryConsensusStatesRequest;
                    toAminoMsg(message: _117.QueryConsensusStatesRequest): _117.QueryConsensusStatesRequestAminoMsg;
                    fromProtoMsg(message: _117.QueryConsensusStatesRequestProtoMsg): _117.QueryConsensusStatesRequest;
                    toProto(message: _117.QueryConsensusStatesRequest): Uint8Array;
                    toProtoMsg(message: _117.QueryConsensusStatesRequest): _117.QueryConsensusStatesRequestProtoMsg;
                };
                QueryConsensusStatesResponse: {
                    typeUrl: string;
                    encode(message: _117.QueryConsensusStatesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryConsensusStatesResponse;
                    fromPartial(object: Partial<_117.QueryConsensusStatesResponse>): _117.QueryConsensusStatesResponse;
                    fromAmino(object: _117.QueryConsensusStatesResponseAmino): _117.QueryConsensusStatesResponse;
                    toAmino(message: _117.QueryConsensusStatesResponse): _117.QueryConsensusStatesResponseAmino;
                    fromAminoMsg(object: _117.QueryConsensusStatesResponseAminoMsg): _117.QueryConsensusStatesResponse;
                    toAminoMsg(message: _117.QueryConsensusStatesResponse): _117.QueryConsensusStatesResponseAminoMsg;
                    fromProtoMsg(message: _117.QueryConsensusStatesResponseProtoMsg): _117.QueryConsensusStatesResponse;
                    toProto(message: _117.QueryConsensusStatesResponse): Uint8Array;
                    toProtoMsg(message: _117.QueryConsensusStatesResponse): _117.QueryConsensusStatesResponseProtoMsg;
                };
                QueryClientStatusRequest: {
                    typeUrl: string;
                    encode(message: _117.QueryClientStatusRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryClientStatusRequest;
                    fromPartial(object: Partial<_117.QueryClientStatusRequest>): _117.QueryClientStatusRequest;
                    fromAmino(object: _117.QueryClientStatusRequestAmino): _117.QueryClientStatusRequest;
                    toAmino(message: _117.QueryClientStatusRequest): _117.QueryClientStatusRequestAmino;
                    fromAminoMsg(object: _117.QueryClientStatusRequestAminoMsg): _117.QueryClientStatusRequest;
                    toAminoMsg(message: _117.QueryClientStatusRequest): _117.QueryClientStatusRequestAminoMsg;
                    fromProtoMsg(message: _117.QueryClientStatusRequestProtoMsg): _117.QueryClientStatusRequest;
                    toProto(message: _117.QueryClientStatusRequest): Uint8Array;
                    toProtoMsg(message: _117.QueryClientStatusRequest): _117.QueryClientStatusRequestProtoMsg;
                };
                QueryClientStatusResponse: {
                    typeUrl: string;
                    encode(message: _117.QueryClientStatusResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryClientStatusResponse;
                    fromPartial(object: Partial<_117.QueryClientStatusResponse>): _117.QueryClientStatusResponse;
                    fromAmino(object: _117.QueryClientStatusResponseAmino): _117.QueryClientStatusResponse;
                    toAmino(message: _117.QueryClientStatusResponse): _117.QueryClientStatusResponseAmino;
                    fromAminoMsg(object: _117.QueryClientStatusResponseAminoMsg): _117.QueryClientStatusResponse;
                    toAminoMsg(message: _117.QueryClientStatusResponse): _117.QueryClientStatusResponseAminoMsg;
                    fromProtoMsg(message: _117.QueryClientStatusResponseProtoMsg): _117.QueryClientStatusResponse;
                    toProto(message: _117.QueryClientStatusResponse): Uint8Array;
                    toProtoMsg(message: _117.QueryClientStatusResponse): _117.QueryClientStatusResponseProtoMsg;
                };
                QueryClientParamsRequest: {
                    typeUrl: string;
                    encode(_: _117.QueryClientParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryClientParamsRequest;
                    fromPartial(_: Partial<_117.QueryClientParamsRequest>): _117.QueryClientParamsRequest;
                    fromAmino(_: _117.QueryClientParamsRequestAmino): _117.QueryClientParamsRequest;
                    toAmino(_: _117.QueryClientParamsRequest): _117.QueryClientParamsRequestAmino;
                    fromAminoMsg(object: _117.QueryClientParamsRequestAminoMsg): _117.QueryClientParamsRequest;
                    toAminoMsg(message: _117.QueryClientParamsRequest): _117.QueryClientParamsRequestAminoMsg;
                    fromProtoMsg(message: _117.QueryClientParamsRequestProtoMsg): _117.QueryClientParamsRequest;
                    toProto(message: _117.QueryClientParamsRequest): Uint8Array;
                    toProtoMsg(message: _117.QueryClientParamsRequest): _117.QueryClientParamsRequestProtoMsg;
                };
                QueryClientParamsResponse: {
                    typeUrl: string;
                    encode(message: _117.QueryClientParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryClientParamsResponse;
                    fromPartial(object: Partial<_117.QueryClientParamsResponse>): _117.QueryClientParamsResponse;
                    fromAmino(object: _117.QueryClientParamsResponseAmino): _117.QueryClientParamsResponse;
                    toAmino(message: _117.QueryClientParamsResponse): _117.QueryClientParamsResponseAmino;
                    fromAminoMsg(object: _117.QueryClientParamsResponseAminoMsg): _117.QueryClientParamsResponse;
                    toAminoMsg(message: _117.QueryClientParamsResponse): _117.QueryClientParamsResponseAminoMsg;
                    fromProtoMsg(message: _117.QueryClientParamsResponseProtoMsg): _117.QueryClientParamsResponse;
                    toProto(message: _117.QueryClientParamsResponse): Uint8Array;
                    toProtoMsg(message: _117.QueryClientParamsResponse): _117.QueryClientParamsResponseProtoMsg;
                };
                QueryUpgradedClientStateRequest: {
                    typeUrl: string;
                    encode(_: _117.QueryUpgradedClientStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryUpgradedClientStateRequest;
                    fromPartial(_: Partial<_117.QueryUpgradedClientStateRequest>): _117.QueryUpgradedClientStateRequest;
                    fromAmino(_: _117.QueryUpgradedClientStateRequestAmino): _117.QueryUpgradedClientStateRequest;
                    toAmino(_: _117.QueryUpgradedClientStateRequest): _117.QueryUpgradedClientStateRequestAmino;
                    fromAminoMsg(object: _117.QueryUpgradedClientStateRequestAminoMsg): _117.QueryUpgradedClientStateRequest;
                    toAminoMsg(message: _117.QueryUpgradedClientStateRequest): _117.QueryUpgradedClientStateRequestAminoMsg;
                    fromProtoMsg(message: _117.QueryUpgradedClientStateRequestProtoMsg): _117.QueryUpgradedClientStateRequest;
                    toProto(message: _117.QueryUpgradedClientStateRequest): Uint8Array;
                    toProtoMsg(message: _117.QueryUpgradedClientStateRequest): _117.QueryUpgradedClientStateRequestProtoMsg;
                };
                QueryUpgradedClientStateResponse: {
                    typeUrl: string;
                    encode(message: _117.QueryUpgradedClientStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryUpgradedClientStateResponse;
                    fromPartial(object: Partial<_117.QueryUpgradedClientStateResponse>): _117.QueryUpgradedClientStateResponse;
                    fromAmino(object: _117.QueryUpgradedClientStateResponseAmino): _117.QueryUpgradedClientStateResponse;
                    toAmino(message: _117.QueryUpgradedClientStateResponse): _117.QueryUpgradedClientStateResponseAmino;
                    fromAminoMsg(object: _117.QueryUpgradedClientStateResponseAminoMsg): _117.QueryUpgradedClientStateResponse;
                    toAminoMsg(message: _117.QueryUpgradedClientStateResponse): _117.QueryUpgradedClientStateResponseAminoMsg;
                    fromProtoMsg(message: _117.QueryUpgradedClientStateResponseProtoMsg): _117.QueryUpgradedClientStateResponse;
                    toProto(message: _117.QueryUpgradedClientStateResponse): Uint8Array;
                    toProtoMsg(message: _117.QueryUpgradedClientStateResponse): _117.QueryUpgradedClientStateResponseProtoMsg;
                };
                QueryUpgradedConsensusStateRequest: {
                    typeUrl: string;
                    encode(_: _117.QueryUpgradedConsensusStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryUpgradedConsensusStateRequest;
                    fromPartial(_: Partial<_117.QueryUpgradedConsensusStateRequest>): _117.QueryUpgradedConsensusStateRequest;
                    fromAmino(_: _117.QueryUpgradedConsensusStateRequestAmino): _117.QueryUpgradedConsensusStateRequest;
                    toAmino(_: _117.QueryUpgradedConsensusStateRequest): _117.QueryUpgradedConsensusStateRequestAmino;
                    fromAminoMsg(object: _117.QueryUpgradedConsensusStateRequestAminoMsg): _117.QueryUpgradedConsensusStateRequest;
                    toAminoMsg(message: _117.QueryUpgradedConsensusStateRequest): _117.QueryUpgradedConsensusStateRequestAminoMsg;
                    fromProtoMsg(message: _117.QueryUpgradedConsensusStateRequestProtoMsg): _117.QueryUpgradedConsensusStateRequest;
                    toProto(message: _117.QueryUpgradedConsensusStateRequest): Uint8Array;
                    toProtoMsg(message: _117.QueryUpgradedConsensusStateRequest): _117.QueryUpgradedConsensusStateRequestProtoMsg;
                };
                QueryUpgradedConsensusStateResponse: {
                    typeUrl: string;
                    encode(message: _117.QueryUpgradedConsensusStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _117.QueryUpgradedConsensusStateResponse;
                    fromPartial(object: Partial<_117.QueryUpgradedConsensusStateResponse>): _117.QueryUpgradedConsensusStateResponse;
                    fromAmino(object: _117.QueryUpgradedConsensusStateResponseAmino): _117.QueryUpgradedConsensusStateResponse;
                    toAmino(message: _117.QueryUpgradedConsensusStateResponse): _117.QueryUpgradedConsensusStateResponseAmino;
                    fromAminoMsg(object: _117.QueryUpgradedConsensusStateResponseAminoMsg): _117.QueryUpgradedConsensusStateResponse;
                    toAminoMsg(message: _117.QueryUpgradedConsensusStateResponse): _117.QueryUpgradedConsensusStateResponseAminoMsg;
                    fromProtoMsg(message: _117.QueryUpgradedConsensusStateResponseProtoMsg): _117.QueryUpgradedConsensusStateResponse;
                    toProto(message: _117.QueryUpgradedConsensusStateResponse): Uint8Array;
                    toProtoMsg(message: _117.QueryUpgradedConsensusStateResponse): _117.QueryUpgradedConsensusStateResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: string;
                    encode(message: _116.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _116.GenesisState;
                    fromPartial(object: Partial<_116.GenesisState>): _116.GenesisState;
                    fromAmino(object: _116.GenesisStateAmino): _116.GenesisState;
                    toAmino(message: _116.GenesisState): _116.GenesisStateAmino;
                    fromAminoMsg(object: _116.GenesisStateAminoMsg): _116.GenesisState;
                    toAminoMsg(message: _116.GenesisState): _116.GenesisStateAminoMsg;
                    fromProtoMsg(message: _116.GenesisStateProtoMsg): _116.GenesisState;
                    toProto(message: _116.GenesisState): Uint8Array;
                    toProtoMsg(message: _116.GenesisState): _116.GenesisStateProtoMsg;
                };
                GenesisMetadata: {
                    typeUrl: string;
                    encode(message: _116.GenesisMetadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _116.GenesisMetadata;
                    fromPartial(object: Partial<_116.GenesisMetadata>): _116.GenesisMetadata;
                    fromAmino(object: _116.GenesisMetadataAmino): _116.GenesisMetadata;
                    toAmino(message: _116.GenesisMetadata): _116.GenesisMetadataAmino;
                    fromAminoMsg(object: _116.GenesisMetadataAminoMsg): _116.GenesisMetadata;
                    toAminoMsg(message: _116.GenesisMetadata): _116.GenesisMetadataAminoMsg;
                    fromProtoMsg(message: _116.GenesisMetadataProtoMsg): _116.GenesisMetadata;
                    toProto(message: _116.GenesisMetadata): Uint8Array;
                    toProtoMsg(message: _116.GenesisMetadata): _116.GenesisMetadataProtoMsg;
                };
                IdentifiedGenesisMetadata: {
                    typeUrl: string;
                    encode(message: _116.IdentifiedGenesisMetadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _116.IdentifiedGenesisMetadata;
                    fromPartial(object: Partial<_116.IdentifiedGenesisMetadata>): _116.IdentifiedGenesisMetadata;
                    fromAmino(object: _116.IdentifiedGenesisMetadataAmino): _116.IdentifiedGenesisMetadata;
                    toAmino(message: _116.IdentifiedGenesisMetadata): _116.IdentifiedGenesisMetadataAmino;
                    fromAminoMsg(object: _116.IdentifiedGenesisMetadataAminoMsg): _116.IdentifiedGenesisMetadata;
                    toAminoMsg(message: _116.IdentifiedGenesisMetadata): _116.IdentifiedGenesisMetadataAminoMsg;
                    fromProtoMsg(message: _116.IdentifiedGenesisMetadataProtoMsg): _116.IdentifiedGenesisMetadata;
                    toProto(message: _116.IdentifiedGenesisMetadata): Uint8Array;
                    toProtoMsg(message: _116.IdentifiedGenesisMetadata): _116.IdentifiedGenesisMetadataProtoMsg;
                };
                IdentifiedClientState: {
                    typeUrl: string;
                    encode(message: _115.IdentifiedClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _115.IdentifiedClientState;
                    fromPartial(object: Partial<_115.IdentifiedClientState>): _115.IdentifiedClientState;
                    fromAmino(object: _115.IdentifiedClientStateAmino): _115.IdentifiedClientState;
                    toAmino(message: _115.IdentifiedClientState): _115.IdentifiedClientStateAmino;
                    fromAminoMsg(object: _115.IdentifiedClientStateAminoMsg): _115.IdentifiedClientState;
                    toAminoMsg(message: _115.IdentifiedClientState): _115.IdentifiedClientStateAminoMsg;
                    fromProtoMsg(message: _115.IdentifiedClientStateProtoMsg): _115.IdentifiedClientState;
                    toProto(message: _115.IdentifiedClientState): Uint8Array;
                    toProtoMsg(message: _115.IdentifiedClientState): _115.IdentifiedClientStateProtoMsg;
                };
                ConsensusStateWithHeight: {
                    typeUrl: string;
                    encode(message: _115.ConsensusStateWithHeight, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _115.ConsensusStateWithHeight;
                    fromPartial(object: Partial<_115.ConsensusStateWithHeight>): _115.ConsensusStateWithHeight;
                    fromAmino(object: _115.ConsensusStateWithHeightAmino): _115.ConsensusStateWithHeight;
                    toAmino(message: _115.ConsensusStateWithHeight): _115.ConsensusStateWithHeightAmino;
                    fromAminoMsg(object: _115.ConsensusStateWithHeightAminoMsg): _115.ConsensusStateWithHeight;
                    toAminoMsg(message: _115.ConsensusStateWithHeight): _115.ConsensusStateWithHeightAminoMsg;
                    fromProtoMsg(message: _115.ConsensusStateWithHeightProtoMsg): _115.ConsensusStateWithHeight;
                    toProto(message: _115.ConsensusStateWithHeight): Uint8Array;
                    toProtoMsg(message: _115.ConsensusStateWithHeight): _115.ConsensusStateWithHeightProtoMsg;
                };
                ClientConsensusStates: {
                    typeUrl: string;
                    encode(message: _115.ClientConsensusStates, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _115.ClientConsensusStates;
                    fromPartial(object: Partial<_115.ClientConsensusStates>): _115.ClientConsensusStates;
                    fromAmino(object: _115.ClientConsensusStatesAmino): _115.ClientConsensusStates;
                    toAmino(message: _115.ClientConsensusStates): _115.ClientConsensusStatesAmino;
                    fromAminoMsg(object: _115.ClientConsensusStatesAminoMsg): _115.ClientConsensusStates;
                    toAminoMsg(message: _115.ClientConsensusStates): _115.ClientConsensusStatesAminoMsg;
                    fromProtoMsg(message: _115.ClientConsensusStatesProtoMsg): _115.ClientConsensusStates;
                    toProto(message: _115.ClientConsensusStates): Uint8Array;
                    toProtoMsg(message: _115.ClientConsensusStates): _115.ClientConsensusStatesProtoMsg;
                };
                ClientUpdateProposal: {
                    typeUrl: string;
                    encode(message: _115.ClientUpdateProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _115.ClientUpdateProposal;
                    fromPartial(object: Partial<_115.ClientUpdateProposal>): _115.ClientUpdateProposal;
                    fromAmino(object: _115.ClientUpdateProposalAmino): _115.ClientUpdateProposal;
                    toAmino(message: _115.ClientUpdateProposal): _115.ClientUpdateProposalAmino;
                    fromAminoMsg(object: _115.ClientUpdateProposalAminoMsg): _115.ClientUpdateProposal;
                    toAminoMsg(message: _115.ClientUpdateProposal): _115.ClientUpdateProposalAminoMsg;
                    fromProtoMsg(message: _115.ClientUpdateProposalProtoMsg): _115.ClientUpdateProposal;
                    toProto(message: _115.ClientUpdateProposal): Uint8Array;
                    toProtoMsg(message: _115.ClientUpdateProposal): _115.ClientUpdateProposalProtoMsg;
                };
                UpgradeProposal: {
                    typeUrl: string;
                    encode(message: _115.UpgradeProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _115.UpgradeProposal;
                    fromPartial(object: Partial<_115.UpgradeProposal>): _115.UpgradeProposal;
                    fromAmino(object: _115.UpgradeProposalAmino): _115.UpgradeProposal;
                    toAmino(message: _115.UpgradeProposal): _115.UpgradeProposalAmino;
                    fromAminoMsg(object: _115.UpgradeProposalAminoMsg): _115.UpgradeProposal;
                    toAminoMsg(message: _115.UpgradeProposal): _115.UpgradeProposalAminoMsg;
                    fromProtoMsg(message: _115.UpgradeProposalProtoMsg): _115.UpgradeProposal;
                    toProto(message: _115.UpgradeProposal): Uint8Array;
                    toProtoMsg(message: _115.UpgradeProposal): _115.UpgradeProposalProtoMsg;
                };
                Height: {
                    typeUrl: string;
                    encode(message: _115.Height, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _115.Height;
                    fromPartial(object: Partial<_115.Height>): _115.Height;
                    fromAmino(object: _115.HeightAmino): _115.Height;
                    toAmino(message: _115.Height): _115.HeightAmino;
                    fromAminoMsg(object: _115.HeightAminoMsg): _115.Height;
                    toAminoMsg(message: _115.Height): _115.HeightAminoMsg;
                    fromProtoMsg(message: _115.HeightProtoMsg): _115.Height;
                    toProto(message: _115.Height): Uint8Array;
                    toProtoMsg(message: _115.Height): _115.HeightProtoMsg;
                };
                Params: {
                    typeUrl: string;
                    encode(message: _115.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _115.Params;
                    fromPartial(object: Partial<_115.Params>): _115.Params;
                    fromAmino(object: _115.ParamsAmino): _115.Params;
                    toAmino(message: _115.Params): _115.ParamsAmino;
                    fromAminoMsg(object: _115.ParamsAminoMsg): _115.Params;
                    toAminoMsg(message: _115.Params): _115.ParamsAminoMsg;
                    fromProtoMsg(message: _115.ParamsProtoMsg): _115.Params;
                    toProto(message: _115.Params): Uint8Array;
                    toProtoMsg(message: _115.Params): _115.ParamsProtoMsg;
                };
            };
        }
        namespace commitment {
            const v1: {
                MerkleRoot: {
                    typeUrl: string;
                    encode(message: _119.MerkleRoot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _119.MerkleRoot;
                    fromPartial(object: Partial<_119.MerkleRoot>): _119.MerkleRoot;
                    fromAmino(object: _119.MerkleRootAmino): _119.MerkleRoot;
                    toAmino(message: _119.MerkleRoot): _119.MerkleRootAmino;
                    fromAminoMsg(object: _119.MerkleRootAminoMsg): _119.MerkleRoot;
                    toAminoMsg(message: _119.MerkleRoot): _119.MerkleRootAminoMsg;
                    fromProtoMsg(message: _119.MerkleRootProtoMsg): _119.MerkleRoot;
                    toProto(message: _119.MerkleRoot): Uint8Array;
                    toProtoMsg(message: _119.MerkleRoot): _119.MerkleRootProtoMsg;
                };
                MerklePrefix: {
                    typeUrl: string;
                    encode(message: _119.MerklePrefix, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _119.MerklePrefix;
                    fromPartial(object: Partial<_119.MerklePrefix>): _119.MerklePrefix;
                    fromAmino(object: _119.MerklePrefixAmino): _119.MerklePrefix;
                    toAmino(message: _119.MerklePrefix): _119.MerklePrefixAmino;
                    fromAminoMsg(object: _119.MerklePrefixAminoMsg): _119.MerklePrefix;
                    toAminoMsg(message: _119.MerklePrefix): _119.MerklePrefixAminoMsg;
                    fromProtoMsg(message: _119.MerklePrefixProtoMsg): _119.MerklePrefix;
                    toProto(message: _119.MerklePrefix): Uint8Array;
                    toProtoMsg(message: _119.MerklePrefix): _119.MerklePrefixProtoMsg;
                };
                MerklePath: {
                    typeUrl: string;
                    encode(message: _119.MerklePath, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _119.MerklePath;
                    fromPartial(object: Partial<_119.MerklePath>): _119.MerklePath;
                    fromAmino(object: _119.MerklePathAmino): _119.MerklePath;
                    toAmino(message: _119.MerklePath): _119.MerklePathAmino;
                    fromAminoMsg(object: _119.MerklePathAminoMsg): _119.MerklePath;
                    toAminoMsg(message: _119.MerklePath): _119.MerklePathAminoMsg;
                    fromProtoMsg(message: _119.MerklePathProtoMsg): _119.MerklePath;
                    toProto(message: _119.MerklePath): Uint8Array;
                    toProtoMsg(message: _119.MerklePath): _119.MerklePathProtoMsg;
                };
                MerkleProof: {
                    typeUrl: string;
                    encode(message: _119.MerkleProof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _119.MerkleProof;
                    fromPartial(object: Partial<_119.MerkleProof>): _119.MerkleProof;
                    fromAmino(object: _119.MerkleProofAmino): _119.MerkleProof;
                    toAmino(message: _119.MerkleProof): _119.MerkleProofAmino;
                    fromAminoMsg(object: _119.MerkleProofAminoMsg): _119.MerkleProof;
                    toAminoMsg(message: _119.MerkleProof): _119.MerkleProofAminoMsg;
                    fromProtoMsg(message: _119.MerkleProofProtoMsg): _119.MerkleProof;
                    toProto(message: _119.MerkleProof): Uint8Array;
                    toProtoMsg(message: _119.MerkleProof): _119.MerkleProofProtoMsg;
                };
            };
        }
        namespace connection {
            const v1: {
                MsgClientImpl: typeof _257.MsgClientImpl;
                QueryClientImpl: typeof _253.QueryClientImpl;
                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
                    connection(request: _122.QueryConnectionRequest): Promise<_122.QueryConnectionResponse>;
                    connections(request?: _122.QueryConnectionsRequest): Promise<_122.QueryConnectionsResponse>;
                    clientConnections(request: _122.QueryClientConnectionsRequest): Promise<_122.QueryClientConnectionsResponse>;
                    connectionClientState(request: _122.QueryConnectionClientStateRequest): Promise<_122.QueryConnectionClientStateResponse>;
                    connectionConsensusState(request: _122.QueryConnectionConsensusStateRequest): Promise<_122.QueryConnectionConsensusStateResponse>;
                };
                LCDQueryClient: typeof _249.LCDQueryClient;
                registry: ReadonlyArray<[string, import("@cosmjs/proto-signing").GeneratedType]>;
                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
                MessageComposer: {
                    encoded: {
                        connectionOpenInit(value: _123.MsgConnectionOpenInit): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        connectionOpenTry(value: _123.MsgConnectionOpenTry): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        connectionOpenAck(value: _123.MsgConnectionOpenAck): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                        connectionOpenConfirm(value: _123.MsgConnectionOpenConfirm): {
                            typeUrl: string;
                            value: Uint8Array;
                        };
                    };
                    withTypeUrl: {
                        connectionOpenInit(value: _123.MsgConnectionOpenInit): {
                            typeUrl: string;
                            value: _123.MsgConnectionOpenInit;
                        };
                        connectionOpenTry(value: _123.MsgConnectionOpenTry): {
                            typeUrl: string;
                            value: _123.MsgConnectionOpenTry;
                        };
                        connectionOpenAck(value: _123.MsgConnectionOpenAck): {
                            typeUrl: string;
                            value: _123.MsgConnectionOpenAck;
                        };
                        connectionOpenConfirm(value: _123.MsgConnectionOpenConfirm): {
                            typeUrl: string;
                            value: _123.MsgConnectionOpenConfirm;
                        };
                    };
                    fromPartial: {
                        connectionOpenInit(value: _123.MsgConnectionOpenInit): {
                            typeUrl: string;
                            value: _123.MsgConnectionOpenInit;
                        };
                        connectionOpenTry(value: _123.MsgConnectionOpenTry): {
                            typeUrl: string;
                            value: _123.MsgConnectionOpenTry;
                        };
                        connectionOpenAck(value: _123.MsgConnectionOpenAck): {
                            typeUrl: string;
                            value: _123.MsgConnectionOpenAck;
                        };
                        connectionOpenConfirm(value: _123.MsgConnectionOpenConfirm): {
                            typeUrl: string;
                            value: _123.MsgConnectionOpenConfirm;
                        };
                    };
                };
                AminoConverter: {
                    "/ibc.core.connection.v1.MsgConnectionOpenInit": {
                        aminoType: string;
                        toAmino: (message: _123.MsgConnectionOpenInit) => _123.MsgConnectionOpenInitAmino;
                        fromAmino: (object: _123.MsgConnectionOpenInitAmino) => _123.MsgConnectionOpenInit;
                    };
                    "/ibc.core.connection.v1.MsgConnectionOpenTry": {
                        aminoType: string;
                        toAmino: (message: _123.MsgConnectionOpenTry) => _123.MsgConnectionOpenTryAmino;
                        fromAmino: (object: _123.MsgConnectionOpenTryAmino) => _123.MsgConnectionOpenTry;
                    };
                    "/ibc.core.connection.v1.MsgConnectionOpenAck": {
                        aminoType: string;
                        toAmino: (message: _123.MsgConnectionOpenAck) => _123.MsgConnectionOpenAckAmino;
                        fromAmino: (object: _123.MsgConnectionOpenAckAmino) => _123.MsgConnectionOpenAck;
                    };
                    "/ibc.core.connection.v1.MsgConnectionOpenConfirm": {
                        aminoType: string;
                        toAmino: (message: _123.MsgConnectionOpenConfirm) => _123.MsgConnectionOpenConfirmAmino;
                        fromAmino: (object: _123.MsgConnectionOpenConfirmAmino) => _123.MsgConnectionOpenConfirm;
                    };
                };
                MsgConnectionOpenInit: {
                    typeUrl: string;
                    encode(message: _123.MsgConnectionOpenInit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.MsgConnectionOpenInit;
                    fromPartial(object: Partial<_123.MsgConnectionOpenInit>): _123.MsgConnectionOpenInit;
                    fromAmino(object: _123.MsgConnectionOpenInitAmino): _123.MsgConnectionOpenInit;
                    toAmino(message: _123.MsgConnectionOpenInit): _123.MsgConnectionOpenInitAmino;
                    fromAminoMsg(object: _123.MsgConnectionOpenInitAminoMsg): _123.MsgConnectionOpenInit;
                    toAminoMsg(message: _123.MsgConnectionOpenInit): _123.MsgConnectionOpenInitAminoMsg;
                    fromProtoMsg(message: _123.MsgConnectionOpenInitProtoMsg): _123.MsgConnectionOpenInit;
                    toProto(message: _123.MsgConnectionOpenInit): Uint8Array;
                    toProtoMsg(message: _123.MsgConnectionOpenInit): _123.MsgConnectionOpenInitProtoMsg;
                };
                MsgConnectionOpenInitResponse: {
                    typeUrl: string;
                    encode(_: _123.MsgConnectionOpenInitResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.MsgConnectionOpenInitResponse;
                    fromPartial(_: Partial<_123.MsgConnectionOpenInitResponse>): _123.MsgConnectionOpenInitResponse;
                    fromAmino(_: _123.MsgConnectionOpenInitResponseAmino): _123.MsgConnectionOpenInitResponse;
                    toAmino(_: _123.MsgConnectionOpenInitResponse): _123.MsgConnectionOpenInitResponseAmino;
                    fromAminoMsg(object: _123.MsgConnectionOpenInitResponseAminoMsg): _123.MsgConnectionOpenInitResponse;
                    toAminoMsg(message: _123.MsgConnectionOpenInitResponse): _123.MsgConnectionOpenInitResponseAminoMsg;
                    fromProtoMsg(message: _123.MsgConnectionOpenInitResponseProtoMsg): _123.MsgConnectionOpenInitResponse;
                    toProto(message: _123.MsgConnectionOpenInitResponse): Uint8Array;
                    toProtoMsg(message: _123.MsgConnectionOpenInitResponse): _123.MsgConnectionOpenInitResponseProtoMsg;
                };
                MsgConnectionOpenTry: {
                    typeUrl: string;
                    encode(message: _123.MsgConnectionOpenTry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.MsgConnectionOpenTry;
                    fromPartial(object: Partial<_123.MsgConnectionOpenTry>): _123.MsgConnectionOpenTry;
                    fromAmino(object: _123.MsgConnectionOpenTryAmino): _123.MsgConnectionOpenTry;
                    toAmino(message: _123.MsgConnectionOpenTry): _123.MsgConnectionOpenTryAmino;
                    fromAminoMsg(object: _123.MsgConnectionOpenTryAminoMsg): _123.MsgConnectionOpenTry;
                    toAminoMsg(message: _123.MsgConnectionOpenTry): _123.MsgConnectionOpenTryAminoMsg;
                    fromProtoMsg(message: _123.MsgConnectionOpenTryProtoMsg): _123.MsgConnectionOpenTry;
                    toProto(message: _123.MsgConnectionOpenTry): Uint8Array;
                    toProtoMsg(message: _123.MsgConnectionOpenTry): _123.MsgConnectionOpenTryProtoMsg;
                };
                MsgConnectionOpenTryResponse: {
                    typeUrl: string;
                    encode(_: _123.MsgConnectionOpenTryResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.MsgConnectionOpenTryResponse;
                    fromPartial(_: Partial<_123.MsgConnectionOpenTryResponse>): _123.MsgConnectionOpenTryResponse;
                    fromAmino(_: _123.MsgConnectionOpenTryResponseAmino): _123.MsgConnectionOpenTryResponse;
                    toAmino(_: _123.MsgConnectionOpenTryResponse): _123.MsgConnectionOpenTryResponseAmino;
                    fromAminoMsg(object: _123.MsgConnectionOpenTryResponseAminoMsg): _123.MsgConnectionOpenTryResponse;
                    toAminoMsg(message: _123.MsgConnectionOpenTryResponse): _123.MsgConnectionOpenTryResponseAminoMsg;
                    fromProtoMsg(message: _123.MsgConnectionOpenTryResponseProtoMsg): _123.MsgConnectionOpenTryResponse;
                    toProto(message: _123.MsgConnectionOpenTryResponse): Uint8Array;
                    toProtoMsg(message: _123.MsgConnectionOpenTryResponse): _123.MsgConnectionOpenTryResponseProtoMsg;
                };
                MsgConnectionOpenAck: {
                    typeUrl: string;
                    encode(message: _123.MsgConnectionOpenAck, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.MsgConnectionOpenAck;
                    fromPartial(object: Partial<_123.MsgConnectionOpenAck>): _123.MsgConnectionOpenAck;
                    fromAmino(object: _123.MsgConnectionOpenAckAmino): _123.MsgConnectionOpenAck;
                    toAmino(message: _123.MsgConnectionOpenAck): _123.MsgConnectionOpenAckAmino;
                    fromAminoMsg(object: _123.MsgConnectionOpenAckAminoMsg): _123.MsgConnectionOpenAck;
                    toAminoMsg(message: _123.MsgConnectionOpenAck): _123.MsgConnectionOpenAckAminoMsg;
                    fromProtoMsg(message: _123.MsgConnectionOpenAckProtoMsg): _123.MsgConnectionOpenAck;
                    toProto(message: _123.MsgConnectionOpenAck): Uint8Array;
                    toProtoMsg(message: _123.MsgConnectionOpenAck): _123.MsgConnectionOpenAckProtoMsg;
                };
                MsgConnectionOpenAckResponse: {
                    typeUrl: string;
                    encode(_: _123.MsgConnectionOpenAckResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.MsgConnectionOpenAckResponse;
                    fromPartial(_: Partial<_123.MsgConnectionOpenAckResponse>): _123.MsgConnectionOpenAckResponse;
                    fromAmino(_: _123.MsgConnectionOpenAckResponseAmino): _123.MsgConnectionOpenAckResponse;
                    toAmino(_: _123.MsgConnectionOpenAckResponse): _123.MsgConnectionOpenAckResponseAmino;
                    fromAminoMsg(object: _123.MsgConnectionOpenAckResponseAminoMsg): _123.MsgConnectionOpenAckResponse;
                    toAminoMsg(message: _123.MsgConnectionOpenAckResponse): _123.MsgConnectionOpenAckResponseAminoMsg;
                    fromProtoMsg(message: _123.MsgConnectionOpenAckResponseProtoMsg): _123.MsgConnectionOpenAckResponse;
                    toProto(message: _123.MsgConnectionOpenAckResponse): Uint8Array;
                    toProtoMsg(message: _123.MsgConnectionOpenAckResponse): _123.MsgConnectionOpenAckResponseProtoMsg;
                };
                MsgConnectionOpenConfirm: {
                    typeUrl: string;
                    encode(message: _123.MsgConnectionOpenConfirm, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.MsgConnectionOpenConfirm;
                    fromPartial(object: Partial<_123.MsgConnectionOpenConfirm>): _123.MsgConnectionOpenConfirm;
                    fromAmino(object: _123.MsgConnectionOpenConfirmAmino): _123.MsgConnectionOpenConfirm;
                    toAmino(message: _123.MsgConnectionOpenConfirm): _123.MsgConnectionOpenConfirmAmino;
                    fromAminoMsg(object: _123.MsgConnectionOpenConfirmAminoMsg): _123.MsgConnectionOpenConfirm;
                    toAminoMsg(message: _123.MsgConnectionOpenConfirm): _123.MsgConnectionOpenConfirmAminoMsg;
                    fromProtoMsg(message: _123.MsgConnectionOpenConfirmProtoMsg): _123.MsgConnectionOpenConfirm;
                    toProto(message: _123.MsgConnectionOpenConfirm): Uint8Array;
                    toProtoMsg(message: _123.MsgConnectionOpenConfirm): _123.MsgConnectionOpenConfirmProtoMsg;
                };
                MsgConnectionOpenConfirmResponse: {
                    typeUrl: string;
                    encode(_: _123.MsgConnectionOpenConfirmResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _123.MsgConnectionOpenConfirmResponse;
                    fromPartial(_: Partial<_123.MsgConnectionOpenConfirmResponse>): _123.MsgConnectionOpenConfirmResponse;
                    fromAmino(_: _123.MsgConnectionOpenConfirmResponseAmino): _123.MsgConnectionOpenConfirmResponse;
                    toAmino(_: _123.MsgConnectionOpenConfirmResponse): _123.MsgConnectionOpenConfirmResponseAmino;
                    fromAminoMsg(object: _123.MsgConnectionOpenConfirmResponseAminoMsg): _123.MsgConnectionOpenConfirmResponse;
                    toAminoMsg(message: _123.MsgConnectionOpenConfirmResponse): _123.MsgConnectionOpenConfirmResponseAminoMsg;
                    fromProtoMsg(message: _123.MsgConnectionOpenConfirmResponseProtoMsg): _123.MsgConnectionOpenConfirmResponse;
                    toProto(message: _123.MsgConnectionOpenConfirmResponse): Uint8Array;
                    toProtoMsg(message: _123.MsgConnectionOpenConfirmResponse): _123.MsgConnectionOpenConfirmResponseProtoMsg;
                };
                QueryConnectionRequest: {
                    typeUrl: string;
                    encode(message: _122.QueryConnectionRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryConnectionRequest;
                    fromPartial(object: Partial<_122.QueryConnectionRequest>): _122.QueryConnectionRequest;
                    fromAmino(object: _122.QueryConnectionRequestAmino): _122.QueryConnectionRequest;
                    toAmino(message: _122.QueryConnectionRequest): _122.QueryConnectionRequestAmino;
                    fromAminoMsg(object: _122.QueryConnectionRequestAminoMsg): _122.QueryConnectionRequest;
                    toAminoMsg(message: _122.QueryConnectionRequest): _122.QueryConnectionRequestAminoMsg;
                    fromProtoMsg(message: _122.QueryConnectionRequestProtoMsg): _122.QueryConnectionRequest;
                    toProto(message: _122.QueryConnectionRequest): Uint8Array;
                    toProtoMsg(message: _122.QueryConnectionRequest): _122.QueryConnectionRequestProtoMsg;
                };
                QueryConnectionResponse: {
                    typeUrl: string;
                    encode(message: _122.QueryConnectionResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryConnectionResponse;
                    fromPartial(object: Partial<_122.QueryConnectionResponse>): _122.QueryConnectionResponse;
                    fromAmino(object: _122.QueryConnectionResponseAmino): _122.QueryConnectionResponse;
                    toAmino(message: _122.QueryConnectionResponse): _122.QueryConnectionResponseAmino;
                    fromAminoMsg(object: _122.QueryConnectionResponseAminoMsg): _122.QueryConnectionResponse;
                    toAminoMsg(message: _122.QueryConnectionResponse): _122.QueryConnectionResponseAminoMsg;
                    fromProtoMsg(message: _122.QueryConnectionResponseProtoMsg): _122.QueryConnectionResponse;
                    toProto(message: _122.QueryConnectionResponse): Uint8Array;
                    toProtoMsg(message: _122.QueryConnectionResponse): _122.QueryConnectionResponseProtoMsg;
                };
                QueryConnectionsRequest: {
                    typeUrl: string;
                    encode(message: _122.QueryConnectionsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryConnectionsRequest;
                    fromPartial(object: Partial<_122.QueryConnectionsRequest>): _122.QueryConnectionsRequest;
                    fromAmino(object: _122.QueryConnectionsRequestAmino): _122.QueryConnectionsRequest;
                    toAmino(message: _122.QueryConnectionsRequest): _122.QueryConnectionsRequestAmino;
                    fromAminoMsg(object: _122.QueryConnectionsRequestAminoMsg): _122.QueryConnectionsRequest;
                    toAminoMsg(message: _122.QueryConnectionsRequest): _122.QueryConnectionsRequestAminoMsg;
                    fromProtoMsg(message: _122.QueryConnectionsRequestProtoMsg): _122.QueryConnectionsRequest;
                    toProto(message: _122.QueryConnectionsRequest): Uint8Array;
                    toProtoMsg(message: _122.QueryConnectionsRequest): _122.QueryConnectionsRequestProtoMsg;
                };
                QueryConnectionsResponse: {
                    typeUrl: string;
                    encode(message: _122.QueryConnectionsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryConnectionsResponse;
                    fromPartial(object: Partial<_122.QueryConnectionsResponse>): _122.QueryConnectionsResponse;
                    fromAmino(object: _122.QueryConnectionsResponseAmino): _122.QueryConnectionsResponse;
                    toAmino(message: _122.QueryConnectionsResponse): _122.QueryConnectionsResponseAmino;
                    fromAminoMsg(object: _122.QueryConnectionsResponseAminoMsg): _122.QueryConnectionsResponse;
                    toAminoMsg(message: _122.QueryConnectionsResponse): _122.QueryConnectionsResponseAminoMsg;
                    fromProtoMsg(message: _122.QueryConnectionsResponseProtoMsg): _122.QueryConnectionsResponse;
                    toProto(message: _122.QueryConnectionsResponse): Uint8Array;
                    toProtoMsg(message: _122.QueryConnectionsResponse): _122.QueryConnectionsResponseProtoMsg;
                };
                QueryClientConnectionsRequest: {
                    typeUrl: string;
                    encode(message: _122.QueryClientConnectionsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryClientConnectionsRequest;
                    fromPartial(object: Partial<_122.QueryClientConnectionsRequest>): _122.QueryClientConnectionsRequest;
                    fromAmino(object: _122.QueryClientConnectionsRequestAmino): _122.QueryClientConnectionsRequest;
                    toAmino(message: _122.QueryClientConnectionsRequest): _122.QueryClientConnectionsRequestAmino;
                    fromAminoMsg(object: _122.QueryClientConnectionsRequestAminoMsg): _122.QueryClientConnectionsRequest;
                    toAminoMsg(message: _122.QueryClientConnectionsRequest): _122.QueryClientConnectionsRequestAminoMsg;
                    fromProtoMsg(message: _122.QueryClientConnectionsRequestProtoMsg): _122.QueryClientConnectionsRequest;
                    toProto(message: _122.QueryClientConnectionsRequest): Uint8Array;
                    toProtoMsg(message: _122.QueryClientConnectionsRequest): _122.QueryClientConnectionsRequestProtoMsg;
                };
                QueryClientConnectionsResponse: {
                    typeUrl: string;
                    encode(message: _122.QueryClientConnectionsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryClientConnectionsResponse;
                    fromPartial(object: Partial<_122.QueryClientConnectionsResponse>): _122.QueryClientConnectionsResponse;
                    fromAmino(object: _122.QueryClientConnectionsResponseAmino): _122.QueryClientConnectionsResponse;
                    toAmino(message: _122.QueryClientConnectionsResponse): _122.QueryClientConnectionsResponseAmino;
                    fromAminoMsg(object: _122.QueryClientConnectionsResponseAminoMsg): _122.QueryClientConnectionsResponse;
                    toAminoMsg(message: _122.QueryClientConnectionsResponse): _122.QueryClientConnectionsResponseAminoMsg;
                    fromProtoMsg(message: _122.QueryClientConnectionsResponseProtoMsg): _122.QueryClientConnectionsResponse;
                    toProto(message: _122.QueryClientConnectionsResponse): Uint8Array;
                    toProtoMsg(message: _122.QueryClientConnectionsResponse): _122.QueryClientConnectionsResponseProtoMsg;
                };
                QueryConnectionClientStateRequest: {
                    typeUrl: string;
                    encode(message: _122.QueryConnectionClientStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryConnectionClientStateRequest;
                    fromPartial(object: Partial<_122.QueryConnectionClientStateRequest>): _122.QueryConnectionClientStateRequest;
                    fromAmino(object: _122.QueryConnectionClientStateRequestAmino): _122.QueryConnectionClientStateRequest;
                    toAmino(message: _122.QueryConnectionClientStateRequest): _122.QueryConnectionClientStateRequestAmino;
                    fromAminoMsg(object: _122.QueryConnectionClientStateRequestAminoMsg): _122.QueryConnectionClientStateRequest;
                    toAminoMsg(message: _122.QueryConnectionClientStateRequest): _122.QueryConnectionClientStateRequestAminoMsg;
                    fromProtoMsg(message: _122.QueryConnectionClientStateRequestProtoMsg): _122.QueryConnectionClientStateRequest;
                    toProto(message: _122.QueryConnectionClientStateRequest): Uint8Array;
                    toProtoMsg(message: _122.QueryConnectionClientStateRequest): _122.QueryConnectionClientStateRequestProtoMsg;
                };
                QueryConnectionClientStateResponse: {
                    typeUrl: string;
                    encode(message: _122.QueryConnectionClientStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryConnectionClientStateResponse;
                    fromPartial(object: Partial<_122.QueryConnectionClientStateResponse>): _122.QueryConnectionClientStateResponse;
                    fromAmino(object: _122.QueryConnectionClientStateResponseAmino): _122.QueryConnectionClientStateResponse;
                    toAmino(message: _122.QueryConnectionClientStateResponse): _122.QueryConnectionClientStateResponseAmino;
                    fromAminoMsg(object: _122.QueryConnectionClientStateResponseAminoMsg): _122.QueryConnectionClientStateResponse;
                    toAminoMsg(message: _122.QueryConnectionClientStateResponse): _122.QueryConnectionClientStateResponseAminoMsg;
                    fromProtoMsg(message: _122.QueryConnectionClientStateResponseProtoMsg): _122.QueryConnectionClientStateResponse;
                    toProto(message: _122.QueryConnectionClientStateResponse): Uint8Array;
                    toProtoMsg(message: _122.QueryConnectionClientStateResponse): _122.QueryConnectionClientStateResponseProtoMsg;
                };
                QueryConnectionConsensusStateRequest: {
                    typeUrl: string;
                    encode(message: _122.QueryConnectionConsensusStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryConnectionConsensusStateRequest;
                    fromPartial(object: Partial<_122.QueryConnectionConsensusStateRequest>): _122.QueryConnectionConsensusStateRequest;
                    fromAmino(object: _122.QueryConnectionConsensusStateRequestAmino): _122.QueryConnectionConsensusStateRequest;
                    toAmino(message: _122.QueryConnectionConsensusStateRequest): _122.QueryConnectionConsensusStateRequestAmino;
                    fromAminoMsg(object: _122.QueryConnectionConsensusStateRequestAminoMsg): _122.QueryConnectionConsensusStateRequest;
                    toAminoMsg(message: _122.QueryConnectionConsensusStateRequest): _122.QueryConnectionConsensusStateRequestAminoMsg;
                    fromProtoMsg(message: _122.QueryConnectionConsensusStateRequestProtoMsg): _122.QueryConnectionConsensusStateRequest;
                    toProto(message: _122.QueryConnectionConsensusStateRequest): Uint8Array;
                    toProtoMsg(message: _122.QueryConnectionConsensusStateRequest): _122.QueryConnectionConsensusStateRequestProtoMsg;
                };
                QueryConnectionConsensusStateResponse: {
                    typeUrl: string;
                    encode(message: _122.QueryConnectionConsensusStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _122.QueryConnectionConsensusStateResponse;
                    fromPartial(object: Partial<_122.QueryConnectionConsensusStateResponse>): _122.QueryConnectionConsensusStateResponse;
                    fromAmino(object: _122.QueryConnectionConsensusStateResponseAmino): _122.QueryConnectionConsensusStateResponse;
                    toAmino(message: _122.QueryConnectionConsensusStateResponse): _122.QueryConnectionConsensusStateResponseAmino;
                    fromAminoMsg(object: _122.QueryConnectionConsensusStateResponseAminoMsg): _122.QueryConnectionConsensusStateResponse;
                    toAminoMsg(message: _122.QueryConnectionConsensusStateResponse): _122.QueryConnectionConsensusStateResponseAminoMsg;
                    fromProtoMsg(message: _122.QueryConnectionConsensusStateResponseProtoMsg): _122.QueryConnectionConsensusStateResponse;
                    toProto(message: _122.QueryConnectionConsensusStateResponse): Uint8Array;
                    toProtoMsg(message: _122.QueryConnectionConsensusStateResponse): _122.QueryConnectionConsensusStateResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: string;
                    encode(message: _121.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _121.GenesisState;
                    fromPartial(object: Partial<_121.GenesisState>): _121.GenesisState;
                    fromAmino(object: _121.GenesisStateAmino): _121.GenesisState;
                    toAmino(message: _121.GenesisState): _121.GenesisStateAmino;
                    fromAminoMsg(object: _121.GenesisStateAminoMsg): _121.GenesisState;
                    toAminoMsg(message: _121.GenesisState): _121.GenesisStateAminoMsg;
                    fromProtoMsg(message: _121.GenesisStateProtoMsg): _121.GenesisState;
                    toProto(message: _121.GenesisState): Uint8Array;
                    toProtoMsg(message: _121.GenesisState): _121.GenesisStateProtoMsg;
                };
                stateFromJSON(object: any): _120.State;
                stateToJSON(object: _120.State): string;
                State: typeof _120.State;
                StateSDKType: typeof _120.State;
                StateAmino: typeof _120.State;
                ConnectionEnd: {
                    typeUrl: string;
                    encode(message: _120.ConnectionEnd, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _120.ConnectionEnd;
                    fromPartial(object: Partial<_120.ConnectionEnd>): _120.ConnectionEnd;
                    fromAmino(object: _120.ConnectionEndAmino): _120.ConnectionEnd;
                    toAmino(message: _120.ConnectionEnd): _120.ConnectionEndAmino;
                    fromAminoMsg(object: _120.ConnectionEndAminoMsg): _120.ConnectionEnd;
                    toAminoMsg(message: _120.ConnectionEnd): _120.ConnectionEndAminoMsg;
                    fromProtoMsg(message: _120.ConnectionEndProtoMsg): _120.ConnectionEnd;
                    toProto(message: _120.ConnectionEnd): Uint8Array;
                    toProtoMsg(message: _120.ConnectionEnd): _120.ConnectionEndProtoMsg;
                };
                IdentifiedConnection: {
                    typeUrl: string;
                    encode(message: _120.IdentifiedConnection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _120.IdentifiedConnection;
                    fromPartial(object: Partial<_120.IdentifiedConnection>): _120.IdentifiedConnection;
                    fromAmino(object: _120.IdentifiedConnectionAmino): _120.IdentifiedConnection;
                    toAmino(message: _120.IdentifiedConnection): _120.IdentifiedConnectionAmino;
                    fromAminoMsg(object: _120.IdentifiedConnectionAminoMsg): _120.IdentifiedConnection;
                    toAminoMsg(message: _120.IdentifiedConnection): _120.IdentifiedConnectionAminoMsg;
                    fromProtoMsg(message: _120.IdentifiedConnectionProtoMsg): _120.IdentifiedConnection;
                    toProto(message: _120.IdentifiedConnection): Uint8Array;
                    toProtoMsg(message: _120.IdentifiedConnection): _120.IdentifiedConnectionProtoMsg;
                };
                Counterparty: {
                    typeUrl: string;
                    encode(message: _120.Counterparty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _120.Counterparty;
                    fromPartial(object: Partial<_120.Counterparty>): _120.Counterparty;
                    fromAmino(object: _120.CounterpartyAmino): _120.Counterparty;
                    toAmino(message: _120.Counterparty): _120.CounterpartyAmino;
                    fromAminoMsg(object: _120.CounterpartyAminoMsg): _120.Counterparty;
                    toAminoMsg(message: _120.Counterparty): _120.CounterpartyAminoMsg;
                    fromProtoMsg(message: _120.CounterpartyProtoMsg): _120.Counterparty;
                    toProto(message: _120.Counterparty): Uint8Array;
                    toProtoMsg(message: _120.Counterparty): _120.CounterpartyProtoMsg;
                };
                ClientPaths: {
                    typeUrl: string;
                    encode(message: _120.ClientPaths, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _120.ClientPaths;
                    fromPartial(object: Partial<_120.ClientPaths>): _120.ClientPaths;
                    fromAmino(object: _120.ClientPathsAmino): _120.ClientPaths;
                    toAmino(message: _120.ClientPaths): _120.ClientPathsAmino;
                    fromAminoMsg(object: _120.ClientPathsAminoMsg): _120.ClientPaths;
                    toAminoMsg(message: _120.ClientPaths): _120.ClientPathsAminoMsg;
                    fromProtoMsg(message: _120.ClientPathsProtoMsg): _120.ClientPaths;
                    toProto(message: _120.ClientPaths): Uint8Array;
                    toProtoMsg(message: _120.ClientPaths): _120.ClientPathsProtoMsg;
                };
                ConnectionPaths: {
                    typeUrl: string;
                    encode(message: _120.ConnectionPaths, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _120.ConnectionPaths;
                    fromPartial(object: Partial<_120.ConnectionPaths>): _120.ConnectionPaths;
                    fromAmino(object: _120.ConnectionPathsAmino): _120.ConnectionPaths;
                    toAmino(message: _120.ConnectionPaths): _120.ConnectionPathsAmino;
                    fromAminoMsg(object: _120.ConnectionPathsAminoMsg): _120.ConnectionPaths;
                    toAminoMsg(message: _120.ConnectionPaths): _120.ConnectionPathsAminoMsg;
                    fromProtoMsg(message: _120.ConnectionPathsProtoMsg): _120.ConnectionPaths;
                    toProto(message: _120.ConnectionPaths): Uint8Array;
                    toProtoMsg(message: _120.ConnectionPaths): _120.ConnectionPathsProtoMsg;
                };
                Version: {
                    typeUrl: string;
                    encode(message: _120.Version, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _120.Version;
                    fromPartial(object: Partial<_120.Version>): _120.Version;
                    fromAmino(object: _120.VersionAmino): _120.Version;
                    toAmino(message: _120.Version): _120.VersionAmino;
                    fromAminoMsg(object: _120.VersionAminoMsg): _120.Version;
                    toAminoMsg(message: _120.Version): _120.VersionAminoMsg;
                    fromProtoMsg(message: _120.VersionProtoMsg): _120.Version;
                    toProto(message: _120.Version): Uint8Array;
                    toProtoMsg(message: _120.Version): _120.VersionProtoMsg;
                };
                Params: {
                    typeUrl: string;
                    encode(message: _120.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _120.Params;
                    fromPartial(object: Partial<_120.Params>): _120.Params;
                    fromAmino(object: _120.ParamsAmino): _120.Params;
                    toAmino(message: _120.Params): _120.ParamsAmino;
                    fromAminoMsg(object: _120.ParamsAminoMsg): _120.Params;
                    toAminoMsg(message: _120.Params): _120.ParamsAminoMsg;
                    fromProtoMsg(message: _120.ParamsProtoMsg): _120.Params;
                    toProto(message: _120.Params): Uint8Array;
                    toProtoMsg(message: _120.Params): _120.ParamsProtoMsg;
                };
            };
        }
    }
    namespace lightclients {
        namespace localhost {
            const v1: {
                ClientState: {
                    typeUrl: string;
                    encode(message: _124.ClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _124.ClientState;
                    fromPartial(object: Partial<_124.ClientState>): _124.ClientState;
                    fromAmino(object: _124.ClientStateAmino): _124.ClientState;
                    toAmino(message: _124.ClientState): _124.ClientStateAmino;
                    fromAminoMsg(object: _124.ClientStateAminoMsg): _124.ClientState;
                    toAminoMsg(message: _124.ClientState): _124.ClientStateAminoMsg;
                    fromProtoMsg(message: _124.ClientStateProtoMsg): _124.ClientState;
                    toProto(message: _124.ClientState): Uint8Array;
                    toProtoMsg(message: _124.ClientState): _124.ClientStateProtoMsg;
                };
            };
        }
        namespace solomachine {
            const v1: {
                dataTypeFromJSON(object: any): _125.DataType;
                dataTypeToJSON(object: _125.DataType): string;
                DataType: typeof _125.DataType;
                DataTypeSDKType: typeof _125.DataType;
                DataTypeAmino: typeof _125.DataType;
                ClientState: {
                    typeUrl: string;
                    encode(message: _125.ClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.ClientState;
                    fromPartial(object: Partial<_125.ClientState>): _125.ClientState;
                    fromAmino(object: _125.ClientStateAmino): _125.ClientState;
                    toAmino(message: _125.ClientState): _125.ClientStateAmino;
                    fromAminoMsg(object: _125.ClientStateAminoMsg): _125.ClientState;
                    toAminoMsg(message: _125.ClientState): _125.ClientStateAminoMsg;
                    fromProtoMsg(message: _125.ClientStateProtoMsg): _125.ClientState;
                    toProto(message: _125.ClientState): Uint8Array;
                    toProtoMsg(message: _125.ClientState): _125.ClientStateProtoMsg;
                };
                ConsensusState: {
                    typeUrl: string;
                    encode(message: _125.ConsensusState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.ConsensusState;
                    fromPartial(object: Partial<_125.ConsensusState>): _125.ConsensusState;
                    fromAmino(object: _125.ConsensusStateAmino): _125.ConsensusState;
                    toAmino(message: _125.ConsensusState): _125.ConsensusStateAmino;
                    fromAminoMsg(object: _125.ConsensusStateAminoMsg): _125.ConsensusState;
                    toAminoMsg(message: _125.ConsensusState): _125.ConsensusStateAminoMsg;
                    fromProtoMsg(message: _125.ConsensusStateProtoMsg): _125.ConsensusState;
                    toProto(message: _125.ConsensusState): Uint8Array;
                    toProtoMsg(message: _125.ConsensusState): _125.ConsensusStateProtoMsg;
                };
                Header: {
                    typeUrl: string;
                    encode(message: _125.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.Header;
                    fromPartial(object: Partial<_125.Header>): _125.Header;
                    fromAmino(object: _125.HeaderAmino): _125.Header;
                    toAmino(message: _125.Header): _125.HeaderAmino;
                    fromAminoMsg(object: _125.HeaderAminoMsg): _125.Header;
                    toAminoMsg(message: _125.Header): _125.HeaderAminoMsg;
                    fromProtoMsg(message: _125.HeaderProtoMsg): _125.Header;
                    toProto(message: _125.Header): Uint8Array;
                    toProtoMsg(message: _125.Header): _125.HeaderProtoMsg;
                };
                Misbehaviour: {
                    typeUrl: string;
                    encode(message: _125.Misbehaviour, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.Misbehaviour;
                    fromPartial(object: Partial<_125.Misbehaviour>): _125.Misbehaviour;
                    fromAmino(object: _125.MisbehaviourAmino): _125.Misbehaviour;
                    toAmino(message: _125.Misbehaviour): _125.MisbehaviourAmino;
                    fromAminoMsg(object: _125.MisbehaviourAminoMsg): _125.Misbehaviour;
                    toAminoMsg(message: _125.Misbehaviour): _125.MisbehaviourAminoMsg;
                    fromProtoMsg(message: _125.MisbehaviourProtoMsg): _125.Misbehaviour;
                    toProto(message: _125.Misbehaviour): Uint8Array;
                    toProtoMsg(message: _125.Misbehaviour): _125.MisbehaviourProtoMsg;
                };
                SignatureAndData: {
                    typeUrl: string;
                    encode(message: _125.SignatureAndData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.SignatureAndData;
                    fromPartial(object: Partial<_125.SignatureAndData>): _125.SignatureAndData;
                    fromAmino(object: _125.SignatureAndDataAmino): _125.SignatureAndData;
                    toAmino(message: _125.SignatureAndData): _125.SignatureAndDataAmino;
                    fromAminoMsg(object: _125.SignatureAndDataAminoMsg): _125.SignatureAndData;
                    toAminoMsg(message: _125.SignatureAndData): _125.SignatureAndDataAminoMsg;
                    fromProtoMsg(message: _125.SignatureAndDataProtoMsg): _125.SignatureAndData;
                    toProto(message: _125.SignatureAndData): Uint8Array;
                    toProtoMsg(message: _125.SignatureAndData): _125.SignatureAndDataProtoMsg;
                };
                TimestampedSignatureData: {
                    typeUrl: string;
                    encode(message: _125.TimestampedSignatureData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.TimestampedSignatureData;
                    fromPartial(object: Partial<_125.TimestampedSignatureData>): _125.TimestampedSignatureData;
                    fromAmino(object: _125.TimestampedSignatureDataAmino): _125.TimestampedSignatureData;
                    toAmino(message: _125.TimestampedSignatureData): _125.TimestampedSignatureDataAmino;
                    fromAminoMsg(object: _125.TimestampedSignatureDataAminoMsg): _125.TimestampedSignatureData;
                    toAminoMsg(message: _125.TimestampedSignatureData): _125.TimestampedSignatureDataAminoMsg;
                    fromProtoMsg(message: _125.TimestampedSignatureDataProtoMsg): _125.TimestampedSignatureData;
                    toProto(message: _125.TimestampedSignatureData): Uint8Array;
                    toProtoMsg(message: _125.TimestampedSignatureData): _125.TimestampedSignatureDataProtoMsg;
                };
                SignBytes: {
                    typeUrl: string;
                    encode(message: _125.SignBytes, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.SignBytes;
                    fromPartial(object: Partial<_125.SignBytes>): _125.SignBytes;
                    fromAmino(object: _125.SignBytesAmino): _125.SignBytes;
                    toAmino(message: _125.SignBytes): _125.SignBytesAmino;
                    fromAminoMsg(object: _125.SignBytesAminoMsg): _125.SignBytes;
                    toAminoMsg(message: _125.SignBytes): _125.SignBytesAminoMsg;
                    fromProtoMsg(message: _125.SignBytesProtoMsg): _125.SignBytes;
                    toProto(message: _125.SignBytes): Uint8Array;
                    toProtoMsg(message: _125.SignBytes): _125.SignBytesProtoMsg;
                };
                HeaderData: {
                    typeUrl: string;
                    encode(message: _125.HeaderData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.HeaderData;
                    fromPartial(object: Partial<_125.HeaderData>): _125.HeaderData;
                    fromAmino(object: _125.HeaderDataAmino): _125.HeaderData;
                    toAmino(message: _125.HeaderData): _125.HeaderDataAmino;
                    fromAminoMsg(object: _125.HeaderDataAminoMsg): _125.HeaderData;
                    toAminoMsg(message: _125.HeaderData): _125.HeaderDataAminoMsg;
                    fromProtoMsg(message: _125.HeaderDataProtoMsg): _125.HeaderData;
                    toProto(message: _125.HeaderData): Uint8Array;
                    toProtoMsg(message: _125.HeaderData): _125.HeaderDataProtoMsg;
                };
                ClientStateData: {
                    typeUrl: string;
                    encode(message: _125.ClientStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.ClientStateData;
                    fromPartial(object: Partial<_125.ClientStateData>): _125.ClientStateData;
                    fromAmino(object: _125.ClientStateDataAmino): _125.ClientStateData;
                    toAmino(message: _125.ClientStateData): _125.ClientStateDataAmino;
                    fromAminoMsg(object: _125.ClientStateDataAminoMsg): _125.ClientStateData;
                    toAminoMsg(message: _125.ClientStateData): _125.ClientStateDataAminoMsg;
                    fromProtoMsg(message: _125.ClientStateDataProtoMsg): _125.ClientStateData;
                    toProto(message: _125.ClientStateData): Uint8Array;
                    toProtoMsg(message: _125.ClientStateData): _125.ClientStateDataProtoMsg;
                };
                ConsensusStateData: {
                    typeUrl: string;
                    encode(message: _125.ConsensusStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.ConsensusStateData;
                    fromPartial(object: Partial<_125.ConsensusStateData>): _125.ConsensusStateData;
                    fromAmino(object: _125.ConsensusStateDataAmino): _125.ConsensusStateData;
                    toAmino(message: _125.ConsensusStateData): _125.ConsensusStateDataAmino;
                    fromAminoMsg(object: _125.ConsensusStateDataAminoMsg): _125.ConsensusStateData;
                    toAminoMsg(message: _125.ConsensusStateData): _125.ConsensusStateDataAminoMsg;
                    fromProtoMsg(message: _125.ConsensusStateDataProtoMsg): _125.ConsensusStateData;
                    toProto(message: _125.ConsensusStateData): Uint8Array;
                    toProtoMsg(message: _125.ConsensusStateData): _125.ConsensusStateDataProtoMsg;
                };
                ConnectionStateData: {
                    typeUrl: string;
                    encode(message: _125.ConnectionStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.ConnectionStateData;
                    fromPartial(object: Partial<_125.ConnectionStateData>): _125.ConnectionStateData;
                    fromAmino(object: _125.ConnectionStateDataAmino): _125.ConnectionStateData;
                    toAmino(message: _125.ConnectionStateData): _125.ConnectionStateDataAmino;
                    fromAminoMsg(object: _125.ConnectionStateDataAminoMsg): _125.ConnectionStateData;
                    toAminoMsg(message: _125.ConnectionStateData): _125.ConnectionStateDataAminoMsg;
                    fromProtoMsg(message: _125.ConnectionStateDataProtoMsg): _125.ConnectionStateData;
                    toProto(message: _125.ConnectionStateData): Uint8Array;
                    toProtoMsg(message: _125.ConnectionStateData): _125.ConnectionStateDataProtoMsg;
                };
                ChannelStateData: {
                    typeUrl: string;
                    encode(message: _125.ChannelStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.ChannelStateData;
                    fromPartial(object: Partial<_125.ChannelStateData>): _125.ChannelStateData;
                    fromAmino(object: _125.ChannelStateDataAmino): _125.ChannelStateData;
                    toAmino(message: _125.ChannelStateData): _125.ChannelStateDataAmino;
                    fromAminoMsg(object: _125.ChannelStateDataAminoMsg): _125.ChannelStateData;
                    toAminoMsg(message: _125.ChannelStateData): _125.ChannelStateDataAminoMsg;
                    fromProtoMsg(message: _125.ChannelStateDataProtoMsg): _125.ChannelStateData;
                    toProto(message: _125.ChannelStateData): Uint8Array;
                    toProtoMsg(message: _125.ChannelStateData): _125.ChannelStateDataProtoMsg;
                };
                PacketCommitmentData: {
                    typeUrl: string;
                    encode(message: _125.PacketCommitmentData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.PacketCommitmentData;
                    fromPartial(object: Partial<_125.PacketCommitmentData>): _125.PacketCommitmentData;
                    fromAmino(object: _125.PacketCommitmentDataAmino): _125.PacketCommitmentData;
                    toAmino(message: _125.PacketCommitmentData): _125.PacketCommitmentDataAmino;
                    fromAminoMsg(object: _125.PacketCommitmentDataAminoMsg): _125.PacketCommitmentData;
                    toAminoMsg(message: _125.PacketCommitmentData): _125.PacketCommitmentDataAminoMsg;
                    fromProtoMsg(message: _125.PacketCommitmentDataProtoMsg): _125.PacketCommitmentData;
                    toProto(message: _125.PacketCommitmentData): Uint8Array;
                    toProtoMsg(message: _125.PacketCommitmentData): _125.PacketCommitmentDataProtoMsg;
                };
                PacketAcknowledgementData: {
                    typeUrl: string;
                    encode(message: _125.PacketAcknowledgementData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.PacketAcknowledgementData;
                    fromPartial(object: Partial<_125.PacketAcknowledgementData>): _125.PacketAcknowledgementData;
                    fromAmino(object: _125.PacketAcknowledgementDataAmino): _125.PacketAcknowledgementData;
                    toAmino(message: _125.PacketAcknowledgementData): _125.PacketAcknowledgementDataAmino;
                    fromAminoMsg(object: _125.PacketAcknowledgementDataAminoMsg): _125.PacketAcknowledgementData;
                    toAminoMsg(message: _125.PacketAcknowledgementData): _125.PacketAcknowledgementDataAminoMsg;
                    fromProtoMsg(message: _125.PacketAcknowledgementDataProtoMsg): _125.PacketAcknowledgementData;
                    toProto(message: _125.PacketAcknowledgementData): Uint8Array;
                    toProtoMsg(message: _125.PacketAcknowledgementData): _125.PacketAcknowledgementDataProtoMsg;
                };
                PacketReceiptAbsenceData: {
                    typeUrl: string;
                    encode(message: _125.PacketReceiptAbsenceData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.PacketReceiptAbsenceData;
                    fromPartial(object: Partial<_125.PacketReceiptAbsenceData>): _125.PacketReceiptAbsenceData;
                    fromAmino(object: _125.PacketReceiptAbsenceDataAmino): _125.PacketReceiptAbsenceData;
                    toAmino(message: _125.PacketReceiptAbsenceData): _125.PacketReceiptAbsenceDataAmino;
                    fromAminoMsg(object: _125.PacketReceiptAbsenceDataAminoMsg): _125.PacketReceiptAbsenceData;
                    toAminoMsg(message: _125.PacketReceiptAbsenceData): _125.PacketReceiptAbsenceDataAminoMsg;
                    fromProtoMsg(message: _125.PacketReceiptAbsenceDataProtoMsg): _125.PacketReceiptAbsenceData;
                    toProto(message: _125.PacketReceiptAbsenceData): Uint8Array;
                    toProtoMsg(message: _125.PacketReceiptAbsenceData): _125.PacketReceiptAbsenceDataProtoMsg;
                };
                NextSequenceRecvData: {
                    typeUrl: string;
                    encode(message: _125.NextSequenceRecvData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.NextSequenceRecvData;
                    fromPartial(object: Partial<_125.NextSequenceRecvData>): _125.NextSequenceRecvData;
                    fromAmino(object: _125.NextSequenceRecvDataAmino): _125.NextSequenceRecvData;
                    toAmino(message: _125.NextSequenceRecvData): _125.NextSequenceRecvDataAmino;
                    fromAminoMsg(object: _125.NextSequenceRecvDataAminoMsg): _125.NextSequenceRecvData;
                    toAminoMsg(message: _125.NextSequenceRecvData): _125.NextSequenceRecvDataAminoMsg;
                    fromProtoMsg(message: _125.NextSequenceRecvDataProtoMsg): _125.NextSequenceRecvData;
                    toProto(message: _125.NextSequenceRecvData): Uint8Array;
                    toProtoMsg(message: _125.NextSequenceRecvData): _125.NextSequenceRecvDataProtoMsg;
                };
            };
            const v2: {
                dataTypeFromJSON(object: any): _126.DataType;
                dataTypeToJSON(object: _126.DataType): string;
                DataType: typeof _126.DataType;
                DataTypeSDKType: typeof _126.DataType;
                DataTypeAmino: typeof _126.DataType;
                ClientState: {
                    typeUrl: string;
                    encode(message: _126.ClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.ClientState;
                    fromPartial(object: Partial<_126.ClientState>): _126.ClientState;
                    fromAmino(object: _126.ClientStateAmino): _126.ClientState;
                    toAmino(message: _126.ClientState): _126.ClientStateAmino;
                    fromAminoMsg(object: _126.ClientStateAminoMsg): _126.ClientState;
                    toAminoMsg(message: _126.ClientState): _126.ClientStateAminoMsg;
                    fromProtoMsg(message: _126.ClientStateProtoMsg): _126.ClientState;
                    toProto(message: _126.ClientState): Uint8Array;
                    toProtoMsg(message: _126.ClientState): _126.ClientStateProtoMsg;
                };
                ConsensusState: {
                    typeUrl: string;
                    encode(message: _126.ConsensusState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.ConsensusState;
                    fromPartial(object: Partial<_126.ConsensusState>): _126.ConsensusState;
                    fromAmino(object: _126.ConsensusStateAmino): _126.ConsensusState;
                    toAmino(message: _126.ConsensusState): _126.ConsensusStateAmino;
                    fromAminoMsg(object: _126.ConsensusStateAminoMsg): _126.ConsensusState;
                    toAminoMsg(message: _126.ConsensusState): _126.ConsensusStateAminoMsg;
                    fromProtoMsg(message: _126.ConsensusStateProtoMsg): _126.ConsensusState;
                    toProto(message: _126.ConsensusState): Uint8Array;
                    toProtoMsg(message: _126.ConsensusState): _126.ConsensusStateProtoMsg;
                };
                Header: {
                    typeUrl: string;
                    encode(message: _126.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.Header;
                    fromPartial(object: Partial<_126.Header>): _126.Header;
                    fromAmino(object: _126.HeaderAmino): _126.Header;
                    toAmino(message: _126.Header): _126.HeaderAmino;
                    fromAminoMsg(object: _126.HeaderAminoMsg): _126.Header;
                    toAminoMsg(message: _126.Header): _126.HeaderAminoMsg;
                    fromProtoMsg(message: _126.HeaderProtoMsg): _126.Header;
                    toProto(message: _126.Header): Uint8Array;
                    toProtoMsg(message: _126.Header): _126.HeaderProtoMsg;
                };
                Misbehaviour: {
                    typeUrl: string;
                    encode(message: _126.Misbehaviour, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.Misbehaviour;
                    fromPartial(object: Partial<_126.Misbehaviour>): _126.Misbehaviour;
                    fromAmino(object: _126.MisbehaviourAmino): _126.Misbehaviour;
                    toAmino(message: _126.Misbehaviour): _126.MisbehaviourAmino;
                    fromAminoMsg(object: _126.MisbehaviourAminoMsg): _126.Misbehaviour;
                    toAminoMsg(message: _126.Misbehaviour): _126.MisbehaviourAminoMsg;
                    fromProtoMsg(message: _126.MisbehaviourProtoMsg): _126.Misbehaviour;
                    toProto(message: _126.Misbehaviour): Uint8Array;
                    toProtoMsg(message: _126.Misbehaviour): _126.MisbehaviourProtoMsg;
                };
                SignatureAndData: {
                    typeUrl: string;
                    encode(message: _126.SignatureAndData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.SignatureAndData;
                    fromPartial(object: Partial<_126.SignatureAndData>): _126.SignatureAndData;
                    fromAmino(object: _126.SignatureAndDataAmino): _126.SignatureAndData;
                    toAmino(message: _126.SignatureAndData): _126.SignatureAndDataAmino;
                    fromAminoMsg(object: _126.SignatureAndDataAminoMsg): _126.SignatureAndData;
                    toAminoMsg(message: _126.SignatureAndData): _126.SignatureAndDataAminoMsg;
                    fromProtoMsg(message: _126.SignatureAndDataProtoMsg): _126.SignatureAndData;
                    toProto(message: _126.SignatureAndData): Uint8Array;
                    toProtoMsg(message: _126.SignatureAndData): _126.SignatureAndDataProtoMsg;
                };
                TimestampedSignatureData: {
                    typeUrl: string;
                    encode(message: _126.TimestampedSignatureData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.TimestampedSignatureData;
                    fromPartial(object: Partial<_126.TimestampedSignatureData>): _126.TimestampedSignatureData;
                    fromAmino(object: _126.TimestampedSignatureDataAmino): _126.TimestampedSignatureData;
                    toAmino(message: _126.TimestampedSignatureData): _126.TimestampedSignatureDataAmino;
                    fromAminoMsg(object: _126.TimestampedSignatureDataAminoMsg): _126.TimestampedSignatureData;
                    toAminoMsg(message: _126.TimestampedSignatureData): _126.TimestampedSignatureDataAminoMsg;
                    fromProtoMsg(message: _126.TimestampedSignatureDataProtoMsg): _126.TimestampedSignatureData;
                    toProto(message: _126.TimestampedSignatureData): Uint8Array;
                    toProtoMsg(message: _126.TimestampedSignatureData): _126.TimestampedSignatureDataProtoMsg;
                };
                SignBytes: {
                    typeUrl: string;
                    encode(message: _126.SignBytes, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.SignBytes;
                    fromPartial(object: Partial<_126.SignBytes>): _126.SignBytes;
                    fromAmino(object: _126.SignBytesAmino): _126.SignBytes;
                    toAmino(message: _126.SignBytes): _126.SignBytesAmino;
                    fromAminoMsg(object: _126.SignBytesAminoMsg): _126.SignBytes;
                    toAminoMsg(message: _126.SignBytes): _126.SignBytesAminoMsg;
                    fromProtoMsg(message: _126.SignBytesProtoMsg): _126.SignBytes;
                    toProto(message: _126.SignBytes): Uint8Array;
                    toProtoMsg(message: _126.SignBytes): _126.SignBytesProtoMsg;
                };
                HeaderData: {
                    typeUrl: string;
                    encode(message: _126.HeaderData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.HeaderData;
                    fromPartial(object: Partial<_126.HeaderData>): _126.HeaderData;
                    fromAmino(object: _126.HeaderDataAmino): _126.HeaderData;
                    toAmino(message: _126.HeaderData): _126.HeaderDataAmino;
                    fromAminoMsg(object: _126.HeaderDataAminoMsg): _126.HeaderData;
                    toAminoMsg(message: _126.HeaderData): _126.HeaderDataAminoMsg;
                    fromProtoMsg(message: _126.HeaderDataProtoMsg): _126.HeaderData;
                    toProto(message: _126.HeaderData): Uint8Array;
                    toProtoMsg(message: _126.HeaderData): _126.HeaderDataProtoMsg;
                };
                ClientStateData: {
                    typeUrl: string;
                    encode(message: _126.ClientStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.ClientStateData;
                    fromPartial(object: Partial<_126.ClientStateData>): _126.ClientStateData;
                    fromAmino(object: _126.ClientStateDataAmino): _126.ClientStateData;
                    toAmino(message: _126.ClientStateData): _126.ClientStateDataAmino;
                    fromAminoMsg(object: _126.ClientStateDataAminoMsg): _126.ClientStateData;
                    toAminoMsg(message: _126.ClientStateData): _126.ClientStateDataAminoMsg;
                    fromProtoMsg(message: _126.ClientStateDataProtoMsg): _126.ClientStateData;
                    toProto(message: _126.ClientStateData): Uint8Array;
                    toProtoMsg(message: _126.ClientStateData): _126.ClientStateDataProtoMsg;
                };
                ConsensusStateData: {
                    typeUrl: string;
                    encode(message: _126.ConsensusStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.ConsensusStateData;
                    fromPartial(object: Partial<_126.ConsensusStateData>): _126.ConsensusStateData;
                    fromAmino(object: _126.ConsensusStateDataAmino): _126.ConsensusStateData;
                    toAmino(message: _126.ConsensusStateData): _126.ConsensusStateDataAmino;
                    fromAminoMsg(object: _126.ConsensusStateDataAminoMsg): _126.ConsensusStateData;
                    toAminoMsg(message: _126.ConsensusStateData): _126.ConsensusStateDataAminoMsg;
                    fromProtoMsg(message: _126.ConsensusStateDataProtoMsg): _126.ConsensusStateData;
                    toProto(message: _126.ConsensusStateData): Uint8Array;
                    toProtoMsg(message: _126.ConsensusStateData): _126.ConsensusStateDataProtoMsg;
                };
                ConnectionStateData: {
                    typeUrl: string;
                    encode(message: _126.ConnectionStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.ConnectionStateData;
                    fromPartial(object: Partial<_126.ConnectionStateData>): _126.ConnectionStateData;
                    fromAmino(object: _126.ConnectionStateDataAmino): _126.ConnectionStateData;
                    toAmino(message: _126.ConnectionStateData): _126.ConnectionStateDataAmino;
                    fromAminoMsg(object: _126.ConnectionStateDataAminoMsg): _126.ConnectionStateData;
                    toAminoMsg(message: _126.ConnectionStateData): _126.ConnectionStateDataAminoMsg;
                    fromProtoMsg(message: _126.ConnectionStateDataProtoMsg): _126.ConnectionStateData;
                    toProto(message: _126.ConnectionStateData): Uint8Array;
                    toProtoMsg(message: _126.ConnectionStateData): _126.ConnectionStateDataProtoMsg;
                };
                ChannelStateData: {
                    typeUrl: string;
                    encode(message: _126.ChannelStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.ChannelStateData;
                    fromPartial(object: Partial<_126.ChannelStateData>): _126.ChannelStateData;
                    fromAmino(object: _126.ChannelStateDataAmino): _126.ChannelStateData;
                    toAmino(message: _126.ChannelStateData): _126.ChannelStateDataAmino;
                    fromAminoMsg(object: _126.ChannelStateDataAminoMsg): _126.ChannelStateData;
                    toAminoMsg(message: _126.ChannelStateData): _126.ChannelStateDataAminoMsg;
                    fromProtoMsg(message: _126.ChannelStateDataProtoMsg): _126.ChannelStateData;
                    toProto(message: _126.ChannelStateData): Uint8Array;
                    toProtoMsg(message: _126.ChannelStateData): _126.ChannelStateDataProtoMsg;
                };
                PacketCommitmentData: {
                    typeUrl: string;
                    encode(message: _126.PacketCommitmentData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.PacketCommitmentData;
                    fromPartial(object: Partial<_126.PacketCommitmentData>): _126.PacketCommitmentData;
                    fromAmino(object: _126.PacketCommitmentDataAmino): _126.PacketCommitmentData;
                    toAmino(message: _126.PacketCommitmentData): _126.PacketCommitmentDataAmino;
                    fromAminoMsg(object: _126.PacketCommitmentDataAminoMsg): _126.PacketCommitmentData;
                    toAminoMsg(message: _126.PacketCommitmentData): _126.PacketCommitmentDataAminoMsg;
                    fromProtoMsg(message: _126.PacketCommitmentDataProtoMsg): _126.PacketCommitmentData;
                    toProto(message: _126.PacketCommitmentData): Uint8Array;
                    toProtoMsg(message: _126.PacketCommitmentData): _126.PacketCommitmentDataProtoMsg;
                };
                PacketAcknowledgementData: {
                    typeUrl: string;
                    encode(message: _126.PacketAcknowledgementData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.PacketAcknowledgementData;
                    fromPartial(object: Partial<_126.PacketAcknowledgementData>): _126.PacketAcknowledgementData;
                    fromAmino(object: _126.PacketAcknowledgementDataAmino): _126.PacketAcknowledgementData;
                    toAmino(message: _126.PacketAcknowledgementData): _126.PacketAcknowledgementDataAmino;
                    fromAminoMsg(object: _126.PacketAcknowledgementDataAminoMsg): _126.PacketAcknowledgementData;
                    toAminoMsg(message: _126.PacketAcknowledgementData): _126.PacketAcknowledgementDataAminoMsg;
                    fromProtoMsg(message: _126.PacketAcknowledgementDataProtoMsg): _126.PacketAcknowledgementData;
                    toProto(message: _126.PacketAcknowledgementData): Uint8Array;
                    toProtoMsg(message: _126.PacketAcknowledgementData): _126.PacketAcknowledgementDataProtoMsg;
                };
                PacketReceiptAbsenceData: {
                    typeUrl: string;
                    encode(message: _126.PacketReceiptAbsenceData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.PacketReceiptAbsenceData;
                    fromPartial(object: Partial<_126.PacketReceiptAbsenceData>): _126.PacketReceiptAbsenceData;
                    fromAmino(object: _126.PacketReceiptAbsenceDataAmino): _126.PacketReceiptAbsenceData;
                    toAmino(message: _126.PacketReceiptAbsenceData): _126.PacketReceiptAbsenceDataAmino;
                    fromAminoMsg(object: _126.PacketReceiptAbsenceDataAminoMsg): _126.PacketReceiptAbsenceData;
                    toAminoMsg(message: _126.PacketReceiptAbsenceData): _126.PacketReceiptAbsenceDataAminoMsg;
                    fromProtoMsg(message: _126.PacketReceiptAbsenceDataProtoMsg): _126.PacketReceiptAbsenceData;
                    toProto(message: _126.PacketReceiptAbsenceData): Uint8Array;
                    toProtoMsg(message: _126.PacketReceiptAbsenceData): _126.PacketReceiptAbsenceDataProtoMsg;
                };
                NextSequenceRecvData: {
                    typeUrl: string;
                    encode(message: _126.NextSequenceRecvData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.NextSequenceRecvData;
                    fromPartial(object: Partial<_126.NextSequenceRecvData>): _126.NextSequenceRecvData;
                    fromAmino(object: _126.NextSequenceRecvDataAmino): _126.NextSequenceRecvData;
                    toAmino(message: _126.NextSequenceRecvData): _126.NextSequenceRecvDataAmino;
                    fromAminoMsg(object: _126.NextSequenceRecvDataAminoMsg): _126.NextSequenceRecvData;
                    toAminoMsg(message: _126.NextSequenceRecvData): _126.NextSequenceRecvDataAminoMsg;
                    fromProtoMsg(message: _126.NextSequenceRecvDataProtoMsg): _126.NextSequenceRecvData;
                    toProto(message: _126.NextSequenceRecvData): Uint8Array;
                    toProtoMsg(message: _126.NextSequenceRecvData): _126.NextSequenceRecvDataProtoMsg;
                };
            };
        }
        namespace tendermint {
            const v1: {
                ClientState: {
                    typeUrl: string;
                    encode(message: _127.ClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.ClientState;
                    fromPartial(object: Partial<_127.ClientState>): _127.ClientState;
                    fromAmino(object: _127.ClientStateAmino): _127.ClientState;
                    toAmino(message: _127.ClientState): _127.ClientStateAmino;
                    fromAminoMsg(object: _127.ClientStateAminoMsg): _127.ClientState;
                    toAminoMsg(message: _127.ClientState): _127.ClientStateAminoMsg;
                    fromProtoMsg(message: _127.ClientStateProtoMsg): _127.ClientState;
                    toProto(message: _127.ClientState): Uint8Array;
                    toProtoMsg(message: _127.ClientState): _127.ClientStateProtoMsg;
                };
                ConsensusState: {
                    typeUrl: string;
                    encode(message: _127.ConsensusState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.ConsensusState;
                    fromPartial(object: Partial<_127.ConsensusState>): _127.ConsensusState;
                    fromAmino(object: _127.ConsensusStateAmino): _127.ConsensusState;
                    toAmino(message: _127.ConsensusState): _127.ConsensusStateAmino;
                    fromAminoMsg(object: _127.ConsensusStateAminoMsg): _127.ConsensusState;
                    toAminoMsg(message: _127.ConsensusState): _127.ConsensusStateAminoMsg;
                    fromProtoMsg(message: _127.ConsensusStateProtoMsg): _127.ConsensusState;
                    toProto(message: _127.ConsensusState): Uint8Array;
                    toProtoMsg(message: _127.ConsensusState): _127.ConsensusStateProtoMsg;
                };
                Misbehaviour: {
                    typeUrl: string;
                    encode(message: _127.Misbehaviour, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.Misbehaviour;
                    fromPartial(object: Partial<_127.Misbehaviour>): _127.Misbehaviour;
                    fromAmino(object: _127.MisbehaviourAmino): _127.Misbehaviour;
                    toAmino(message: _127.Misbehaviour): _127.MisbehaviourAmino;
                    fromAminoMsg(object: _127.MisbehaviourAminoMsg): _127.Misbehaviour;
                    toAminoMsg(message: _127.Misbehaviour): _127.MisbehaviourAminoMsg;
                    fromProtoMsg(message: _127.MisbehaviourProtoMsg): _127.Misbehaviour;
                    toProto(message: _127.Misbehaviour): Uint8Array;
                    toProtoMsg(message: _127.Misbehaviour): _127.MisbehaviourProtoMsg;
                };
                Header: {
                    typeUrl: string;
                    encode(message: _127.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.Header;
                    fromPartial(object: Partial<_127.Header>): _127.Header;
                    fromAmino(object: _127.HeaderAmino): _127.Header;
                    toAmino(message: _127.Header): _127.HeaderAmino;
                    fromAminoMsg(object: _127.HeaderAminoMsg): _127.Header;
                    toAminoMsg(message: _127.Header): _127.HeaderAminoMsg;
                    fromProtoMsg(message: _127.HeaderProtoMsg): _127.Header;
                    toProto(message: _127.Header): Uint8Array;
                    toProtoMsg(message: _127.Header): _127.HeaderProtoMsg;
                };
                Fraction: {
                    typeUrl: string;
                    encode(message: _127.Fraction, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.Fraction;
                    fromPartial(object: Partial<_127.Fraction>): _127.Fraction;
                    fromAmino(object: _127.FractionAmino): _127.Fraction;
                    toAmino(message: _127.Fraction): _127.FractionAmino;
                    fromAminoMsg(object: _127.FractionAminoMsg): _127.Fraction;
                    toAminoMsg(message: _127.Fraction): _127.FractionAminoMsg;
                    fromProtoMsg(message: _127.FractionProtoMsg): _127.Fraction;
                    toProto(message: _127.Fraction): Uint8Array;
                    toProtoMsg(message: _127.Fraction): _127.FractionProtoMsg;
                };
            };
        }
    }
    const ClientFactory: {
        createRPCMsgClient: ({ rpc }: {
            rpc: import("../helpers").Rpc;
        }) => Promise<{
            cosmos: {
                authz: {
                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
                };
                bank: {
                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
                };
                distribution: {
                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
                };
                feegrant: {
                    v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
                };
                gov: {
                    v1: import("../cosmos/gov/v1/tx.rpc.msg").MsgClientImpl;
                    v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg").MsgClientImpl;
                };
                group: {
                    v1: import("../cosmos/group/v1/tx.rpc.msg").MsgClientImpl;
                };
                staking: {
                    v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg").MsgClientImpl;
                };
                upgrade: {
                    v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
                };
                vesting: {
                    v1beta1: import("../cosmos/vesting/v1beta1/tx.rpc.msg").MsgClientImpl;
                };
            };
            ibc: {
                applications: {
                    transfer: {
                        v1: _254.MsgClientImpl;
                    };
                };
                core: {
                    channel: {
                        v1: _255.MsgClientImpl;
                    };
                    client: {
                        v1: _256.MsgClientImpl;
                    };
                    connection: {
                        v1: _257.MsgClientImpl;
                    };
                };
            };
        }>;
        createRPCQueryClient: ({ rpcEndpoint }: {
            rpcEndpoint: string | import("@cosmjs/tendermint-rpc").HttpEndpoint;
        }) => Promise<{
            cosmos: {
                auth: {
                    v1beta1: {
                        accounts(request?: import("../cosmos/auth/v1beta1/query").QueryAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountsResponse>;
                        account(request: import("../cosmos/auth/v1beta1/query").QueryAccountRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountResponse>;
                        params(request?: import("../cosmos/auth/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryParamsResponse>;
                        moduleAccounts(request?: import("../cosmos/auth/v1beta1/query").QueryModuleAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryModuleAccountsResponse>;
                        bech32Prefix(request?: import("../cosmos/auth/v1beta1/query").Bech32PrefixRequest): Promise<import("../cosmos/auth/v1beta1/query").Bech32PrefixResponse>;
                        addressBytesToString(request: import("../cosmos/auth/v1beta1/query").AddressBytesToStringRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressBytesToStringResponse>;
                        addressStringToBytes(request: import("../cosmos/auth/v1beta1/query").AddressStringToBytesRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressStringToBytesResponse>;
                    };
                };
                authz: {
                    v1beta1: {
                        grants(request: import("../cosmos/authz/v1beta1/query").QueryGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGrantsResponse>;
                        granterGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranterGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranterGrantsResponse>;
                        granteeGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsResponse>;
                    };
                };
                bank: {
                    v1beta1: {
                        balance(request: import("../cosmos/bank/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryBalanceResponse>;
                        allBalances(request: import("../cosmos/bank/v1beta1/query").QueryAllBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryAllBalancesResponse>;
                        spendableBalances(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesResponse>;
                        totalSupply(request?: import("../cosmos/bank/v1beta1/query").QueryTotalSupplyRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryTotalSupplyResponse>;
                        supplyOf(request: import("../cosmos/bank/v1beta1/query").QuerySupplyOfRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySupplyOfResponse>;
                        params(request?: import("../cosmos/bank/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryParamsResponse>;
                        denomMetadata(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataResponse>;
                        denomsMetadata(request?: import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataResponse>;
                        denomOwners(request: import("../cosmos/bank/v1beta1/query").QueryDenomOwnersRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomOwnersResponse>;
                    };
                };
                distribution: {
                    v1beta1: {
                        params(request?: import("../cosmos/distribution/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryParamsResponse>;
                        validatorOutstandingRewards(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsResponse>;
                        validatorCommission(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionResponse>;
                        validatorSlashes(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesResponse>;
                        delegationRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsResponse>;
                        delegationTotalRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsResponse>;
                        delegatorValidators(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsResponse>;
                        delegatorWithdrawAddress(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressResponse>;
                        communityPool(request?: import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolResponse>;
                    };
                };
                feegrant: {
                    v1beta1: {
                        allowance(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowanceRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowanceResponse>;
                        allowances(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesResponse>;
                        allowancesByGranter(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterResponse>;
                    };
                };
                gov: {
                    v1: {
                        proposal(request: import("../cosmos/gov/v1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalResponse>;
                        proposals(request: import("../cosmos/gov/v1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalsResponse>;
                        vote(request: import("../cosmos/gov/v1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1/query").QueryVoteResponse>;
                        votes(request: import("../cosmos/gov/v1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1/query").QueryVotesResponse>;
                        params(request: import("../cosmos/gov/v1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1/query").QueryParamsResponse>;
                        deposit(request: import("../cosmos/gov/v1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositResponse>;
                        deposits(request: import("../cosmos/gov/v1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositsResponse>;
                        tallyResult(request: import("../cosmos/gov/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1/query").QueryTallyResultResponse>;
                    };
                    v1beta1: {
                        proposal(request: import("../cosmos/gov/v1beta1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalResponse>;
                        proposals(request: import("../cosmos/gov/v1beta1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalsResponse>;
                        vote(request: import("../cosmos/gov/v1beta1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVoteResponse>;
                        votes(request: import("../cosmos/gov/v1beta1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVotesResponse>;
                        params(request: import("../cosmos/gov/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryParamsResponse>;
                        deposit(request: import("../cosmos/gov/v1beta1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositResponse>;
                        deposits(request: import("../cosmos/gov/v1beta1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositsResponse>;
                        tallyResult(request: import("../cosmos/gov/v1beta1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryTallyResultResponse>;
                    };
                };
                group: {
                    v1: {
                        groupInfo(request: import("../cosmos/group/v1/query").QueryGroupInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupInfoResponse>;
                        groupPolicyInfo(request: import("../cosmos/group/v1/query").QueryGroupPolicyInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPolicyInfoResponse>;
                        groupMembers(request: import("../cosmos/group/v1/query").QueryGroupMembersRequest): Promise<import("../cosmos/group/v1/query").QueryGroupMembersResponse>;
                        groupsByAdmin(request: import("../cosmos/group/v1/query").QueryGroupsByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByAdminResponse>;
                        groupPoliciesByGroup(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupResponse>;
                        groupPoliciesByAdmin(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminResponse>;
                        proposal(request: import("../cosmos/group/v1/query").QueryProposalRequest): Promise<import("../cosmos/group/v1/query").QueryProposalResponse>;
                        proposalsByGroupPolicy(request: import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyRequest): Promise<import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyResponse>;
                        voteByProposalVoter(request: import("../cosmos/group/v1/query").QueryVoteByProposalVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVoteByProposalVoterResponse>;
                        votesByProposal(request: import("../cosmos/group/v1/query").QueryVotesByProposalRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByProposalResponse>;
                        votesByVoter(request: import("../cosmos/group/v1/query").QueryVotesByVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByVoterResponse>;
                        groupsByMember(request: import("../cosmos/group/v1/query").QueryGroupsByMemberRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByMemberResponse>;
                        tallyResult(request: import("../cosmos/group/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/group/v1/query").QueryTallyResultResponse>;
                    };
                };
                mint: {
                    v1beta1: {
                        params(request?: import("../cosmos/mint/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryParamsResponse>;
                        inflation(request?: import("../cosmos/mint/v1beta1/query").QueryInflationRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryInflationResponse>;
                        annualProvisions(request?: import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsResponse>;
                    };
                };
                params: {
                    v1beta1: {
                        params(request: import("../cosmos/params/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/params/v1beta1/query").QueryParamsResponse>;
                        subspaces(request?: import("../cosmos/params/v1beta1/query").QuerySubspacesRequest): Promise<import("../cosmos/params/v1beta1/query").QuerySubspacesResponse>;
                    };
                };
                staking: {
                    v1beta1: {
                        validators(request: import("../cosmos/staking/v1beta1/query").QueryValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorsResponse>;
                        validator(request: import("../cosmos/staking/v1beta1/query").QueryValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorResponse>;
                        validatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsResponse>;
                        validatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsResponse>;
                        delegation(request: import("../cosmos/staking/v1beta1/query").QueryDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegationResponse>;
                        unbondingDelegation(request: import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationResponse>;
                        delegatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsResponse>;
                        delegatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsResponse>;
                        redelegations(request: import("../cosmos/staking/v1beta1/query").QueryRedelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryRedelegationsResponse>;
                        delegatorValidators(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsResponse>;
                        delegatorValidator(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorResponse>;
                        historicalInfo(request: import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoResponse>;
                        pool(request?: import("../cosmos/staking/v1beta1/query").QueryPoolRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryPoolResponse>;
                        params(request?: import("../cosmos/staking/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryParamsResponse>;
                    };
                };
                tx: {
                    v1beta1: {
                        simulate(request: import("../cosmos/tx/v1beta1/service").SimulateRequest): Promise<import("../cosmos/tx/v1beta1/service").SimulateResponse>;
                        getTx(request: import("../cosmos/tx/v1beta1/service").GetTxRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxResponse>;
                        broadcastTx(request: import("../cosmos/tx/v1beta1/service").BroadcastTxRequest): Promise<import("../cosmos/tx/v1beta1/service").BroadcastTxResponse>;
                        getTxsEvent(request: import("../cosmos/tx/v1beta1/service").GetTxsEventRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxsEventResponse>;
                        getBlockWithTxs(request: import("../cosmos/tx/v1beta1/service").GetBlockWithTxsRequest): Promise<import("../cosmos/tx/v1beta1/service").GetBlockWithTxsResponse>;
                    };
                };
                upgrade: {
                    v1beta1: {
                        currentPlan(request?: import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanResponse>;
                        appliedPlan(request: import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanResponse>;
                        upgradedConsensusState(request: import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateResponse>;
                        moduleVersions(request: import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsResponse>;
                        authority(request?: import("../cosmos/upgrade/v1beta1/query").QueryAuthorityRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAuthorityResponse>;
                    };
                };
            };
            ibc: {
                applications: {
                    transfer: {
                        v1: {
                            denomTrace(request: _107.QueryDenomTraceRequest): Promise<_107.QueryDenomTraceResponse>;
                            denomTraces(request?: _107.QueryDenomTracesRequest): Promise<_107.QueryDenomTracesResponse>;
                            params(request?: _107.QueryParamsRequest): Promise<_107.QueryParamsResponse>;
                        };
                    };
                };
                core: {
                    channel: {
                        v1: {
                            channel(request: _113.QueryChannelRequest): Promise<_113.QueryChannelResponse>;
                            channels(request?: _113.QueryChannelsRequest): Promise<_113.QueryChannelsResponse>;
                            connectionChannels(request: _113.QueryConnectionChannelsRequest): Promise<_113.QueryConnectionChannelsResponse>;
                            channelClientState(request: _113.QueryChannelClientStateRequest): Promise<_113.QueryChannelClientStateResponse>;
                            channelConsensusState(request: _113.QueryChannelConsensusStateRequest): Promise<_113.QueryChannelConsensusStateResponse>;
                            packetCommitment(request: _113.QueryPacketCommitmentRequest): Promise<_113.QueryPacketCommitmentResponse>;
                            packetCommitments(request: _113.QueryPacketCommitmentsRequest): Promise<_113.QueryPacketCommitmentsResponse>;
                            packetReceipt(request: _113.QueryPacketReceiptRequest): Promise<_113.QueryPacketReceiptResponse>;
                            packetAcknowledgement(request: _113.QueryPacketAcknowledgementRequest): Promise<_113.QueryPacketAcknowledgementResponse>;
                            packetAcknowledgements(request: _113.QueryPacketAcknowledgementsRequest): Promise<_113.QueryPacketAcknowledgementsResponse>;
                            unreceivedPackets(request: _113.QueryUnreceivedPacketsRequest): Promise<_113.QueryUnreceivedPacketsResponse>;
                            unreceivedAcks(request: _113.QueryUnreceivedAcksRequest): Promise<_113.QueryUnreceivedAcksResponse>;
                            nextSequenceReceive(request: _113.QueryNextSequenceReceiveRequest): Promise<_113.QueryNextSequenceReceiveResponse>;
                        };
                    };
                    client: {
                        v1: {
                            clientState(request: _117.QueryClientStateRequest): Promise<_117.QueryClientStateResponse>;
                            clientStates(request?: _117.QueryClientStatesRequest): Promise<_117.QueryClientStatesResponse>;
                            consensusState(request: _117.QueryConsensusStateRequest): Promise<_117.QueryConsensusStateResponse>;
                            consensusStates(request: _117.QueryConsensusStatesRequest): Promise<_117.QueryConsensusStatesResponse>;
                            clientStatus(request: _117.QueryClientStatusRequest): Promise<_117.QueryClientStatusResponse>;
                            clientParams(request?: _117.QueryClientParamsRequest): Promise<_117.QueryClientParamsResponse>;
                            upgradedClientState(request?: _117.QueryUpgradedClientStateRequest): Promise<_117.QueryUpgradedClientStateResponse>;
                            upgradedConsensusState(request?: _117.QueryUpgradedConsensusStateRequest): Promise<_117.QueryUpgradedConsensusStateResponse>;
                        };
                    };
                    connection: {
                        v1: {
                            connection(request: _122.QueryConnectionRequest): Promise<_122.QueryConnectionResponse>;
                            connections(request?: _122.QueryConnectionsRequest): Promise<_122.QueryConnectionsResponse>;
                            clientConnections(request: _122.QueryClientConnectionsRequest): Promise<_122.QueryClientConnectionsResponse>;
                            connectionClientState(request: _122.QueryConnectionClientStateRequest): Promise<_122.QueryConnectionClientStateResponse>;
                            connectionConsensusState(request: _122.QueryConnectionConsensusStateRequest): Promise<_122.QueryConnectionConsensusStateResponse>;
                        };
                    };
                };
            };
        }>;
        createLCDClient: ({ restEndpoint }: {
            restEndpoint: string;
        }) => Promise<{
            cosmos: {
                auth: {
                    v1beta1: import("../cosmos/auth/v1beta1/query.lcd").LCDQueryClient;
                };
                authz: {
                    v1beta1: import("../cosmos/authz/v1beta1/query.lcd").LCDQueryClient;
                };
                bank: {
                    v1beta1: import("../cosmos/bank/v1beta1/query.lcd").LCDQueryClient;
                };
                distribution: {
                    v1beta1: import("../cosmos/distribution/v1beta1/query.lcd").LCDQueryClient;
                };
                feegrant: {
                    v1beta1: import("../cosmos/feegrant/v1beta1/query.lcd").LCDQueryClient;
                };
                gov: {
                    v1: import("../cosmos/gov/v1/query.lcd").LCDQueryClient;
                    v1beta1: import("../cosmos/gov/v1beta1/query.lcd").LCDQueryClient;
                };
                group: {
                    v1: import("../cosmos/group/v1/query.lcd").LCDQueryClient;
                };
                mint: {
                    v1beta1: import("../cosmos/mint/v1beta1/query.lcd").LCDQueryClient;
                };
                params: {
                    v1beta1: import("../cosmos/params/v1beta1/query.lcd").LCDQueryClient;
                };
                staking: {
                    v1beta1: import("../cosmos/staking/v1beta1/query.lcd").LCDQueryClient;
                };
                tx: {
                    v1beta1: import("../cosmos/tx/v1beta1/service.lcd").LCDQueryClient;
                };
                upgrade: {
                    v1beta1: import("../cosmos/upgrade/v1beta1/query.lcd").LCDQueryClient;
                };
            };
            ibc: {
                applications: {
                    transfer: {
                        v1: _246.LCDQueryClient;
                    };
                };
                core: {
                    channel: {
                        v1: _247.LCDQueryClient;
                    };
                    client: {
                        v1: _248.LCDQueryClient;
                    };
                    connection: {
                        v1: _249.LCDQueryClient;
                    };
                };
            };
        }>;
    };
}