@agoric/cosmic-proto 0.4.1-dev-76b8d53.0 → 0.4.1-dev-b78d824.0

package/dist/codegen/ibc/bundle.d.ts

@@ -1,174 +1,2318 @@
-import * as _85 from './core/channel/v1/channel.js';
-import * as _86 from './core/client/v1/client.js';
+import * as _86 from './applications/interchain_accounts/controller/v1/controller.js';
+import * as _87 from './applications/interchain_accounts/controller/v1/query.js';
+import * as _88 from './applications/interchain_accounts/controller/v1/tx.js';
+import * as _89 from './applications/interchain_accounts/genesis/v1/genesis.js';
+import * as _90 from './applications/interchain_accounts/host/v1/host.js';
+import * as _91 from './applications/interchain_accounts/host/v1/query.js';
+import * as _92 from './applications/interchain_accounts/v1/account.js';
+import * as _93 from './applications/interchain_accounts/v1/metadata.js';
+import * as _94 from './applications/interchain_accounts/v1/packet.js';
+import * as _95 from './applications/transfer/v1/authz.js';
+import * as _96 from './applications/transfer/v1/genesis.js';
+import * as _97 from './applications/transfer/v1/query.js';
+import * as _98 from './applications/transfer/v1/transfer.js';
+import * as _99 from './applications/transfer/v1/tx.js';
+import * as _100 from './applications/transfer/v2/packet.js';
+import * as _101 from './core/channel/v1/channel.js';
+import * as _102 from './core/channel/v1/genesis.js';
+import * as _103 from './core/channel/v1/query.js';
+import * as _104 from './core/channel/v1/tx.js';
+import * as _105 from './core/client/v1/client.js';
+import * as _106 from './core/client/v1/genesis.js';
+import * as _107 from './core/client/v1/query.js';
+import * as _108 from './core/client/v1/tx.js';
+import * as _109 from './core/commitment/v1/commitment.js';
+import * as _110 from './core/connection/v1/connection.js';
+import * as _111 from './core/connection/v1/genesis.js';
+import * as _112 from './core/connection/v1/query.js';
+import * as _113 from './core/connection/v1/tx.js';
+import * as _114 from './lightclients/localhost/v1/localhost.js';
+import * as _115 from './lightclients/solomachine/v1/solomachine.js';
+import * as _116 from './lightclients/solomachine/v2/solomachine.js';
+import * as _117 from './lightclients/tendermint/v1/tendermint.js';
 export declare namespace ibc {
+    namespace applications {
+        namespace interchain_accounts {
+            namespace controller {
+                const v1: {
+                    MsgRegisterInterchainAccount: {
+                        typeUrl: string;
+                        encode(message: _88.MsgRegisterInterchainAccount, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _88.MsgRegisterInterchainAccount;
+                        fromJSON(object: any): _88.MsgRegisterInterchainAccount;
+                        toJSON(message: _88.MsgRegisterInterchainAccount): unknown;
+                        fromPartial(object: Partial<_88.MsgRegisterInterchainAccount>): _88.MsgRegisterInterchainAccount;
+                        fromProtoMsg(message: _88.MsgRegisterInterchainAccountProtoMsg): _88.MsgRegisterInterchainAccount;
+                        toProto(message: _88.MsgRegisterInterchainAccount): Uint8Array;
+                        toProtoMsg(message: _88.MsgRegisterInterchainAccount): _88.MsgRegisterInterchainAccountProtoMsg;
+                    };
+                    MsgRegisterInterchainAccountResponse: {
+                        typeUrl: string;
+                        encode(message: _88.MsgRegisterInterchainAccountResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _88.MsgRegisterInterchainAccountResponse;
+                        fromJSON(object: any): _88.MsgRegisterInterchainAccountResponse;
+                        toJSON(message: _88.MsgRegisterInterchainAccountResponse): unknown;
+                        fromPartial(object: Partial<_88.MsgRegisterInterchainAccountResponse>): _88.MsgRegisterInterchainAccountResponse;
+                        fromProtoMsg(message: _88.MsgRegisterInterchainAccountResponseProtoMsg): _88.MsgRegisterInterchainAccountResponse;
+                        toProto(message: _88.MsgRegisterInterchainAccountResponse): Uint8Array;
+                        toProtoMsg(message: _88.MsgRegisterInterchainAccountResponse): _88.MsgRegisterInterchainAccountResponseProtoMsg;
+                    };
+                    MsgSendTx: {
+                        typeUrl: string;
+                        encode(message: _88.MsgSendTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _88.MsgSendTx;
+                        fromJSON(object: any): _88.MsgSendTx;
+                        toJSON(message: _88.MsgSendTx): unknown;
+                        fromPartial(object: Partial<_88.MsgSendTx>): _88.MsgSendTx;
+                        fromProtoMsg(message: _88.MsgSendTxProtoMsg): _88.MsgSendTx;
+                        toProto(message: _88.MsgSendTx): Uint8Array;
+                        toProtoMsg(message: _88.MsgSendTx): _88.MsgSendTxProtoMsg;
+                    };
+                    MsgSendTxResponse: {
+                        typeUrl: string;
+                        encode(message: _88.MsgSendTxResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _88.MsgSendTxResponse;
+                        fromJSON(object: any): _88.MsgSendTxResponse;
+                        toJSON(message: _88.MsgSendTxResponse): unknown;
+                        fromPartial(object: Partial<_88.MsgSendTxResponse>): _88.MsgSendTxResponse;
+                        fromProtoMsg(message: _88.MsgSendTxResponseProtoMsg): _88.MsgSendTxResponse;
+                        toProto(message: _88.MsgSendTxResponse): Uint8Array;
+                        toProtoMsg(message: _88.MsgSendTxResponse): _88.MsgSendTxResponseProtoMsg;
+                    };
+                    QueryInterchainAccountRequest: {
+                        typeUrl: string;
+                        encode(message: _87.QueryInterchainAccountRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _87.QueryInterchainAccountRequest;
+                        fromJSON(object: any): _87.QueryInterchainAccountRequest;
+                        toJSON(message: _87.QueryInterchainAccountRequest): unknown;
+                        fromPartial(object: Partial<_87.QueryInterchainAccountRequest>): _87.QueryInterchainAccountRequest;
+                        fromProtoMsg(message: _87.QueryInterchainAccountRequestProtoMsg): _87.QueryInterchainAccountRequest;
+                        toProto(message: _87.QueryInterchainAccountRequest): Uint8Array;
+                        toProtoMsg(message: _87.QueryInterchainAccountRequest): _87.QueryInterchainAccountRequestProtoMsg;
+                    };
+                    QueryInterchainAccountResponse: {
+                        typeUrl: string;
+                        encode(message: _87.QueryInterchainAccountResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _87.QueryInterchainAccountResponse;
+                        fromJSON(object: any): _87.QueryInterchainAccountResponse;
+                        toJSON(message: _87.QueryInterchainAccountResponse): unknown;
+                        fromPartial(object: Partial<_87.QueryInterchainAccountResponse>): _87.QueryInterchainAccountResponse;
+                        fromProtoMsg(message: _87.QueryInterchainAccountResponseProtoMsg): _87.QueryInterchainAccountResponse;
+                        toProto(message: _87.QueryInterchainAccountResponse): Uint8Array;
+                        toProtoMsg(message: _87.QueryInterchainAccountResponse): _87.QueryInterchainAccountResponseProtoMsg;
+                    };
+                    QueryParamsRequest: {
+                        typeUrl: string;
+                        encode(_: _87.QueryParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _87.QueryParamsRequest;
+                        fromJSON(_: any): _87.QueryParamsRequest;
+                        toJSON(_: _87.QueryParamsRequest): unknown;
+                        fromPartial(_: Partial<_87.QueryParamsRequest>): _87.QueryParamsRequest;
+                        fromProtoMsg(message: _87.QueryParamsRequestProtoMsg): _87.QueryParamsRequest;
+                        toProto(message: _87.QueryParamsRequest): Uint8Array;
+                        toProtoMsg(message: _87.QueryParamsRequest): _87.QueryParamsRequestProtoMsg;
+                    };
+                    QueryParamsResponse: {
+                        typeUrl: string;
+                        encode(message: _87.QueryParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _87.QueryParamsResponse;
+                        fromJSON(object: any): _87.QueryParamsResponse;
+                        toJSON(message: _87.QueryParamsResponse): unknown;
+                        fromPartial(object: Partial<_87.QueryParamsResponse>): _87.QueryParamsResponse;
+                        fromProtoMsg(message: _87.QueryParamsResponseProtoMsg): _87.QueryParamsResponse;
+                        toProto(message: _87.QueryParamsResponse): Uint8Array;
+                        toProtoMsg(message: _87.QueryParamsResponse): _87.QueryParamsResponseProtoMsg;
+                    };
+                    Params: {
+                        typeUrl: string;
+                        encode(message: _86.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _86.Params;
+                        fromJSON(object: any): _86.Params;
+                        toJSON(message: _86.Params): unknown;
+                        fromPartial(object: Partial<_86.Params>): _86.Params;
+                        fromProtoMsg(message: _86.ParamsProtoMsg): _86.Params;
+                        toProto(message: _86.Params): Uint8Array;
+                        toProtoMsg(message: _86.Params): _86.ParamsProtoMsg;
+                    };
+                };
+            }
+            namespace genesis {
+                const v1: {
+                    GenesisState: {
+                        typeUrl: string;
+                        encode(message: _89.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _89.GenesisState;
+                        fromJSON(object: any): _89.GenesisState;
+                        toJSON(message: _89.GenesisState): unknown;
+                        fromPartial(object: Partial<_89.GenesisState>): _89.GenesisState;
+                        fromProtoMsg(message: _89.GenesisStateProtoMsg): _89.GenesisState;
+                        toProto(message: _89.GenesisState): Uint8Array;
+                        toProtoMsg(message: _89.GenesisState): _89.GenesisStateProtoMsg;
+                    };
+                    ControllerGenesisState: {
+                        typeUrl: string;
+                        encode(message: _89.ControllerGenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _89.ControllerGenesisState;
+                        fromJSON(object: any): _89.ControllerGenesisState;
+                        toJSON(message: _89.ControllerGenesisState): unknown;
+                        fromPartial(object: Partial<_89.ControllerGenesisState>): _89.ControllerGenesisState;
+                        fromProtoMsg(message: _89.ControllerGenesisStateProtoMsg): _89.ControllerGenesisState;
+                        toProto(message: _89.ControllerGenesisState): Uint8Array;
+                        toProtoMsg(message: _89.ControllerGenesisState): _89.ControllerGenesisStateProtoMsg;
+                    };
+                    HostGenesisState: {
+                        typeUrl: string;
+                        encode(message: _89.HostGenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _89.HostGenesisState;
+                        fromJSON(object: any): _89.HostGenesisState;
+                        toJSON(message: _89.HostGenesisState): unknown;
+                        fromPartial(object: Partial<_89.HostGenesisState>): _89.HostGenesisState;
+                        fromProtoMsg(message: _89.HostGenesisStateProtoMsg): _89.HostGenesisState;
+                        toProto(message: _89.HostGenesisState): Uint8Array;
+                        toProtoMsg(message: _89.HostGenesisState): _89.HostGenesisStateProtoMsg;
+                    };
+                    ActiveChannel: {
+                        typeUrl: string;
+                        encode(message: _89.ActiveChannel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _89.ActiveChannel;
+                        fromJSON(object: any): _89.ActiveChannel;
+                        toJSON(message: _89.ActiveChannel): unknown;
+                        fromPartial(object: Partial<_89.ActiveChannel>): _89.ActiveChannel;
+                        fromProtoMsg(message: _89.ActiveChannelProtoMsg): _89.ActiveChannel;
+                        toProto(message: _89.ActiveChannel): Uint8Array;
+                        toProtoMsg(message: _89.ActiveChannel): _89.ActiveChannelProtoMsg;
+                    };
+                    RegisteredInterchainAccount: {
+                        typeUrl: string;
+                        encode(message: _89.RegisteredInterchainAccount, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _89.RegisteredInterchainAccount;
+                        fromJSON(object: any): _89.RegisteredInterchainAccount;
+                        toJSON(message: _89.RegisteredInterchainAccount): unknown;
+                        fromPartial(object: Partial<_89.RegisteredInterchainAccount>): _89.RegisteredInterchainAccount;
+                        fromProtoMsg(message: _89.RegisteredInterchainAccountProtoMsg): _89.RegisteredInterchainAccount;
+                        toProto(message: _89.RegisteredInterchainAccount): Uint8Array;
+                        toProtoMsg(message: _89.RegisteredInterchainAccount): _89.RegisteredInterchainAccountProtoMsg;
+                    };
+                };
+            }
+            namespace host {
+                const v1: {
+                    QueryParamsRequest: {
+                        typeUrl: string;
+                        encode(_: _91.QueryParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _91.QueryParamsRequest;
+                        fromJSON(_: any): _91.QueryParamsRequest;
+                        toJSON(_: _91.QueryParamsRequest): unknown;
+                        fromPartial(_: Partial<_91.QueryParamsRequest>): _91.QueryParamsRequest;
+                        fromProtoMsg(message: _91.QueryParamsRequestProtoMsg): _91.QueryParamsRequest;
+                        toProto(message: _91.QueryParamsRequest): Uint8Array;
+                        toProtoMsg(message: _91.QueryParamsRequest): _91.QueryParamsRequestProtoMsg;
+                    };
+                    QueryParamsResponse: {
+                        typeUrl: string;
+                        encode(message: _91.QueryParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _91.QueryParamsResponse;
+                        fromJSON(object: any): _91.QueryParamsResponse;
+                        toJSON(message: _91.QueryParamsResponse): unknown;
+                        fromPartial(object: Partial<_91.QueryParamsResponse>): _91.QueryParamsResponse;
+                        fromProtoMsg(message: _91.QueryParamsResponseProtoMsg): _91.QueryParamsResponse;
+                        toProto(message: _91.QueryParamsResponse): Uint8Array;
+                        toProtoMsg(message: _91.QueryParamsResponse): _91.QueryParamsResponseProtoMsg;
+                    };
+                    Params: {
+                        typeUrl: string;
+                        encode(message: _90.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _90.Params;
+                        fromJSON(object: any): _90.Params;
+                        toJSON(message: _90.Params): unknown;
+                        fromPartial(object: Partial<_90.Params>): _90.Params;
+                        fromProtoMsg(message: _90.ParamsProtoMsg): _90.Params;
+                        toProto(message: _90.Params): Uint8Array;
+                        toProtoMsg(message: _90.Params): _90.ParamsProtoMsg;
+                    };
+                };
+            }
+            const v1: {
+                typeFromJSON(object: any): _94.Type;
+                typeToJSON(object: _94.Type): string;
+                Type: typeof _94.Type;
+                TypeSDKType: typeof _94.Type;
+                InterchainAccountPacketData: {
+                    typeUrl: string;
+                    encode(message: _94.InterchainAccountPacketData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _94.InterchainAccountPacketData;
+                    fromJSON(object: any): _94.InterchainAccountPacketData;
+                    toJSON(message: _94.InterchainAccountPacketData): unknown;
+                    fromPartial(object: Partial<_94.InterchainAccountPacketData>): _94.InterchainAccountPacketData;
+                    fromProtoMsg(message: _94.InterchainAccountPacketDataProtoMsg): _94.InterchainAccountPacketData;
+                    toProto(message: _94.InterchainAccountPacketData): Uint8Array;
+                    toProtoMsg(message: _94.InterchainAccountPacketData): _94.InterchainAccountPacketDataProtoMsg;
+                };
+                CosmosTx: {
+                    typeUrl: string;
+                    encode(message: _94.CosmosTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _94.CosmosTx;
+                    fromJSON(object: any): _94.CosmosTx;
+                    toJSON(message: _94.CosmosTx): unknown;
+                    fromPartial(object: Partial<_94.CosmosTx>): _94.CosmosTx;
+                    fromProtoMsg(message: _94.CosmosTxProtoMsg): _94.CosmosTx;
+                    toProto(message: _94.CosmosTx): Uint8Array;
+                    toProtoMsg(message: _94.CosmosTx): _94.CosmosTxProtoMsg;
+                };
+                Metadata: {
+                    typeUrl: string;
+                    encode(message: _93.Metadata, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _93.Metadata;
+                    fromJSON(object: any): _93.Metadata;
+                    toJSON(message: _93.Metadata): unknown;
+                    fromPartial(object: Partial<_93.Metadata>): _93.Metadata;
+                    fromProtoMsg(message: _93.MetadataProtoMsg): _93.Metadata;
+                    toProto(message: _93.Metadata): Uint8Array;
+                    toProtoMsg(message: _93.Metadata): _93.MetadataProtoMsg;
+                };
+                InterchainAccount: {
+                    typeUrl: string;
+                    encode(message: _92.InterchainAccount, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _92.InterchainAccount;
+                    fromJSON(object: any): _92.InterchainAccount;
+                    toJSON(message: _92.InterchainAccount): unknown;
+                    fromPartial(object: Partial<_92.InterchainAccount>): _92.InterchainAccount;
+                    fromProtoMsg(message: _92.InterchainAccountProtoMsg): _92.InterchainAccount;
+                    toProto(message: _92.InterchainAccount): Uint8Array;
+                    toProtoMsg(message: _92.InterchainAccount): _92.InterchainAccountProtoMsg;
+                };
+            };
+        }
+        namespace transfer {
+            const v1: {
+                MsgTransfer: {
+                    typeUrl: string;
+                    encode(message: _99.MsgTransfer, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _99.MsgTransfer;
+                    fromJSON(object: any): _99.MsgTransfer;
+                    toJSON(message: _99.MsgTransfer): unknown;
+                    fromPartial(object: Partial<_99.MsgTransfer>): _99.MsgTransfer;
+                    fromProtoMsg(message: _99.MsgTransferProtoMsg): _99.MsgTransfer;
+                    toProto(message: _99.MsgTransfer): Uint8Array;
+                    toProtoMsg(message: _99.MsgTransfer): _99.MsgTransferProtoMsg;
+                };
+                MsgTransferResponse: {
+                    typeUrl: string;
+                    encode(message: _99.MsgTransferResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _99.MsgTransferResponse;
+                    fromJSON(object: any): _99.MsgTransferResponse;
+                    toJSON(message: _99.MsgTransferResponse): unknown;
+                    fromPartial(object: Partial<_99.MsgTransferResponse>): _99.MsgTransferResponse;
+                    fromProtoMsg(message: _99.MsgTransferResponseProtoMsg): _99.MsgTransferResponse;
+                    toProto(message: _99.MsgTransferResponse): Uint8Array;
+                    toProtoMsg(message: _99.MsgTransferResponse): _99.MsgTransferResponseProtoMsg;
+                };
+                DenomTrace: {
+                    typeUrl: string;
+                    encode(message: _98.DenomTrace, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _98.DenomTrace;
+                    fromJSON(object: any): _98.DenomTrace;
+                    toJSON(message: _98.DenomTrace): unknown;
+                    fromPartial(object: Partial<_98.DenomTrace>): _98.DenomTrace;
+                    fromProtoMsg(message: _98.DenomTraceProtoMsg): _98.DenomTrace;
+                    toProto(message: _98.DenomTrace): Uint8Array;
+                    toProtoMsg(message: _98.DenomTrace): _98.DenomTraceProtoMsg;
+                };
+                Params: {
+                    typeUrl: string;
+                    encode(message: _98.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _98.Params;
+                    fromJSON(object: any): _98.Params;
+                    toJSON(message: _98.Params): unknown;
+                    fromPartial(object: Partial<_98.Params>): _98.Params;
+                    fromProtoMsg(message: _98.ParamsProtoMsg): _98.Params;
+                    toProto(message: _98.Params): Uint8Array;
+                    toProtoMsg(message: _98.Params): _98.ParamsProtoMsg;
+                };
+                QueryDenomTraceRequest: {
+                    typeUrl: string;
+                    encode(message: _97.QueryDenomTraceRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryDenomTraceRequest;
+                    fromJSON(object: any): _97.QueryDenomTraceRequest;
+                    toJSON(message: _97.QueryDenomTraceRequest): unknown;
+                    fromPartial(object: Partial<_97.QueryDenomTraceRequest>): _97.QueryDenomTraceRequest;
+                    fromProtoMsg(message: _97.QueryDenomTraceRequestProtoMsg): _97.QueryDenomTraceRequest;
+                    toProto(message: _97.QueryDenomTraceRequest): Uint8Array;
+                    toProtoMsg(message: _97.QueryDenomTraceRequest): _97.QueryDenomTraceRequestProtoMsg;
+                };
+                QueryDenomTraceResponse: {
+                    typeUrl: string;
+                    encode(message: _97.QueryDenomTraceResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryDenomTraceResponse;
+                    fromJSON(object: any): _97.QueryDenomTraceResponse;
+                    toJSON(message: _97.QueryDenomTraceResponse): unknown;
+                    fromPartial(object: Partial<_97.QueryDenomTraceResponse>): _97.QueryDenomTraceResponse;
+                    fromProtoMsg(message: _97.QueryDenomTraceResponseProtoMsg): _97.QueryDenomTraceResponse;
+                    toProto(message: _97.QueryDenomTraceResponse): Uint8Array;
+                    toProtoMsg(message: _97.QueryDenomTraceResponse): _97.QueryDenomTraceResponseProtoMsg;
+                };
+                QueryDenomTracesRequest: {
+                    typeUrl: string;
+                    encode(message: _97.QueryDenomTracesRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryDenomTracesRequest;
+                    fromJSON(object: any): _97.QueryDenomTracesRequest;
+                    toJSON(message: _97.QueryDenomTracesRequest): unknown;
+                    fromPartial(object: Partial<_97.QueryDenomTracesRequest>): _97.QueryDenomTracesRequest;
+                    fromProtoMsg(message: _97.QueryDenomTracesRequestProtoMsg): _97.QueryDenomTracesRequest;
+                    toProto(message: _97.QueryDenomTracesRequest): Uint8Array;
+                    toProtoMsg(message: _97.QueryDenomTracesRequest): _97.QueryDenomTracesRequestProtoMsg;
+                };
+                QueryDenomTracesResponse: {
+                    typeUrl: string;
+                    encode(message: _97.QueryDenomTracesResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryDenomTracesResponse;
+                    fromJSON(object: any): _97.QueryDenomTracesResponse;
+                    toJSON(message: _97.QueryDenomTracesResponse): unknown;
+                    fromPartial(object: Partial<_97.QueryDenomTracesResponse>): _97.QueryDenomTracesResponse;
+                    fromProtoMsg(message: _97.QueryDenomTracesResponseProtoMsg): _97.QueryDenomTracesResponse;
+                    toProto(message: _97.QueryDenomTracesResponse): Uint8Array;
+                    toProtoMsg(message: _97.QueryDenomTracesResponse): _97.QueryDenomTracesResponseProtoMsg;
+                };
+                QueryParamsRequest: {
+                    typeUrl: string;
+                    encode(_: _97.QueryParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryParamsRequest;
+                    fromJSON(_: any): _97.QueryParamsRequest;
+                    toJSON(_: _97.QueryParamsRequest): unknown;
+                    fromPartial(_: Partial<_97.QueryParamsRequest>): _97.QueryParamsRequest;
+                    fromProtoMsg(message: _97.QueryParamsRequestProtoMsg): _97.QueryParamsRequest;
+                    toProto(message: _97.QueryParamsRequest): Uint8Array;
+                    toProtoMsg(message: _97.QueryParamsRequest): _97.QueryParamsRequestProtoMsg;
+                };
+                QueryParamsResponse: {
+                    typeUrl: string;
+                    encode(message: _97.QueryParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryParamsResponse;
+                    fromJSON(object: any): _97.QueryParamsResponse;
+                    toJSON(message: _97.QueryParamsResponse): unknown;
+                    fromPartial(object: Partial<_97.QueryParamsResponse>): _97.QueryParamsResponse;
+                    fromProtoMsg(message: _97.QueryParamsResponseProtoMsg): _97.QueryParamsResponse;
+                    toProto(message: _97.QueryParamsResponse): Uint8Array;
+                    toProtoMsg(message: _97.QueryParamsResponse): _97.QueryParamsResponseProtoMsg;
+                };
+                QueryDenomHashRequest: {
+                    typeUrl: string;
+                    encode(message: _97.QueryDenomHashRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryDenomHashRequest;
+                    fromJSON(object: any): _97.QueryDenomHashRequest;
+                    toJSON(message: _97.QueryDenomHashRequest): unknown;
+                    fromPartial(object: Partial<_97.QueryDenomHashRequest>): _97.QueryDenomHashRequest;
+                    fromProtoMsg(message: _97.QueryDenomHashRequestProtoMsg): _97.QueryDenomHashRequest;
+                    toProto(message: _97.QueryDenomHashRequest): Uint8Array;
+                    toProtoMsg(message: _97.QueryDenomHashRequest): _97.QueryDenomHashRequestProtoMsg;
+                };
+                QueryDenomHashResponse: {
+                    typeUrl: string;
+                    encode(message: _97.QueryDenomHashResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryDenomHashResponse;
+                    fromJSON(object: any): _97.QueryDenomHashResponse;
+                    toJSON(message: _97.QueryDenomHashResponse): unknown;
+                    fromPartial(object: Partial<_97.QueryDenomHashResponse>): _97.QueryDenomHashResponse;
+                    fromProtoMsg(message: _97.QueryDenomHashResponseProtoMsg): _97.QueryDenomHashResponse;
+                    toProto(message: _97.QueryDenomHashResponse): Uint8Array;
+                    toProtoMsg(message: _97.QueryDenomHashResponse): _97.QueryDenomHashResponseProtoMsg;
+                };
+                QueryEscrowAddressRequest: {
+                    typeUrl: string;
+                    encode(message: _97.QueryEscrowAddressRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryEscrowAddressRequest;
+                    fromJSON(object: any): _97.QueryEscrowAddressRequest;
+                    toJSON(message: _97.QueryEscrowAddressRequest): unknown;
+                    fromPartial(object: Partial<_97.QueryEscrowAddressRequest>): _97.QueryEscrowAddressRequest;
+                    fromProtoMsg(message: _97.QueryEscrowAddressRequestProtoMsg): _97.QueryEscrowAddressRequest;
+                    toProto(message: _97.QueryEscrowAddressRequest): Uint8Array;
+                    toProtoMsg(message: _97.QueryEscrowAddressRequest): _97.QueryEscrowAddressRequestProtoMsg;
+                };
+                QueryEscrowAddressResponse: {
+                    typeUrl: string;
+                    encode(message: _97.QueryEscrowAddressResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _97.QueryEscrowAddressResponse;
+                    fromJSON(object: any): _97.QueryEscrowAddressResponse;
+                    toJSON(message: _97.QueryEscrowAddressResponse): unknown;
+                    fromPartial(object: Partial<_97.QueryEscrowAddressResponse>): _97.QueryEscrowAddressResponse;
+                    fromProtoMsg(message: _97.QueryEscrowAddressResponseProtoMsg): _97.QueryEscrowAddressResponse;
+                    toProto(message: _97.QueryEscrowAddressResponse): Uint8Array;
+                    toProtoMsg(message: _97.QueryEscrowAddressResponse): _97.QueryEscrowAddressResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: string;
+                    encode(message: _96.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _96.GenesisState;
+                    fromJSON(object: any): _96.GenesisState;
+                    toJSON(message: _96.GenesisState): unknown;
+                    fromPartial(object: Partial<_96.GenesisState>): _96.GenesisState;
+                    fromProtoMsg(message: _96.GenesisStateProtoMsg): _96.GenesisState;
+                    toProto(message: _96.GenesisState): Uint8Array;
+                    toProtoMsg(message: _96.GenesisState): _96.GenesisStateProtoMsg;
+                };
+                Allocation: {
+                    typeUrl: string;
+                    encode(message: _95.Allocation, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _95.Allocation;
+                    fromJSON(object: any): _95.Allocation;
+                    toJSON(message: _95.Allocation): unknown;
+                    fromPartial(object: Partial<_95.Allocation>): _95.Allocation;
+                    fromProtoMsg(message: _95.AllocationProtoMsg): _95.Allocation;
+                    toProto(message: _95.Allocation): Uint8Array;
+                    toProtoMsg(message: _95.Allocation): _95.AllocationProtoMsg;
+                };
+                TransferAuthorization: {
+                    typeUrl: string;
+                    encode(message: _95.TransferAuthorization, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _95.TransferAuthorization;
+                    fromJSON(object: any): _95.TransferAuthorization;
+                    toJSON(message: _95.TransferAuthorization): unknown;
+                    fromPartial(object: Partial<_95.TransferAuthorization>): _95.TransferAuthorization;
+                    fromProtoMsg(message: _95.TransferAuthorizationProtoMsg): _95.TransferAuthorization;
+                    toProto(message: _95.TransferAuthorization): Uint8Array;
+                    toProtoMsg(message: _95.TransferAuthorization): _95.TransferAuthorizationProtoMsg;
+                };
+            };
+            const v2: {
+                FungibleTokenPacketData: {
+                    typeUrl: string;
+                    encode(message: _100.FungibleTokenPacketData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _100.FungibleTokenPacketData;
+                    fromJSON(object: any): _100.FungibleTokenPacketData;
+                    toJSON(message: _100.FungibleTokenPacketData): unknown;
+                    fromPartial(object: Partial<_100.FungibleTokenPacketData>): _100.FungibleTokenPacketData;
+                    fromProtoMsg(message: _100.FungibleTokenPacketDataProtoMsg): _100.FungibleTokenPacketData;
+                    toProto(message: _100.FungibleTokenPacketData): Uint8Array;
+                    toProtoMsg(message: _100.FungibleTokenPacketData): _100.FungibleTokenPacketDataProtoMsg;
+                };
+            };
+        }
+    }
     namespace core {
         namespace channel {
             const v1: {
-                stateFromJSON(object: any): _85.State;
-                stateToJSON(object: _85.State): string;
-                orderFromJSON(object: any): _85.Order;
-                orderToJSON(object: _85.Order): string;
-                State: typeof _85.State;
-                StateSDKType: typeof _85.State;
-                Order: typeof _85.Order;
-                OrderSDKType: typeof _85.Order;
+                responseResultTypeFromJSON(object: any): _104.ResponseResultType;
+                responseResultTypeToJSON(object: _104.ResponseResultType): string;
+                ResponseResultType: typeof _104.ResponseResultType;
+                ResponseResultTypeSDKType: typeof _104.ResponseResultType;
+                MsgChannelOpenInit: {
+                    typeUrl: string;
+                    encode(message: _104.MsgChannelOpenInit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelOpenInit;
+                    fromJSON(object: any): _104.MsgChannelOpenInit;
+                    toJSON(message: _104.MsgChannelOpenInit): unknown;
+                    fromPartial(object: Partial<_104.MsgChannelOpenInit>): _104.MsgChannelOpenInit;
+                    fromProtoMsg(message: _104.MsgChannelOpenInitProtoMsg): _104.MsgChannelOpenInit;
+                    toProto(message: _104.MsgChannelOpenInit): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelOpenInit): _104.MsgChannelOpenInitProtoMsg;
+                };
+                MsgChannelOpenInitResponse: {
+                    typeUrl: string;
+                    encode(message: _104.MsgChannelOpenInitResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelOpenInitResponse;
+                    fromJSON(object: any): _104.MsgChannelOpenInitResponse;
+                    toJSON(message: _104.MsgChannelOpenInitResponse): unknown;
+                    fromPartial(object: Partial<_104.MsgChannelOpenInitResponse>): _104.MsgChannelOpenInitResponse;
+                    fromProtoMsg(message: _104.MsgChannelOpenInitResponseProtoMsg): _104.MsgChannelOpenInitResponse;
+                    toProto(message: _104.MsgChannelOpenInitResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelOpenInitResponse): _104.MsgChannelOpenInitResponseProtoMsg;
+                };
+                MsgChannelOpenTry: {
+                    typeUrl: string;
+                    encode(message: _104.MsgChannelOpenTry, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelOpenTry;
+                    fromJSON(object: any): _104.MsgChannelOpenTry;
+                    toJSON(message: _104.MsgChannelOpenTry): unknown;
+                    fromPartial(object: Partial<_104.MsgChannelOpenTry>): _104.MsgChannelOpenTry;
+                    fromProtoMsg(message: _104.MsgChannelOpenTryProtoMsg): _104.MsgChannelOpenTry;
+                    toProto(message: _104.MsgChannelOpenTry): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelOpenTry): _104.MsgChannelOpenTryProtoMsg;
+                };
+                MsgChannelOpenTryResponse: {
+                    typeUrl: string;
+                    encode(message: _104.MsgChannelOpenTryResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelOpenTryResponse;
+                    fromJSON(object: any): _104.MsgChannelOpenTryResponse;
+                    toJSON(message: _104.MsgChannelOpenTryResponse): unknown;
+                    fromPartial(object: Partial<_104.MsgChannelOpenTryResponse>): _104.MsgChannelOpenTryResponse;
+                    fromProtoMsg(message: _104.MsgChannelOpenTryResponseProtoMsg): _104.MsgChannelOpenTryResponse;
+                    toProto(message: _104.MsgChannelOpenTryResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelOpenTryResponse): _104.MsgChannelOpenTryResponseProtoMsg;
+                };
+                MsgChannelOpenAck: {
+                    typeUrl: string;
+                    encode(message: _104.MsgChannelOpenAck, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelOpenAck;
+                    fromJSON(object: any): _104.MsgChannelOpenAck;
+                    toJSON(message: _104.MsgChannelOpenAck): unknown;
+                    fromPartial(object: Partial<_104.MsgChannelOpenAck>): _104.MsgChannelOpenAck;
+                    fromProtoMsg(message: _104.MsgChannelOpenAckProtoMsg): _104.MsgChannelOpenAck;
+                    toProto(message: _104.MsgChannelOpenAck): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelOpenAck): _104.MsgChannelOpenAckProtoMsg;
+                };
+                MsgChannelOpenAckResponse: {
+                    typeUrl: string;
+                    encode(_: _104.MsgChannelOpenAckResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelOpenAckResponse;
+                    fromJSON(_: any): _104.MsgChannelOpenAckResponse;
+                    toJSON(_: _104.MsgChannelOpenAckResponse): unknown;
+                    fromPartial(_: Partial<_104.MsgChannelOpenAckResponse>): _104.MsgChannelOpenAckResponse;
+                    fromProtoMsg(message: _104.MsgChannelOpenAckResponseProtoMsg): _104.MsgChannelOpenAckResponse;
+                    toProto(message: _104.MsgChannelOpenAckResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelOpenAckResponse): _104.MsgChannelOpenAckResponseProtoMsg;
+                };
+                MsgChannelOpenConfirm: {
+                    typeUrl: string;
+                    encode(message: _104.MsgChannelOpenConfirm, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelOpenConfirm;
+                    fromJSON(object: any): _104.MsgChannelOpenConfirm;
+                    toJSON(message: _104.MsgChannelOpenConfirm): unknown;
+                    fromPartial(object: Partial<_104.MsgChannelOpenConfirm>): _104.MsgChannelOpenConfirm;
+                    fromProtoMsg(message: _104.MsgChannelOpenConfirmProtoMsg): _104.MsgChannelOpenConfirm;
+                    toProto(message: _104.MsgChannelOpenConfirm): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelOpenConfirm): _104.MsgChannelOpenConfirmProtoMsg;
+                };
+                MsgChannelOpenConfirmResponse: {
+                    typeUrl: string;
+                    encode(_: _104.MsgChannelOpenConfirmResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelOpenConfirmResponse;
+                    fromJSON(_: any): _104.MsgChannelOpenConfirmResponse;
+                    toJSON(_: _104.MsgChannelOpenConfirmResponse): unknown;
+                    fromPartial(_: Partial<_104.MsgChannelOpenConfirmResponse>): _104.MsgChannelOpenConfirmResponse;
+                    fromProtoMsg(message: _104.MsgChannelOpenConfirmResponseProtoMsg): _104.MsgChannelOpenConfirmResponse;
+                    toProto(message: _104.MsgChannelOpenConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelOpenConfirmResponse): _104.MsgChannelOpenConfirmResponseProtoMsg;
+                };
+                MsgChannelCloseInit: {
+                    typeUrl: string;
+                    encode(message: _104.MsgChannelCloseInit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelCloseInit;
+                    fromJSON(object: any): _104.MsgChannelCloseInit;
+                    toJSON(message: _104.MsgChannelCloseInit): unknown;
+                    fromPartial(object: Partial<_104.MsgChannelCloseInit>): _104.MsgChannelCloseInit;
+                    fromProtoMsg(message: _104.MsgChannelCloseInitProtoMsg): _104.MsgChannelCloseInit;
+                    toProto(message: _104.MsgChannelCloseInit): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelCloseInit): _104.MsgChannelCloseInitProtoMsg;
+                };
+                MsgChannelCloseInitResponse: {
+                    typeUrl: string;
+                    encode(_: _104.MsgChannelCloseInitResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelCloseInitResponse;
+                    fromJSON(_: any): _104.MsgChannelCloseInitResponse;
+                    toJSON(_: _104.MsgChannelCloseInitResponse): unknown;
+                    fromPartial(_: Partial<_104.MsgChannelCloseInitResponse>): _104.MsgChannelCloseInitResponse;
+                    fromProtoMsg(message: _104.MsgChannelCloseInitResponseProtoMsg): _104.MsgChannelCloseInitResponse;
+                    toProto(message: _104.MsgChannelCloseInitResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelCloseInitResponse): _104.MsgChannelCloseInitResponseProtoMsg;
+                };
+                MsgChannelCloseConfirm: {
+                    typeUrl: string;
+                    encode(message: _104.MsgChannelCloseConfirm, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelCloseConfirm;
+                    fromJSON(object: any): _104.MsgChannelCloseConfirm;
+                    toJSON(message: _104.MsgChannelCloseConfirm): unknown;
+                    fromPartial(object: Partial<_104.MsgChannelCloseConfirm>): _104.MsgChannelCloseConfirm;
+                    fromProtoMsg(message: _104.MsgChannelCloseConfirmProtoMsg): _104.MsgChannelCloseConfirm;
+                    toProto(message: _104.MsgChannelCloseConfirm): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelCloseConfirm): _104.MsgChannelCloseConfirmProtoMsg;
+                };
+                MsgChannelCloseConfirmResponse: {
+                    typeUrl: string;
+                    encode(_: _104.MsgChannelCloseConfirmResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgChannelCloseConfirmResponse;
+                    fromJSON(_: any): _104.MsgChannelCloseConfirmResponse;
+                    toJSON(_: _104.MsgChannelCloseConfirmResponse): unknown;
+                    fromPartial(_: Partial<_104.MsgChannelCloseConfirmResponse>): _104.MsgChannelCloseConfirmResponse;
+                    fromProtoMsg(message: _104.MsgChannelCloseConfirmResponseProtoMsg): _104.MsgChannelCloseConfirmResponse;
+                    toProto(message: _104.MsgChannelCloseConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgChannelCloseConfirmResponse): _104.MsgChannelCloseConfirmResponseProtoMsg;
+                };
+                MsgRecvPacket: {
+                    typeUrl: string;
+                    encode(message: _104.MsgRecvPacket, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgRecvPacket;
+                    fromJSON(object: any): _104.MsgRecvPacket;
+                    toJSON(message: _104.MsgRecvPacket): unknown;
+                    fromPartial(object: Partial<_104.MsgRecvPacket>): _104.MsgRecvPacket;
+                    fromProtoMsg(message: _104.MsgRecvPacketProtoMsg): _104.MsgRecvPacket;
+                    toProto(message: _104.MsgRecvPacket): Uint8Array;
+                    toProtoMsg(message: _104.MsgRecvPacket): _104.MsgRecvPacketProtoMsg;
+                };
+                MsgRecvPacketResponse: {
+                    typeUrl: string;
+                    encode(message: _104.MsgRecvPacketResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgRecvPacketResponse;
+                    fromJSON(object: any): _104.MsgRecvPacketResponse;
+                    toJSON(message: _104.MsgRecvPacketResponse): unknown;
+                    fromPartial(object: Partial<_104.MsgRecvPacketResponse>): _104.MsgRecvPacketResponse;
+                    fromProtoMsg(message: _104.MsgRecvPacketResponseProtoMsg): _104.MsgRecvPacketResponse;
+                    toProto(message: _104.MsgRecvPacketResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgRecvPacketResponse): _104.MsgRecvPacketResponseProtoMsg;
+                };
+                MsgTimeout: {
+                    typeUrl: string;
+                    encode(message: _104.MsgTimeout, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgTimeout;
+                    fromJSON(object: any): _104.MsgTimeout;
+                    toJSON(message: _104.MsgTimeout): unknown;
+                    fromPartial(object: Partial<_104.MsgTimeout>): _104.MsgTimeout;
+                    fromProtoMsg(message: _104.MsgTimeoutProtoMsg): _104.MsgTimeout;
+                    toProto(message: _104.MsgTimeout): Uint8Array;
+                    toProtoMsg(message: _104.MsgTimeout): _104.MsgTimeoutProtoMsg;
+                };
+                MsgTimeoutResponse: {
+                    typeUrl: string;
+                    encode(message: _104.MsgTimeoutResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgTimeoutResponse;
+                    fromJSON(object: any): _104.MsgTimeoutResponse;
+                    toJSON(message: _104.MsgTimeoutResponse): unknown;
+                    fromPartial(object: Partial<_104.MsgTimeoutResponse>): _104.MsgTimeoutResponse;
+                    fromProtoMsg(message: _104.MsgTimeoutResponseProtoMsg): _104.MsgTimeoutResponse;
+                    toProto(message: _104.MsgTimeoutResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgTimeoutResponse): _104.MsgTimeoutResponseProtoMsg;
+                };
+                MsgTimeoutOnClose: {
+                    typeUrl: string;
+                    encode(message: _104.MsgTimeoutOnClose, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgTimeoutOnClose;
+                    fromJSON(object: any): _104.MsgTimeoutOnClose;
+                    toJSON(message: _104.MsgTimeoutOnClose): unknown;
+                    fromPartial(object: Partial<_104.MsgTimeoutOnClose>): _104.MsgTimeoutOnClose;
+                    fromProtoMsg(message: _104.MsgTimeoutOnCloseProtoMsg): _104.MsgTimeoutOnClose;
+                    toProto(message: _104.MsgTimeoutOnClose): Uint8Array;
+                    toProtoMsg(message: _104.MsgTimeoutOnClose): _104.MsgTimeoutOnCloseProtoMsg;
+                };
+                MsgTimeoutOnCloseResponse: {
+                    typeUrl: string;
+                    encode(message: _104.MsgTimeoutOnCloseResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgTimeoutOnCloseResponse;
+                    fromJSON(object: any): _104.MsgTimeoutOnCloseResponse;
+                    toJSON(message: _104.MsgTimeoutOnCloseResponse): unknown;
+                    fromPartial(object: Partial<_104.MsgTimeoutOnCloseResponse>): _104.MsgTimeoutOnCloseResponse;
+                    fromProtoMsg(message: _104.MsgTimeoutOnCloseResponseProtoMsg): _104.MsgTimeoutOnCloseResponse;
+                    toProto(message: _104.MsgTimeoutOnCloseResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgTimeoutOnCloseResponse): _104.MsgTimeoutOnCloseResponseProtoMsg;
+                };
+                MsgAcknowledgement: {
+                    typeUrl: string;
+                    encode(message: _104.MsgAcknowledgement, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgAcknowledgement;
+                    fromJSON(object: any): _104.MsgAcknowledgement;
+                    toJSON(message: _104.MsgAcknowledgement): unknown;
+                    fromPartial(object: Partial<_104.MsgAcknowledgement>): _104.MsgAcknowledgement;
+                    fromProtoMsg(message: _104.MsgAcknowledgementProtoMsg): _104.MsgAcknowledgement;
+                    toProto(message: _104.MsgAcknowledgement): Uint8Array;
+                    toProtoMsg(message: _104.MsgAcknowledgement): _104.MsgAcknowledgementProtoMsg;
+                };
+                MsgAcknowledgementResponse: {
+                    typeUrl: string;
+                    encode(message: _104.MsgAcknowledgementResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _104.MsgAcknowledgementResponse;
+                    fromJSON(object: any): _104.MsgAcknowledgementResponse;
+                    toJSON(message: _104.MsgAcknowledgementResponse): unknown;
+                    fromPartial(object: Partial<_104.MsgAcknowledgementResponse>): _104.MsgAcknowledgementResponse;
+                    fromProtoMsg(message: _104.MsgAcknowledgementResponseProtoMsg): _104.MsgAcknowledgementResponse;
+                    toProto(message: _104.MsgAcknowledgementResponse): Uint8Array;
+                    toProtoMsg(message: _104.MsgAcknowledgementResponse): _104.MsgAcknowledgementResponseProtoMsg;
+                };
+                QueryChannelRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryChannelRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryChannelRequest;
+                    fromJSON(object: any): _103.QueryChannelRequest;
+                    toJSON(message: _103.QueryChannelRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryChannelRequest>): _103.QueryChannelRequest;
+                    fromProtoMsg(message: _103.QueryChannelRequestProtoMsg): _103.QueryChannelRequest;
+                    toProto(message: _103.QueryChannelRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryChannelRequest): _103.QueryChannelRequestProtoMsg;
+                };
+                QueryChannelResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryChannelResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryChannelResponse;
+                    fromJSON(object: any): _103.QueryChannelResponse;
+                    toJSON(message: _103.QueryChannelResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryChannelResponse>): _103.QueryChannelResponse;
+                    fromProtoMsg(message: _103.QueryChannelResponseProtoMsg): _103.QueryChannelResponse;
+                    toProto(message: _103.QueryChannelResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryChannelResponse): _103.QueryChannelResponseProtoMsg;
+                };
+                QueryChannelsRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryChannelsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryChannelsRequest;
+                    fromJSON(object: any): _103.QueryChannelsRequest;
+                    toJSON(message: _103.QueryChannelsRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryChannelsRequest>): _103.QueryChannelsRequest;
+                    fromProtoMsg(message: _103.QueryChannelsRequestProtoMsg): _103.QueryChannelsRequest;
+                    toProto(message: _103.QueryChannelsRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryChannelsRequest): _103.QueryChannelsRequestProtoMsg;
+                };
+                QueryChannelsResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryChannelsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryChannelsResponse;
+                    fromJSON(object: any): _103.QueryChannelsResponse;
+                    toJSON(message: _103.QueryChannelsResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryChannelsResponse>): _103.QueryChannelsResponse;
+                    fromProtoMsg(message: _103.QueryChannelsResponseProtoMsg): _103.QueryChannelsResponse;
+                    toProto(message: _103.QueryChannelsResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryChannelsResponse): _103.QueryChannelsResponseProtoMsg;
+                };
+                QueryConnectionChannelsRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryConnectionChannelsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryConnectionChannelsRequest;
+                    fromJSON(object: any): _103.QueryConnectionChannelsRequest;
+                    toJSON(message: _103.QueryConnectionChannelsRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryConnectionChannelsRequest>): _103.QueryConnectionChannelsRequest;
+                    fromProtoMsg(message: _103.QueryConnectionChannelsRequestProtoMsg): _103.QueryConnectionChannelsRequest;
+                    toProto(message: _103.QueryConnectionChannelsRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryConnectionChannelsRequest): _103.QueryConnectionChannelsRequestProtoMsg;
+                };
+                QueryConnectionChannelsResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryConnectionChannelsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryConnectionChannelsResponse;
+                    fromJSON(object: any): _103.QueryConnectionChannelsResponse;
+                    toJSON(message: _103.QueryConnectionChannelsResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryConnectionChannelsResponse>): _103.QueryConnectionChannelsResponse;
+                    fromProtoMsg(message: _103.QueryConnectionChannelsResponseProtoMsg): _103.QueryConnectionChannelsResponse;
+                    toProto(message: _103.QueryConnectionChannelsResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryConnectionChannelsResponse): _103.QueryConnectionChannelsResponseProtoMsg;
+                };
+                QueryChannelClientStateRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryChannelClientStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryChannelClientStateRequest;
+                    fromJSON(object: any): _103.QueryChannelClientStateRequest;
+                    toJSON(message: _103.QueryChannelClientStateRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryChannelClientStateRequest>): _103.QueryChannelClientStateRequest;
+                    fromProtoMsg(message: _103.QueryChannelClientStateRequestProtoMsg): _103.QueryChannelClientStateRequest;
+                    toProto(message: _103.QueryChannelClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryChannelClientStateRequest): _103.QueryChannelClientStateRequestProtoMsg;
+                };
+                QueryChannelClientStateResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryChannelClientStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryChannelClientStateResponse;
+                    fromJSON(object: any): _103.QueryChannelClientStateResponse;
+                    toJSON(message: _103.QueryChannelClientStateResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryChannelClientStateResponse>): _103.QueryChannelClientStateResponse;
+                    fromProtoMsg(message: _103.QueryChannelClientStateResponseProtoMsg): _103.QueryChannelClientStateResponse;
+                    toProto(message: _103.QueryChannelClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryChannelClientStateResponse): _103.QueryChannelClientStateResponseProtoMsg;
+                };
+                QueryChannelConsensusStateRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryChannelConsensusStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryChannelConsensusStateRequest;
+                    fromJSON(object: any): _103.QueryChannelConsensusStateRequest;
+                    toJSON(message: _103.QueryChannelConsensusStateRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryChannelConsensusStateRequest>): _103.QueryChannelConsensusStateRequest;
+                    fromProtoMsg(message: _103.QueryChannelConsensusStateRequestProtoMsg): _103.QueryChannelConsensusStateRequest;
+                    toProto(message: _103.QueryChannelConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryChannelConsensusStateRequest): _103.QueryChannelConsensusStateRequestProtoMsg;
+                };
+                QueryChannelConsensusStateResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryChannelConsensusStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryChannelConsensusStateResponse;
+                    fromJSON(object: any): _103.QueryChannelConsensusStateResponse;
+                    toJSON(message: _103.QueryChannelConsensusStateResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryChannelConsensusStateResponse>): _103.QueryChannelConsensusStateResponse;
+                    fromProtoMsg(message: _103.QueryChannelConsensusStateResponseProtoMsg): _103.QueryChannelConsensusStateResponse;
+                    toProto(message: _103.QueryChannelConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryChannelConsensusStateResponse): _103.QueryChannelConsensusStateResponseProtoMsg;
+                };
+                QueryPacketCommitmentRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketCommitmentRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketCommitmentRequest;
+                    fromJSON(object: any): _103.QueryPacketCommitmentRequest;
+                    toJSON(message: _103.QueryPacketCommitmentRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketCommitmentRequest>): _103.QueryPacketCommitmentRequest;
+                    fromProtoMsg(message: _103.QueryPacketCommitmentRequestProtoMsg): _103.QueryPacketCommitmentRequest;
+                    toProto(message: _103.QueryPacketCommitmentRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketCommitmentRequest): _103.QueryPacketCommitmentRequestProtoMsg;
+                };
+                QueryPacketCommitmentResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketCommitmentResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketCommitmentResponse;
+                    fromJSON(object: any): _103.QueryPacketCommitmentResponse;
+                    toJSON(message: _103.QueryPacketCommitmentResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketCommitmentResponse>): _103.QueryPacketCommitmentResponse;
+                    fromProtoMsg(message: _103.QueryPacketCommitmentResponseProtoMsg): _103.QueryPacketCommitmentResponse;
+                    toProto(message: _103.QueryPacketCommitmentResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketCommitmentResponse): _103.QueryPacketCommitmentResponseProtoMsg;
+                };
+                QueryPacketCommitmentsRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketCommitmentsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketCommitmentsRequest;
+                    fromJSON(object: any): _103.QueryPacketCommitmentsRequest;
+                    toJSON(message: _103.QueryPacketCommitmentsRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketCommitmentsRequest>): _103.QueryPacketCommitmentsRequest;
+                    fromProtoMsg(message: _103.QueryPacketCommitmentsRequestProtoMsg): _103.QueryPacketCommitmentsRequest;
+                    toProto(message: _103.QueryPacketCommitmentsRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketCommitmentsRequest): _103.QueryPacketCommitmentsRequestProtoMsg;
+                };
+                QueryPacketCommitmentsResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketCommitmentsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketCommitmentsResponse;
+                    fromJSON(object: any): _103.QueryPacketCommitmentsResponse;
+                    toJSON(message: _103.QueryPacketCommitmentsResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketCommitmentsResponse>): _103.QueryPacketCommitmentsResponse;
+                    fromProtoMsg(message: _103.QueryPacketCommitmentsResponseProtoMsg): _103.QueryPacketCommitmentsResponse;
+                    toProto(message: _103.QueryPacketCommitmentsResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketCommitmentsResponse): _103.QueryPacketCommitmentsResponseProtoMsg;
+                };
+                QueryPacketReceiptRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketReceiptRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketReceiptRequest;
+                    fromJSON(object: any): _103.QueryPacketReceiptRequest;
+                    toJSON(message: _103.QueryPacketReceiptRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketReceiptRequest>): _103.QueryPacketReceiptRequest;
+                    fromProtoMsg(message: _103.QueryPacketReceiptRequestProtoMsg): _103.QueryPacketReceiptRequest;
+                    toProto(message: _103.QueryPacketReceiptRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketReceiptRequest): _103.QueryPacketReceiptRequestProtoMsg;
+                };
+                QueryPacketReceiptResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketReceiptResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketReceiptResponse;
+                    fromJSON(object: any): _103.QueryPacketReceiptResponse;
+                    toJSON(message: _103.QueryPacketReceiptResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketReceiptResponse>): _103.QueryPacketReceiptResponse;
+                    fromProtoMsg(message: _103.QueryPacketReceiptResponseProtoMsg): _103.QueryPacketReceiptResponse;
+                    toProto(message: _103.QueryPacketReceiptResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketReceiptResponse): _103.QueryPacketReceiptResponseProtoMsg;
+                };
+                QueryPacketAcknowledgementRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketAcknowledgementRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketAcknowledgementRequest;
+                    fromJSON(object: any): _103.QueryPacketAcknowledgementRequest;
+                    toJSON(message: _103.QueryPacketAcknowledgementRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketAcknowledgementRequest>): _103.QueryPacketAcknowledgementRequest;
+                    fromProtoMsg(message: _103.QueryPacketAcknowledgementRequestProtoMsg): _103.QueryPacketAcknowledgementRequest;
+                    toProto(message: _103.QueryPacketAcknowledgementRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketAcknowledgementRequest): _103.QueryPacketAcknowledgementRequestProtoMsg;
+                };
+                QueryPacketAcknowledgementResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketAcknowledgementResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketAcknowledgementResponse;
+                    fromJSON(object: any): _103.QueryPacketAcknowledgementResponse;
+                    toJSON(message: _103.QueryPacketAcknowledgementResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketAcknowledgementResponse>): _103.QueryPacketAcknowledgementResponse;
+                    fromProtoMsg(message: _103.QueryPacketAcknowledgementResponseProtoMsg): _103.QueryPacketAcknowledgementResponse;
+                    toProto(message: _103.QueryPacketAcknowledgementResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketAcknowledgementResponse): _103.QueryPacketAcknowledgementResponseProtoMsg;
+                };
+                QueryPacketAcknowledgementsRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketAcknowledgementsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketAcknowledgementsRequest;
+                    fromJSON(object: any): _103.QueryPacketAcknowledgementsRequest;
+                    toJSON(message: _103.QueryPacketAcknowledgementsRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketAcknowledgementsRequest>): _103.QueryPacketAcknowledgementsRequest;
+                    fromProtoMsg(message: _103.QueryPacketAcknowledgementsRequestProtoMsg): _103.QueryPacketAcknowledgementsRequest;
+                    toProto(message: _103.QueryPacketAcknowledgementsRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketAcknowledgementsRequest): _103.QueryPacketAcknowledgementsRequestProtoMsg;
+                };
+                QueryPacketAcknowledgementsResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryPacketAcknowledgementsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryPacketAcknowledgementsResponse;
+                    fromJSON(object: any): _103.QueryPacketAcknowledgementsResponse;
+                    toJSON(message: _103.QueryPacketAcknowledgementsResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryPacketAcknowledgementsResponse>): _103.QueryPacketAcknowledgementsResponse;
+                    fromProtoMsg(message: _103.QueryPacketAcknowledgementsResponseProtoMsg): _103.QueryPacketAcknowledgementsResponse;
+                    toProto(message: _103.QueryPacketAcknowledgementsResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryPacketAcknowledgementsResponse): _103.QueryPacketAcknowledgementsResponseProtoMsg;
+                };
+                QueryUnreceivedPacketsRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryUnreceivedPacketsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryUnreceivedPacketsRequest;
+                    fromJSON(object: any): _103.QueryUnreceivedPacketsRequest;
+                    toJSON(message: _103.QueryUnreceivedPacketsRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryUnreceivedPacketsRequest>): _103.QueryUnreceivedPacketsRequest;
+                    fromProtoMsg(message: _103.QueryUnreceivedPacketsRequestProtoMsg): _103.QueryUnreceivedPacketsRequest;
+                    toProto(message: _103.QueryUnreceivedPacketsRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryUnreceivedPacketsRequest): _103.QueryUnreceivedPacketsRequestProtoMsg;
+                };
+                QueryUnreceivedPacketsResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryUnreceivedPacketsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryUnreceivedPacketsResponse;
+                    fromJSON(object: any): _103.QueryUnreceivedPacketsResponse;
+                    toJSON(message: _103.QueryUnreceivedPacketsResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryUnreceivedPacketsResponse>): _103.QueryUnreceivedPacketsResponse;
+                    fromProtoMsg(message: _103.QueryUnreceivedPacketsResponseProtoMsg): _103.QueryUnreceivedPacketsResponse;
+                    toProto(message: _103.QueryUnreceivedPacketsResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryUnreceivedPacketsResponse): _103.QueryUnreceivedPacketsResponseProtoMsg;
+                };
+                QueryUnreceivedAcksRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryUnreceivedAcksRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryUnreceivedAcksRequest;
+                    fromJSON(object: any): _103.QueryUnreceivedAcksRequest;
+                    toJSON(message: _103.QueryUnreceivedAcksRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryUnreceivedAcksRequest>): _103.QueryUnreceivedAcksRequest;
+                    fromProtoMsg(message: _103.QueryUnreceivedAcksRequestProtoMsg): _103.QueryUnreceivedAcksRequest;
+                    toProto(message: _103.QueryUnreceivedAcksRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryUnreceivedAcksRequest): _103.QueryUnreceivedAcksRequestProtoMsg;
+                };
+                QueryUnreceivedAcksResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryUnreceivedAcksResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryUnreceivedAcksResponse;
+                    fromJSON(object: any): _103.QueryUnreceivedAcksResponse;
+                    toJSON(message: _103.QueryUnreceivedAcksResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryUnreceivedAcksResponse>): _103.QueryUnreceivedAcksResponse;
+                    fromProtoMsg(message: _103.QueryUnreceivedAcksResponseProtoMsg): _103.QueryUnreceivedAcksResponse;
+                    toProto(message: _103.QueryUnreceivedAcksResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryUnreceivedAcksResponse): _103.QueryUnreceivedAcksResponseProtoMsg;
+                };
+                QueryNextSequenceReceiveRequest: {
+                    typeUrl: string;
+                    encode(message: _103.QueryNextSequenceReceiveRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryNextSequenceReceiveRequest;
+                    fromJSON(object: any): _103.QueryNextSequenceReceiveRequest;
+                    toJSON(message: _103.QueryNextSequenceReceiveRequest): unknown;
+                    fromPartial(object: Partial<_103.QueryNextSequenceReceiveRequest>): _103.QueryNextSequenceReceiveRequest;
+                    fromProtoMsg(message: _103.QueryNextSequenceReceiveRequestProtoMsg): _103.QueryNextSequenceReceiveRequest;
+                    toProto(message: _103.QueryNextSequenceReceiveRequest): Uint8Array;
+                    toProtoMsg(message: _103.QueryNextSequenceReceiveRequest): _103.QueryNextSequenceReceiveRequestProtoMsg;
+                };
+                QueryNextSequenceReceiveResponse: {
+                    typeUrl: string;
+                    encode(message: _103.QueryNextSequenceReceiveResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _103.QueryNextSequenceReceiveResponse;
+                    fromJSON(object: any): _103.QueryNextSequenceReceiveResponse;
+                    toJSON(message: _103.QueryNextSequenceReceiveResponse): unknown;
+                    fromPartial(object: Partial<_103.QueryNextSequenceReceiveResponse>): _103.QueryNextSequenceReceiveResponse;
+                    fromProtoMsg(message: _103.QueryNextSequenceReceiveResponseProtoMsg): _103.QueryNextSequenceReceiveResponse;
+                    toProto(message: _103.QueryNextSequenceReceiveResponse): Uint8Array;
+                    toProtoMsg(message: _103.QueryNextSequenceReceiveResponse): _103.QueryNextSequenceReceiveResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: string;
+                    encode(message: _102.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _102.GenesisState;
+                    fromJSON(object: any): _102.GenesisState;
+                    toJSON(message: _102.GenesisState): unknown;
+                    fromPartial(object: Partial<_102.GenesisState>): _102.GenesisState;
+                    fromProtoMsg(message: _102.GenesisStateProtoMsg): _102.GenesisState;
+                    toProto(message: _102.GenesisState): Uint8Array;
+                    toProtoMsg(message: _102.GenesisState): _102.GenesisStateProtoMsg;
+                };
+                PacketSequence: {
+                    typeUrl: string;
+                    encode(message: _102.PacketSequence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _102.PacketSequence;
+                    fromJSON(object: any): _102.PacketSequence;
+                    toJSON(message: _102.PacketSequence): unknown;
+                    fromPartial(object: Partial<_102.PacketSequence>): _102.PacketSequence;
+                    fromProtoMsg(message: _102.PacketSequenceProtoMsg): _102.PacketSequence;
+                    toProto(message: _102.PacketSequence): Uint8Array;
+                    toProtoMsg(message: _102.PacketSequence): _102.PacketSequenceProtoMsg;
+                };
+                stateFromJSON(object: any): _101.State;
+                stateToJSON(object: _101.State): string;
+                orderFromJSON(object: any): _101.Order;
+                orderToJSON(object: _101.Order): string;
+                State: typeof _101.State;
+                StateSDKType: typeof _101.State;
+                Order: typeof _101.Order;
+                OrderSDKType: typeof _101.Order;
                 Channel: {
                     typeUrl: string;
-                    encode(message: _85.Channel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _85.Channel;
-                    fromJSON(object: any): _85.Channel;
-                    toJSON(message: _85.Channel): unknown;
-                    fromPartial(object: Partial<_85.Channel>): _85.Channel;
-                    fromProtoMsg(message: _85.ChannelProtoMsg): _85.Channel;
-                    toProto(message: _85.Channel): Uint8Array;
-                    toProtoMsg(message: _85.Channel): _85.ChannelProtoMsg;
+                    encode(message: _101.Channel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _101.Channel;
+                    fromJSON(object: any): _101.Channel;
+                    toJSON(message: _101.Channel): unknown;
+                    fromPartial(object: Partial<_101.Channel>): _101.Channel;
+                    fromProtoMsg(message: _101.ChannelProtoMsg): _101.Channel;
+                    toProto(message: _101.Channel): Uint8Array;
+                    toProtoMsg(message: _101.Channel): _101.ChannelProtoMsg;
                 };
                 IdentifiedChannel: {
                     typeUrl: string;
-                    encode(message: _85.IdentifiedChannel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _85.IdentifiedChannel;
-                    fromJSON(object: any): _85.IdentifiedChannel;
-                    toJSON(message: _85.IdentifiedChannel): unknown;
-                    fromPartial(object: Partial<_85.IdentifiedChannel>): _85.IdentifiedChannel;
-                    fromProtoMsg(message: _85.IdentifiedChannelProtoMsg): _85.IdentifiedChannel;
-                    toProto(message: _85.IdentifiedChannel): Uint8Array;
-                    toProtoMsg(message: _85.IdentifiedChannel): _85.IdentifiedChannelProtoMsg;
+                    encode(message: _101.IdentifiedChannel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _101.IdentifiedChannel;
+                    fromJSON(object: any): _101.IdentifiedChannel;
+                    toJSON(message: _101.IdentifiedChannel): unknown;
+                    fromPartial(object: Partial<_101.IdentifiedChannel>): _101.IdentifiedChannel;
+                    fromProtoMsg(message: _101.IdentifiedChannelProtoMsg): _101.IdentifiedChannel;
+                    toProto(message: _101.IdentifiedChannel): Uint8Array;
+                    toProtoMsg(message: _101.IdentifiedChannel): _101.IdentifiedChannelProtoMsg;
                 };
                 Counterparty: {
                     typeUrl: string;
-                    encode(message: _85.Counterparty, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _85.Counterparty;
-                    fromJSON(object: any): _85.Counterparty;
-                    toJSON(message: _85.Counterparty): unknown;
-                    fromPartial(object: Partial<_85.Counterparty>): _85.Counterparty;
-                    fromProtoMsg(message: _85.CounterpartyProtoMsg): _85.Counterparty;
-                    toProto(message: _85.Counterparty): Uint8Array;
-                    toProtoMsg(message: _85.Counterparty): _85.CounterpartyProtoMsg;
+                    encode(message: _101.Counterparty, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _101.Counterparty;
+                    fromJSON(object: any): _101.Counterparty;
+                    toJSON(message: _101.Counterparty): unknown;
+                    fromPartial(object: Partial<_101.Counterparty>): _101.Counterparty;
+                    fromProtoMsg(message: _101.CounterpartyProtoMsg): _101.Counterparty;
+                    toProto(message: _101.Counterparty): Uint8Array;
+                    toProtoMsg(message: _101.Counterparty): _101.CounterpartyProtoMsg;
                 };
                 Packet: {
                     typeUrl: string;
-                    encode(message: _85.Packet, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _85.Packet;
-                    fromJSON(object: any): _85.Packet;
-                    toJSON(message: _85.Packet): unknown;
-                    fromPartial(object: Partial<_85.Packet>): _85.Packet;
-                    fromProtoMsg(message: _85.PacketProtoMsg): _85.Packet;
-                    toProto(message: _85.Packet): Uint8Array;
-                    toProtoMsg(message: _85.Packet): _85.PacketProtoMsg;
+                    encode(message: _101.Packet, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _101.Packet;
+                    fromJSON(object: any): _101.Packet;
+                    toJSON(message: _101.Packet): unknown;
+                    fromPartial(object: Partial<_101.Packet>): _101.Packet;
+                    fromProtoMsg(message: _101.PacketProtoMsg): _101.Packet;
+                    toProto(message: _101.Packet): Uint8Array;
+                    toProtoMsg(message: _101.Packet): _101.PacketProtoMsg;
                 };
                 PacketState: {
                     typeUrl: string;
-                    encode(message: _85.PacketState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _85.PacketState;
-                    fromJSON(object: any): _85.PacketState;
-                    toJSON(message: _85.PacketState): unknown;
-                    fromPartial(object: Partial<_85.PacketState>): _85.PacketState;
-                    fromProtoMsg(message: _85.PacketStateProtoMsg): _85.PacketState;
-                    toProto(message: _85.PacketState): Uint8Array;
-                    toProtoMsg(message: _85.PacketState): _85.PacketStateProtoMsg;
+                    encode(message: _101.PacketState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _101.PacketState;
+                    fromJSON(object: any): _101.PacketState;
+                    toJSON(message: _101.PacketState): unknown;
+                    fromPartial(object: Partial<_101.PacketState>): _101.PacketState;
+                    fromProtoMsg(message: _101.PacketStateProtoMsg): _101.PacketState;
+                    toProto(message: _101.PacketState): Uint8Array;
+                    toProtoMsg(message: _101.PacketState): _101.PacketStateProtoMsg;
                 };
                 PacketId: {
                     typeUrl: string;
-                    encode(message: _85.PacketId, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _85.PacketId;
-                    fromJSON(object: any): _85.PacketId;
-                    toJSON(message: _85.PacketId): unknown;
-                    fromPartial(object: Partial<_85.PacketId>): _85.PacketId;
-                    fromProtoMsg(message: _85.PacketIdProtoMsg): _85.PacketId;
-                    toProto(message: _85.PacketId): Uint8Array;
-                    toProtoMsg(message: _85.PacketId): _85.PacketIdProtoMsg;
+                    encode(message: _101.PacketId, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _101.PacketId;
+                    fromJSON(object: any): _101.PacketId;
+                    toJSON(message: _101.PacketId): unknown;
+                    fromPartial(object: Partial<_101.PacketId>): _101.PacketId;
+                    fromProtoMsg(message: _101.PacketIdProtoMsg): _101.PacketId;
+                    toProto(message: _101.PacketId): Uint8Array;
+                    toProtoMsg(message: _101.PacketId): _101.PacketIdProtoMsg;
                 };
                 Acknowledgement: {
                     typeUrl: string;
-                    encode(message: _85.Acknowledgement, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _85.Acknowledgement;
-                    fromJSON(object: any): _85.Acknowledgement;
-                    toJSON(message: _85.Acknowledgement): unknown;
-                    fromPartial(object: Partial<_85.Acknowledgement>): _85.Acknowledgement;
-                    fromProtoMsg(message: _85.AcknowledgementProtoMsg): _85.Acknowledgement;
-                    toProto(message: _85.Acknowledgement): Uint8Array;
-                    toProtoMsg(message: _85.Acknowledgement): _85.AcknowledgementProtoMsg;
+                    encode(message: _101.Acknowledgement, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _101.Acknowledgement;
+                    fromJSON(object: any): _101.Acknowledgement;
+                    toJSON(message: _101.Acknowledgement): unknown;
+                    fromPartial(object: Partial<_101.Acknowledgement>): _101.Acknowledgement;
+                    fromProtoMsg(message: _101.AcknowledgementProtoMsg): _101.Acknowledgement;
+                    toProto(message: _101.Acknowledgement): Uint8Array;
+                    toProtoMsg(message: _101.Acknowledgement): _101.AcknowledgementProtoMsg;
                 };
             };
         }
         namespace client {
             const v1: {
+                MsgCreateClient: {
+                    typeUrl: string;
+                    encode(message: _108.MsgCreateClient, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _108.MsgCreateClient;
+                    fromJSON(object: any): _108.MsgCreateClient;
+                    toJSON(message: _108.MsgCreateClient): unknown;
+                    fromPartial(object: Partial<_108.MsgCreateClient>): _108.MsgCreateClient;
+                    fromProtoMsg(message: _108.MsgCreateClientProtoMsg): _108.MsgCreateClient;
+                    toProto(message: _108.MsgCreateClient): Uint8Array;
+                    toProtoMsg(message: _108.MsgCreateClient): _108.MsgCreateClientProtoMsg;
+                };
+                MsgCreateClientResponse: {
+                    typeUrl: string;
+                    encode(_: _108.MsgCreateClientResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _108.MsgCreateClientResponse;
+                    fromJSON(_: any): _108.MsgCreateClientResponse;
+                    toJSON(_: _108.MsgCreateClientResponse): unknown;
+                    fromPartial(_: Partial<_108.MsgCreateClientResponse>): _108.MsgCreateClientResponse;
+                    fromProtoMsg(message: _108.MsgCreateClientResponseProtoMsg): _108.MsgCreateClientResponse;
+                    toProto(message: _108.MsgCreateClientResponse): Uint8Array;
+                    toProtoMsg(message: _108.MsgCreateClientResponse): _108.MsgCreateClientResponseProtoMsg;
+                };
+                MsgUpdateClient: {
+                    typeUrl: string;
+                    encode(message: _108.MsgUpdateClient, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _108.MsgUpdateClient;
+                    fromJSON(object: any): _108.MsgUpdateClient;
+                    toJSON(message: _108.MsgUpdateClient): unknown;
+                    fromPartial(object: Partial<_108.MsgUpdateClient>): _108.MsgUpdateClient;
+                    fromProtoMsg(message: _108.MsgUpdateClientProtoMsg): _108.MsgUpdateClient;
+                    toProto(message: _108.MsgUpdateClient): Uint8Array;
+                    toProtoMsg(message: _108.MsgUpdateClient): _108.MsgUpdateClientProtoMsg;
+                };
+                MsgUpdateClientResponse: {
+                    typeUrl: string;
+                    encode(_: _108.MsgUpdateClientResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _108.MsgUpdateClientResponse;
+                    fromJSON(_: any): _108.MsgUpdateClientResponse;
+                    toJSON(_: _108.MsgUpdateClientResponse): unknown;
+                    fromPartial(_: Partial<_108.MsgUpdateClientResponse>): _108.MsgUpdateClientResponse;
+                    fromProtoMsg(message: _108.MsgUpdateClientResponseProtoMsg): _108.MsgUpdateClientResponse;
+                    toProto(message: _108.MsgUpdateClientResponse): Uint8Array;
+                    toProtoMsg(message: _108.MsgUpdateClientResponse): _108.MsgUpdateClientResponseProtoMsg;
+                };
+                MsgUpgradeClient: {
+                    typeUrl: string;
+                    encode(message: _108.MsgUpgradeClient, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _108.MsgUpgradeClient;
+                    fromJSON(object: any): _108.MsgUpgradeClient;
+                    toJSON(message: _108.MsgUpgradeClient): unknown;
+                    fromPartial(object: Partial<_108.MsgUpgradeClient>): _108.MsgUpgradeClient;
+                    fromProtoMsg(message: _108.MsgUpgradeClientProtoMsg): _108.MsgUpgradeClient;
+                    toProto(message: _108.MsgUpgradeClient): Uint8Array;
+                    toProtoMsg(message: _108.MsgUpgradeClient): _108.MsgUpgradeClientProtoMsg;
+                };
+                MsgUpgradeClientResponse: {
+                    typeUrl: string;
+                    encode(_: _108.MsgUpgradeClientResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _108.MsgUpgradeClientResponse;
+                    fromJSON(_: any): _108.MsgUpgradeClientResponse;
+                    toJSON(_: _108.MsgUpgradeClientResponse): unknown;
+                    fromPartial(_: Partial<_108.MsgUpgradeClientResponse>): _108.MsgUpgradeClientResponse;
+                    fromProtoMsg(message: _108.MsgUpgradeClientResponseProtoMsg): _108.MsgUpgradeClientResponse;
+                    toProto(message: _108.MsgUpgradeClientResponse): Uint8Array;
+                    toProtoMsg(message: _108.MsgUpgradeClientResponse): _108.MsgUpgradeClientResponseProtoMsg;
+                };
+                MsgSubmitMisbehaviour: {
+                    typeUrl: string;
+                    encode(message: _108.MsgSubmitMisbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _108.MsgSubmitMisbehaviour;
+                    fromJSON(object: any): _108.MsgSubmitMisbehaviour;
+                    toJSON(message: _108.MsgSubmitMisbehaviour): unknown;
+                    fromPartial(object: Partial<_108.MsgSubmitMisbehaviour>): _108.MsgSubmitMisbehaviour;
+                    fromProtoMsg(message: _108.MsgSubmitMisbehaviourProtoMsg): _108.MsgSubmitMisbehaviour;
+                    toProto(message: _108.MsgSubmitMisbehaviour): Uint8Array;
+                    toProtoMsg(message: _108.MsgSubmitMisbehaviour): _108.MsgSubmitMisbehaviourProtoMsg;
+                };
+                MsgSubmitMisbehaviourResponse: {
+                    typeUrl: string;
+                    encode(_: _108.MsgSubmitMisbehaviourResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _108.MsgSubmitMisbehaviourResponse;
+                    fromJSON(_: any): _108.MsgSubmitMisbehaviourResponse;
+                    toJSON(_: _108.MsgSubmitMisbehaviourResponse): unknown;
+                    fromPartial(_: Partial<_108.MsgSubmitMisbehaviourResponse>): _108.MsgSubmitMisbehaviourResponse;
+                    fromProtoMsg(message: _108.MsgSubmitMisbehaviourResponseProtoMsg): _108.MsgSubmitMisbehaviourResponse;
+                    toProto(message: _108.MsgSubmitMisbehaviourResponse): Uint8Array;
+                    toProtoMsg(message: _108.MsgSubmitMisbehaviourResponse): _108.MsgSubmitMisbehaviourResponseProtoMsg;
+                };
+                QueryClientStateRequest: {
+                    typeUrl: string;
+                    encode(message: _107.QueryClientStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryClientStateRequest;
+                    fromJSON(object: any): _107.QueryClientStateRequest;
+                    toJSON(message: _107.QueryClientStateRequest): unknown;
+                    fromPartial(object: Partial<_107.QueryClientStateRequest>): _107.QueryClientStateRequest;
+                    fromProtoMsg(message: _107.QueryClientStateRequestProtoMsg): _107.QueryClientStateRequest;
+                    toProto(message: _107.QueryClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryClientStateRequest): _107.QueryClientStateRequestProtoMsg;
+                };
+                QueryClientStateResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryClientStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryClientStateResponse;
+                    fromJSON(object: any): _107.QueryClientStateResponse;
+                    toJSON(message: _107.QueryClientStateResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryClientStateResponse>): _107.QueryClientStateResponse;
+                    fromProtoMsg(message: _107.QueryClientStateResponseProtoMsg): _107.QueryClientStateResponse;
+                    toProto(message: _107.QueryClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryClientStateResponse): _107.QueryClientStateResponseProtoMsg;
+                };
+                QueryClientStatesRequest: {
+                    typeUrl: string;
+                    encode(message: _107.QueryClientStatesRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryClientStatesRequest;
+                    fromJSON(object: any): _107.QueryClientStatesRequest;
+                    toJSON(message: _107.QueryClientStatesRequest): unknown;
+                    fromPartial(object: Partial<_107.QueryClientStatesRequest>): _107.QueryClientStatesRequest;
+                    fromProtoMsg(message: _107.QueryClientStatesRequestProtoMsg): _107.QueryClientStatesRequest;
+                    toProto(message: _107.QueryClientStatesRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryClientStatesRequest): _107.QueryClientStatesRequestProtoMsg;
+                };
+                QueryClientStatesResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryClientStatesResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryClientStatesResponse;
+                    fromJSON(object: any): _107.QueryClientStatesResponse;
+                    toJSON(message: _107.QueryClientStatesResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryClientStatesResponse>): _107.QueryClientStatesResponse;
+                    fromProtoMsg(message: _107.QueryClientStatesResponseProtoMsg): _107.QueryClientStatesResponse;
+                    toProto(message: _107.QueryClientStatesResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryClientStatesResponse): _107.QueryClientStatesResponseProtoMsg;
+                };
+                QueryConsensusStateRequest: {
+                    typeUrl: string;
+                    encode(message: _107.QueryConsensusStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryConsensusStateRequest;
+                    fromJSON(object: any): _107.QueryConsensusStateRequest;
+                    toJSON(message: _107.QueryConsensusStateRequest): unknown;
+                    fromPartial(object: Partial<_107.QueryConsensusStateRequest>): _107.QueryConsensusStateRequest;
+                    fromProtoMsg(message: _107.QueryConsensusStateRequestProtoMsg): _107.QueryConsensusStateRequest;
+                    toProto(message: _107.QueryConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryConsensusStateRequest): _107.QueryConsensusStateRequestProtoMsg;
+                };
+                QueryConsensusStateResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryConsensusStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryConsensusStateResponse;
+                    fromJSON(object: any): _107.QueryConsensusStateResponse;
+                    toJSON(message: _107.QueryConsensusStateResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryConsensusStateResponse>): _107.QueryConsensusStateResponse;
+                    fromProtoMsg(message: _107.QueryConsensusStateResponseProtoMsg): _107.QueryConsensusStateResponse;
+                    toProto(message: _107.QueryConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryConsensusStateResponse): _107.QueryConsensusStateResponseProtoMsg;
+                };
+                QueryConsensusStatesRequest: {
+                    typeUrl: string;
+                    encode(message: _107.QueryConsensusStatesRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryConsensusStatesRequest;
+                    fromJSON(object: any): _107.QueryConsensusStatesRequest;
+                    toJSON(message: _107.QueryConsensusStatesRequest): unknown;
+                    fromPartial(object: Partial<_107.QueryConsensusStatesRequest>): _107.QueryConsensusStatesRequest;
+                    fromProtoMsg(message: _107.QueryConsensusStatesRequestProtoMsg): _107.QueryConsensusStatesRequest;
+                    toProto(message: _107.QueryConsensusStatesRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryConsensusStatesRequest): _107.QueryConsensusStatesRequestProtoMsg;
+                };
+                QueryConsensusStatesResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryConsensusStatesResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryConsensusStatesResponse;
+                    fromJSON(object: any): _107.QueryConsensusStatesResponse;
+                    toJSON(message: _107.QueryConsensusStatesResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryConsensusStatesResponse>): _107.QueryConsensusStatesResponse;
+                    fromProtoMsg(message: _107.QueryConsensusStatesResponseProtoMsg): _107.QueryConsensusStatesResponse;
+                    toProto(message: _107.QueryConsensusStatesResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryConsensusStatesResponse): _107.QueryConsensusStatesResponseProtoMsg;
+                };
+                QueryConsensusStateHeightsRequest: {
+                    typeUrl: string;
+                    encode(message: _107.QueryConsensusStateHeightsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryConsensusStateHeightsRequest;
+                    fromJSON(object: any): _107.QueryConsensusStateHeightsRequest;
+                    toJSON(message: _107.QueryConsensusStateHeightsRequest): unknown;
+                    fromPartial(object: Partial<_107.QueryConsensusStateHeightsRequest>): _107.QueryConsensusStateHeightsRequest;
+                    fromProtoMsg(message: _107.QueryConsensusStateHeightsRequestProtoMsg): _107.QueryConsensusStateHeightsRequest;
+                    toProto(message: _107.QueryConsensusStateHeightsRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryConsensusStateHeightsRequest): _107.QueryConsensusStateHeightsRequestProtoMsg;
+                };
+                QueryConsensusStateHeightsResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryConsensusStateHeightsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryConsensusStateHeightsResponse;
+                    fromJSON(object: any): _107.QueryConsensusStateHeightsResponse;
+                    toJSON(message: _107.QueryConsensusStateHeightsResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryConsensusStateHeightsResponse>): _107.QueryConsensusStateHeightsResponse;
+                    fromProtoMsg(message: _107.QueryConsensusStateHeightsResponseProtoMsg): _107.QueryConsensusStateHeightsResponse;
+                    toProto(message: _107.QueryConsensusStateHeightsResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryConsensusStateHeightsResponse): _107.QueryConsensusStateHeightsResponseProtoMsg;
+                };
+                QueryClientStatusRequest: {
+                    typeUrl: string;
+                    encode(message: _107.QueryClientStatusRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryClientStatusRequest;
+                    fromJSON(object: any): _107.QueryClientStatusRequest;
+                    toJSON(message: _107.QueryClientStatusRequest): unknown;
+                    fromPartial(object: Partial<_107.QueryClientStatusRequest>): _107.QueryClientStatusRequest;
+                    fromProtoMsg(message: _107.QueryClientStatusRequestProtoMsg): _107.QueryClientStatusRequest;
+                    toProto(message: _107.QueryClientStatusRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryClientStatusRequest): _107.QueryClientStatusRequestProtoMsg;
+                };
+                QueryClientStatusResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryClientStatusResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryClientStatusResponse;
+                    fromJSON(object: any): _107.QueryClientStatusResponse;
+                    toJSON(message: _107.QueryClientStatusResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryClientStatusResponse>): _107.QueryClientStatusResponse;
+                    fromProtoMsg(message: _107.QueryClientStatusResponseProtoMsg): _107.QueryClientStatusResponse;
+                    toProto(message: _107.QueryClientStatusResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryClientStatusResponse): _107.QueryClientStatusResponseProtoMsg;
+                };
+                QueryClientParamsRequest: {
+                    typeUrl: string;
+                    encode(_: _107.QueryClientParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryClientParamsRequest;
+                    fromJSON(_: any): _107.QueryClientParamsRequest;
+                    toJSON(_: _107.QueryClientParamsRequest): unknown;
+                    fromPartial(_: Partial<_107.QueryClientParamsRequest>): _107.QueryClientParamsRequest;
+                    fromProtoMsg(message: _107.QueryClientParamsRequestProtoMsg): _107.QueryClientParamsRequest;
+                    toProto(message: _107.QueryClientParamsRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryClientParamsRequest): _107.QueryClientParamsRequestProtoMsg;
+                };
+                QueryClientParamsResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryClientParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryClientParamsResponse;
+                    fromJSON(object: any): _107.QueryClientParamsResponse;
+                    toJSON(message: _107.QueryClientParamsResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryClientParamsResponse>): _107.QueryClientParamsResponse;
+                    fromProtoMsg(message: _107.QueryClientParamsResponseProtoMsg): _107.QueryClientParamsResponse;
+                    toProto(message: _107.QueryClientParamsResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryClientParamsResponse): _107.QueryClientParamsResponseProtoMsg;
+                };
+                QueryUpgradedClientStateRequest: {
+                    typeUrl: string;
+                    encode(_: _107.QueryUpgradedClientStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryUpgradedClientStateRequest;
+                    fromJSON(_: any): _107.QueryUpgradedClientStateRequest;
+                    toJSON(_: _107.QueryUpgradedClientStateRequest): unknown;
+                    fromPartial(_: Partial<_107.QueryUpgradedClientStateRequest>): _107.QueryUpgradedClientStateRequest;
+                    fromProtoMsg(message: _107.QueryUpgradedClientStateRequestProtoMsg): _107.QueryUpgradedClientStateRequest;
+                    toProto(message: _107.QueryUpgradedClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryUpgradedClientStateRequest): _107.QueryUpgradedClientStateRequestProtoMsg;
+                };
+                QueryUpgradedClientStateResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryUpgradedClientStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryUpgradedClientStateResponse;
+                    fromJSON(object: any): _107.QueryUpgradedClientStateResponse;
+                    toJSON(message: _107.QueryUpgradedClientStateResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryUpgradedClientStateResponse>): _107.QueryUpgradedClientStateResponse;
+                    fromProtoMsg(message: _107.QueryUpgradedClientStateResponseProtoMsg): _107.QueryUpgradedClientStateResponse;
+                    toProto(message: _107.QueryUpgradedClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryUpgradedClientStateResponse): _107.QueryUpgradedClientStateResponseProtoMsg;
+                };
+                QueryUpgradedConsensusStateRequest: {
+                    typeUrl: string;
+                    encode(_: _107.QueryUpgradedConsensusStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryUpgradedConsensusStateRequest;
+                    fromJSON(_: any): _107.QueryUpgradedConsensusStateRequest;
+                    toJSON(_: _107.QueryUpgradedConsensusStateRequest): unknown;
+                    fromPartial(_: Partial<_107.QueryUpgradedConsensusStateRequest>): _107.QueryUpgradedConsensusStateRequest;
+                    fromProtoMsg(message: _107.QueryUpgradedConsensusStateRequestProtoMsg): _107.QueryUpgradedConsensusStateRequest;
+                    toProto(message: _107.QueryUpgradedConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _107.QueryUpgradedConsensusStateRequest): _107.QueryUpgradedConsensusStateRequestProtoMsg;
+                };
+                QueryUpgradedConsensusStateResponse: {
+                    typeUrl: string;
+                    encode(message: _107.QueryUpgradedConsensusStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _107.QueryUpgradedConsensusStateResponse;
+                    fromJSON(object: any): _107.QueryUpgradedConsensusStateResponse;
+                    toJSON(message: _107.QueryUpgradedConsensusStateResponse): unknown;
+                    fromPartial(object: Partial<_107.QueryUpgradedConsensusStateResponse>): _107.QueryUpgradedConsensusStateResponse;
+                    fromProtoMsg(message: _107.QueryUpgradedConsensusStateResponseProtoMsg): _107.QueryUpgradedConsensusStateResponse;
+                    toProto(message: _107.QueryUpgradedConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _107.QueryUpgradedConsensusStateResponse): _107.QueryUpgradedConsensusStateResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: string;
+                    encode(message: _106.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _106.GenesisState;
+                    fromJSON(object: any): _106.GenesisState;
+                    toJSON(message: _106.GenesisState): unknown;
+                    fromPartial(object: Partial<_106.GenesisState>): _106.GenesisState;
+                    fromProtoMsg(message: _106.GenesisStateProtoMsg): _106.GenesisState;
+                    toProto(message: _106.GenesisState): Uint8Array;
+                    toProtoMsg(message: _106.GenesisState): _106.GenesisStateProtoMsg;
+                };
+                GenesisMetadata: {
+                    typeUrl: string;
+                    encode(message: _106.GenesisMetadata, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _106.GenesisMetadata;
+                    fromJSON(object: any): _106.GenesisMetadata;
+                    toJSON(message: _106.GenesisMetadata): unknown;
+                    fromPartial(object: Partial<_106.GenesisMetadata>): _106.GenesisMetadata;
+                    fromProtoMsg(message: _106.GenesisMetadataProtoMsg): _106.GenesisMetadata;
+                    toProto(message: _106.GenesisMetadata): Uint8Array;
+                    toProtoMsg(message: _106.GenesisMetadata): _106.GenesisMetadataProtoMsg;
+                };
+                IdentifiedGenesisMetadata: {
+                    typeUrl: string;
+                    encode(message: _106.IdentifiedGenesisMetadata, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _106.IdentifiedGenesisMetadata;
+                    fromJSON(object: any): _106.IdentifiedGenesisMetadata;
+                    toJSON(message: _106.IdentifiedGenesisMetadata): unknown;
+                    fromPartial(object: Partial<_106.IdentifiedGenesisMetadata>): _106.IdentifiedGenesisMetadata;
+                    fromProtoMsg(message: _106.IdentifiedGenesisMetadataProtoMsg): _106.IdentifiedGenesisMetadata;
+                    toProto(message: _106.IdentifiedGenesisMetadata): Uint8Array;
+                    toProtoMsg(message: _106.IdentifiedGenesisMetadata): _106.IdentifiedGenesisMetadataProtoMsg;
+                };
                 IdentifiedClientState: {
                     typeUrl: string;
-                    encode(message: _86.IdentifiedClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _86.IdentifiedClientState;
-                    fromJSON(object: any): _86.IdentifiedClientState;
-                    toJSON(message: _86.IdentifiedClientState): unknown;
-                    fromPartial(object: Partial<_86.IdentifiedClientState>): _86.IdentifiedClientState;
-                    fromProtoMsg(message: _86.IdentifiedClientStateProtoMsg): _86.IdentifiedClientState;
-                    toProto(message: _86.IdentifiedClientState): Uint8Array;
-                    toProtoMsg(message: _86.IdentifiedClientState): _86.IdentifiedClientStateProtoMsg;
+                    encode(message: _105.IdentifiedClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _105.IdentifiedClientState;
+                    fromJSON(object: any): _105.IdentifiedClientState;
+                    toJSON(message: _105.IdentifiedClientState): unknown;
+                    fromPartial(object: Partial<_105.IdentifiedClientState>): _105.IdentifiedClientState;
+                    fromProtoMsg(message: _105.IdentifiedClientStateProtoMsg): _105.IdentifiedClientState;
+                    toProto(message: _105.IdentifiedClientState): Uint8Array;
+                    toProtoMsg(message: _105.IdentifiedClientState): _105.IdentifiedClientStateProtoMsg;
                 };
                 ConsensusStateWithHeight: {
                     typeUrl: string;
-                    encode(message: _86.ConsensusStateWithHeight, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _86.ConsensusStateWithHeight;
-                    fromJSON(object: any): _86.ConsensusStateWithHeight;
-                    toJSON(message: _86.ConsensusStateWithHeight): unknown;
-                    fromPartial(object: Partial<_86.ConsensusStateWithHeight>): _86.ConsensusStateWithHeight;
-                    fromProtoMsg(message: _86.ConsensusStateWithHeightProtoMsg): _86.ConsensusStateWithHeight;
-                    toProto(message: _86.ConsensusStateWithHeight): Uint8Array;
-                    toProtoMsg(message: _86.ConsensusStateWithHeight): _86.ConsensusStateWithHeightProtoMsg;
+                    encode(message: _105.ConsensusStateWithHeight, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _105.ConsensusStateWithHeight;
+                    fromJSON(object: any): _105.ConsensusStateWithHeight;
+                    toJSON(message: _105.ConsensusStateWithHeight): unknown;
+                    fromPartial(object: Partial<_105.ConsensusStateWithHeight>): _105.ConsensusStateWithHeight;
+                    fromProtoMsg(message: _105.ConsensusStateWithHeightProtoMsg): _105.ConsensusStateWithHeight;
+                    toProto(message: _105.ConsensusStateWithHeight): Uint8Array;
+                    toProtoMsg(message: _105.ConsensusStateWithHeight): _105.ConsensusStateWithHeightProtoMsg;
                 };
                 ClientConsensusStates: {
                     typeUrl: string;
-                    encode(message: _86.ClientConsensusStates, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _86.ClientConsensusStates;
-                    fromJSON(object: any): _86.ClientConsensusStates;
-                    toJSON(message: _86.ClientConsensusStates): unknown;
-                    fromPartial(object: Partial<_86.ClientConsensusStates>): _86.ClientConsensusStates;
-                    fromProtoMsg(message: _86.ClientConsensusStatesProtoMsg): _86.ClientConsensusStates;
-                    toProto(message: _86.ClientConsensusStates): Uint8Array;
-                    toProtoMsg(message: _86.ClientConsensusStates): _86.ClientConsensusStatesProtoMsg;
+                    encode(message: _105.ClientConsensusStates, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _105.ClientConsensusStates;
+                    fromJSON(object: any): _105.ClientConsensusStates;
+                    toJSON(message: _105.ClientConsensusStates): unknown;
+                    fromPartial(object: Partial<_105.ClientConsensusStates>): _105.ClientConsensusStates;
+                    fromProtoMsg(message: _105.ClientConsensusStatesProtoMsg): _105.ClientConsensusStates;
+                    toProto(message: _105.ClientConsensusStates): Uint8Array;
+                    toProtoMsg(message: _105.ClientConsensusStates): _105.ClientConsensusStatesProtoMsg;
                 };
                 ClientUpdateProposal: {
                     typeUrl: string;
-                    encode(message: _86.ClientUpdateProposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _86.ClientUpdateProposal;
-                    fromJSON(object: any): _86.ClientUpdateProposal;
-                    toJSON(message: _86.ClientUpdateProposal): unknown;
-                    fromPartial(object: Partial<_86.ClientUpdateProposal>): _86.ClientUpdateProposal;
-                    fromProtoMsg(message: _86.ClientUpdateProposalProtoMsg): _86.ClientUpdateProposal;
-                    toProto(message: _86.ClientUpdateProposal): Uint8Array;
-                    toProtoMsg(message: _86.ClientUpdateProposal): _86.ClientUpdateProposalProtoMsg;
+                    encode(message: _105.ClientUpdateProposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _105.ClientUpdateProposal;
+                    fromJSON(object: any): _105.ClientUpdateProposal;
+                    toJSON(message: _105.ClientUpdateProposal): unknown;
+                    fromPartial(object: Partial<_105.ClientUpdateProposal>): _105.ClientUpdateProposal;
+                    fromProtoMsg(message: _105.ClientUpdateProposalProtoMsg): _105.ClientUpdateProposal;
+                    toProto(message: _105.ClientUpdateProposal): Uint8Array;
+                    toProtoMsg(message: _105.ClientUpdateProposal): _105.ClientUpdateProposalProtoMsg;
                 };
                 UpgradeProposal: {
                     typeUrl: string;
-                    encode(message: _86.UpgradeProposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _86.UpgradeProposal;
-                    fromJSON(object: any): _86.UpgradeProposal;
-                    toJSON(message: _86.UpgradeProposal): unknown;
-                    fromPartial(object: Partial<_86.UpgradeProposal>): _86.UpgradeProposal;
-                    fromProtoMsg(message: _86.UpgradeProposalProtoMsg): _86.UpgradeProposal;
-                    toProto(message: _86.UpgradeProposal): Uint8Array;
-                    toProtoMsg(message: _86.UpgradeProposal): _86.UpgradeProposalProtoMsg;
+                    encode(message: _105.UpgradeProposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _105.UpgradeProposal;
+                    fromJSON(object: any): _105.UpgradeProposal;
+                    toJSON(message: _105.UpgradeProposal): unknown;
+                    fromPartial(object: Partial<_105.UpgradeProposal>): _105.UpgradeProposal;
+                    fromProtoMsg(message: _105.UpgradeProposalProtoMsg): _105.UpgradeProposal;
+                    toProto(message: _105.UpgradeProposal): Uint8Array;
+                    toProtoMsg(message: _105.UpgradeProposal): _105.UpgradeProposalProtoMsg;
                 };
                 Height: {
                     typeUrl: string;
-                    encode(message: _86.Height, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _86.Height;
-                    fromJSON(object: any): _86.Height;
-                    toJSON(message: _86.Height): unknown;
-                    fromPartial(object: Partial<_86.Height>): _86.Height;
-                    fromProtoMsg(message: _86.HeightProtoMsg): _86.Height;
-                    toProto(message: _86.Height): Uint8Array;
-                    toProtoMsg(message: _86.Height): _86.HeightProtoMsg;
+                    encode(message: _105.Height, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _105.Height;
+                    fromJSON(object: any): _105.Height;
+                    toJSON(message: _105.Height): unknown;
+                    fromPartial(object: Partial<_105.Height>): _105.Height;
+                    fromProtoMsg(message: _105.HeightProtoMsg): _105.Height;
+                    toProto(message: _105.Height): Uint8Array;
+                    toProtoMsg(message: _105.Height): _105.HeightProtoMsg;
+                };
+                Params: {
+                    typeUrl: string;
+                    encode(message: _105.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _105.Params;
+                    fromJSON(object: any): _105.Params;
+                    toJSON(message: _105.Params): unknown;
+                    fromPartial(object: Partial<_105.Params>): _105.Params;
+                    fromProtoMsg(message: _105.ParamsProtoMsg): _105.Params;
+                    toProto(message: _105.Params): Uint8Array;
+                    toProtoMsg(message: _105.Params): _105.ParamsProtoMsg;
+                };
+            };
+        }
+        namespace commitment {
+            const v1: {
+                MerkleRoot: {
+                    typeUrl: string;
+                    encode(message: _109.MerkleRoot, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _109.MerkleRoot;
+                    fromJSON(object: any): _109.MerkleRoot;
+                    toJSON(message: _109.MerkleRoot): unknown;
+                    fromPartial(object: Partial<_109.MerkleRoot>): _109.MerkleRoot;
+                    fromProtoMsg(message: _109.MerkleRootProtoMsg): _109.MerkleRoot;
+                    toProto(message: _109.MerkleRoot): Uint8Array;
+                    toProtoMsg(message: _109.MerkleRoot): _109.MerkleRootProtoMsg;
+                };
+                MerklePrefix: {
+                    typeUrl: string;
+                    encode(message: _109.MerklePrefix, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _109.MerklePrefix;
+                    fromJSON(object: any): _109.MerklePrefix;
+                    toJSON(message: _109.MerklePrefix): unknown;
+                    fromPartial(object: Partial<_109.MerklePrefix>): _109.MerklePrefix;
+                    fromProtoMsg(message: _109.MerklePrefixProtoMsg): _109.MerklePrefix;
+                    toProto(message: _109.MerklePrefix): Uint8Array;
+                    toProtoMsg(message: _109.MerklePrefix): _109.MerklePrefixProtoMsg;
+                };
+                MerklePath: {
+                    typeUrl: string;
+                    encode(message: _109.MerklePath, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _109.MerklePath;
+                    fromJSON(object: any): _109.MerklePath;
+                    toJSON(message: _109.MerklePath): unknown;
+                    fromPartial(object: Partial<_109.MerklePath>): _109.MerklePath;
+                    fromProtoMsg(message: _109.MerklePathProtoMsg): _109.MerklePath;
+                    toProto(message: _109.MerklePath): Uint8Array;
+                    toProtoMsg(message: _109.MerklePath): _109.MerklePathProtoMsg;
+                };
+                MerkleProof: {
+                    typeUrl: string;
+                    encode(message: _109.MerkleProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _109.MerkleProof;
+                    fromJSON(object: any): _109.MerkleProof;
+                    toJSON(message: _109.MerkleProof): unknown;
+                    fromPartial(object: Partial<_109.MerkleProof>): _109.MerkleProof;
+                    fromProtoMsg(message: _109.MerkleProofProtoMsg): _109.MerkleProof;
+                    toProto(message: _109.MerkleProof): Uint8Array;
+                    toProtoMsg(message: _109.MerkleProof): _109.MerkleProofProtoMsg;
+                };
+            };
+        }
+        namespace connection {
+            const v1: {
+                MsgConnectionOpenInit: {
+                    typeUrl: string;
+                    encode(message: _113.MsgConnectionOpenInit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _113.MsgConnectionOpenInit;
+                    fromJSON(object: any): _113.MsgConnectionOpenInit;
+                    toJSON(message: _113.MsgConnectionOpenInit): unknown;
+                    fromPartial(object: Partial<_113.MsgConnectionOpenInit>): _113.MsgConnectionOpenInit;
+                    fromProtoMsg(message: _113.MsgConnectionOpenInitProtoMsg): _113.MsgConnectionOpenInit;
+                    toProto(message: _113.MsgConnectionOpenInit): Uint8Array;
+                    toProtoMsg(message: _113.MsgConnectionOpenInit): _113.MsgConnectionOpenInitProtoMsg;
+                };
+                MsgConnectionOpenInitResponse: {
+                    typeUrl: string;
+                    encode(_: _113.MsgConnectionOpenInitResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _113.MsgConnectionOpenInitResponse;
+                    fromJSON(_: any): _113.MsgConnectionOpenInitResponse;
+                    toJSON(_: _113.MsgConnectionOpenInitResponse): unknown;
+                    fromPartial(_: Partial<_113.MsgConnectionOpenInitResponse>): _113.MsgConnectionOpenInitResponse;
+                    fromProtoMsg(message: _113.MsgConnectionOpenInitResponseProtoMsg): _113.MsgConnectionOpenInitResponse;
+                    toProto(message: _113.MsgConnectionOpenInitResponse): Uint8Array;
+                    toProtoMsg(message: _113.MsgConnectionOpenInitResponse): _113.MsgConnectionOpenInitResponseProtoMsg;
+                };
+                MsgConnectionOpenTry: {
+                    typeUrl: string;
+                    encode(message: _113.MsgConnectionOpenTry, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _113.MsgConnectionOpenTry;
+                    fromJSON(object: any): _113.MsgConnectionOpenTry;
+                    toJSON(message: _113.MsgConnectionOpenTry): unknown;
+                    fromPartial(object: Partial<_113.MsgConnectionOpenTry>): _113.MsgConnectionOpenTry;
+                    fromProtoMsg(message: _113.MsgConnectionOpenTryProtoMsg): _113.MsgConnectionOpenTry;
+                    toProto(message: _113.MsgConnectionOpenTry): Uint8Array;
+                    toProtoMsg(message: _113.MsgConnectionOpenTry): _113.MsgConnectionOpenTryProtoMsg;
+                };
+                MsgConnectionOpenTryResponse: {
+                    typeUrl: string;
+                    encode(_: _113.MsgConnectionOpenTryResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _113.MsgConnectionOpenTryResponse;
+                    fromJSON(_: any): _113.MsgConnectionOpenTryResponse;
+                    toJSON(_: _113.MsgConnectionOpenTryResponse): unknown;
+                    fromPartial(_: Partial<_113.MsgConnectionOpenTryResponse>): _113.MsgConnectionOpenTryResponse;
+                    fromProtoMsg(message: _113.MsgConnectionOpenTryResponseProtoMsg): _113.MsgConnectionOpenTryResponse;
+                    toProto(message: _113.MsgConnectionOpenTryResponse): Uint8Array;
+                    toProtoMsg(message: _113.MsgConnectionOpenTryResponse): _113.MsgConnectionOpenTryResponseProtoMsg;
+                };
+                MsgConnectionOpenAck: {
+                    typeUrl: string;
+                    encode(message: _113.MsgConnectionOpenAck, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _113.MsgConnectionOpenAck;
+                    fromJSON(object: any): _113.MsgConnectionOpenAck;
+                    toJSON(message: _113.MsgConnectionOpenAck): unknown;
+                    fromPartial(object: Partial<_113.MsgConnectionOpenAck>): _113.MsgConnectionOpenAck;
+                    fromProtoMsg(message: _113.MsgConnectionOpenAckProtoMsg): _113.MsgConnectionOpenAck;
+                    toProto(message: _113.MsgConnectionOpenAck): Uint8Array;
+                    toProtoMsg(message: _113.MsgConnectionOpenAck): _113.MsgConnectionOpenAckProtoMsg;
+                };
+                MsgConnectionOpenAckResponse: {
+                    typeUrl: string;
+                    encode(_: _113.MsgConnectionOpenAckResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _113.MsgConnectionOpenAckResponse;
+                    fromJSON(_: any): _113.MsgConnectionOpenAckResponse;
+                    toJSON(_: _113.MsgConnectionOpenAckResponse): unknown;
+                    fromPartial(_: Partial<_113.MsgConnectionOpenAckResponse>): _113.MsgConnectionOpenAckResponse;
+                    fromProtoMsg(message: _113.MsgConnectionOpenAckResponseProtoMsg): _113.MsgConnectionOpenAckResponse;
+                    toProto(message: _113.MsgConnectionOpenAckResponse): Uint8Array;
+                    toProtoMsg(message: _113.MsgConnectionOpenAckResponse): _113.MsgConnectionOpenAckResponseProtoMsg;
+                };
+                MsgConnectionOpenConfirm: {
+                    typeUrl: string;
+                    encode(message: _113.MsgConnectionOpenConfirm, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _113.MsgConnectionOpenConfirm;
+                    fromJSON(object: any): _113.MsgConnectionOpenConfirm;
+                    toJSON(message: _113.MsgConnectionOpenConfirm): unknown;
+                    fromPartial(object: Partial<_113.MsgConnectionOpenConfirm>): _113.MsgConnectionOpenConfirm;
+                    fromProtoMsg(message: _113.MsgConnectionOpenConfirmProtoMsg): _113.MsgConnectionOpenConfirm;
+                    toProto(message: _113.MsgConnectionOpenConfirm): Uint8Array;
+                    toProtoMsg(message: _113.MsgConnectionOpenConfirm): _113.MsgConnectionOpenConfirmProtoMsg;
+                };
+                MsgConnectionOpenConfirmResponse: {
+                    typeUrl: string;
+                    encode(_: _113.MsgConnectionOpenConfirmResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _113.MsgConnectionOpenConfirmResponse;
+                    fromJSON(_: any): _113.MsgConnectionOpenConfirmResponse;
+                    toJSON(_: _113.MsgConnectionOpenConfirmResponse): unknown;
+                    fromPartial(_: Partial<_113.MsgConnectionOpenConfirmResponse>): _113.MsgConnectionOpenConfirmResponse;
+                    fromProtoMsg(message: _113.MsgConnectionOpenConfirmResponseProtoMsg): _113.MsgConnectionOpenConfirmResponse;
+                    toProto(message: _113.MsgConnectionOpenConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _113.MsgConnectionOpenConfirmResponse): _113.MsgConnectionOpenConfirmResponseProtoMsg;
+                };
+                QueryConnectionRequest: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionRequest;
+                    fromJSON(object: any): _112.QueryConnectionRequest;
+                    toJSON(message: _112.QueryConnectionRequest): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionRequest>): _112.QueryConnectionRequest;
+                    fromProtoMsg(message: _112.QueryConnectionRequestProtoMsg): _112.QueryConnectionRequest;
+                    toProto(message: _112.QueryConnectionRequest): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionRequest): _112.QueryConnectionRequestProtoMsg;
+                };
+                QueryConnectionResponse: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionResponse;
+                    fromJSON(object: any): _112.QueryConnectionResponse;
+                    toJSON(message: _112.QueryConnectionResponse): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionResponse>): _112.QueryConnectionResponse;
+                    fromProtoMsg(message: _112.QueryConnectionResponseProtoMsg): _112.QueryConnectionResponse;
+                    toProto(message: _112.QueryConnectionResponse): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionResponse): _112.QueryConnectionResponseProtoMsg;
+                };
+                QueryConnectionsRequest: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionsRequest;
+                    fromJSON(object: any): _112.QueryConnectionsRequest;
+                    toJSON(message: _112.QueryConnectionsRequest): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionsRequest>): _112.QueryConnectionsRequest;
+                    fromProtoMsg(message: _112.QueryConnectionsRequestProtoMsg): _112.QueryConnectionsRequest;
+                    toProto(message: _112.QueryConnectionsRequest): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionsRequest): _112.QueryConnectionsRequestProtoMsg;
+                };
+                QueryConnectionsResponse: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionsResponse;
+                    fromJSON(object: any): _112.QueryConnectionsResponse;
+                    toJSON(message: _112.QueryConnectionsResponse): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionsResponse>): _112.QueryConnectionsResponse;
+                    fromProtoMsg(message: _112.QueryConnectionsResponseProtoMsg): _112.QueryConnectionsResponse;
+                    toProto(message: _112.QueryConnectionsResponse): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionsResponse): _112.QueryConnectionsResponseProtoMsg;
+                };
+                QueryClientConnectionsRequest: {
+                    typeUrl: string;
+                    encode(message: _112.QueryClientConnectionsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryClientConnectionsRequest;
+                    fromJSON(object: any): _112.QueryClientConnectionsRequest;
+                    toJSON(message: _112.QueryClientConnectionsRequest): unknown;
+                    fromPartial(object: Partial<_112.QueryClientConnectionsRequest>): _112.QueryClientConnectionsRequest;
+                    fromProtoMsg(message: _112.QueryClientConnectionsRequestProtoMsg): _112.QueryClientConnectionsRequest;
+                    toProto(message: _112.QueryClientConnectionsRequest): Uint8Array;
+                    toProtoMsg(message: _112.QueryClientConnectionsRequest): _112.QueryClientConnectionsRequestProtoMsg;
+                };
+                QueryClientConnectionsResponse: {
+                    typeUrl: string;
+                    encode(message: _112.QueryClientConnectionsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryClientConnectionsResponse;
+                    fromJSON(object: any): _112.QueryClientConnectionsResponse;
+                    toJSON(message: _112.QueryClientConnectionsResponse): unknown;
+                    fromPartial(object: Partial<_112.QueryClientConnectionsResponse>): _112.QueryClientConnectionsResponse;
+                    fromProtoMsg(message: _112.QueryClientConnectionsResponseProtoMsg): _112.QueryClientConnectionsResponse;
+                    toProto(message: _112.QueryClientConnectionsResponse): Uint8Array;
+                    toProtoMsg(message: _112.QueryClientConnectionsResponse): _112.QueryClientConnectionsResponseProtoMsg;
+                };
+                QueryConnectionClientStateRequest: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionClientStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionClientStateRequest;
+                    fromJSON(object: any): _112.QueryConnectionClientStateRequest;
+                    toJSON(message: _112.QueryConnectionClientStateRequest): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionClientStateRequest>): _112.QueryConnectionClientStateRequest;
+                    fromProtoMsg(message: _112.QueryConnectionClientStateRequestProtoMsg): _112.QueryConnectionClientStateRequest;
+                    toProto(message: _112.QueryConnectionClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionClientStateRequest): _112.QueryConnectionClientStateRequestProtoMsg;
+                };
+                QueryConnectionClientStateResponse: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionClientStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionClientStateResponse;
+                    fromJSON(object: any): _112.QueryConnectionClientStateResponse;
+                    toJSON(message: _112.QueryConnectionClientStateResponse): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionClientStateResponse>): _112.QueryConnectionClientStateResponse;
+                    fromProtoMsg(message: _112.QueryConnectionClientStateResponseProtoMsg): _112.QueryConnectionClientStateResponse;
+                    toProto(message: _112.QueryConnectionClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionClientStateResponse): _112.QueryConnectionClientStateResponseProtoMsg;
+                };
+                QueryConnectionConsensusStateRequest: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionConsensusStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionConsensusStateRequest;
+                    fromJSON(object: any): _112.QueryConnectionConsensusStateRequest;
+                    toJSON(message: _112.QueryConnectionConsensusStateRequest): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionConsensusStateRequest>): _112.QueryConnectionConsensusStateRequest;
+                    fromProtoMsg(message: _112.QueryConnectionConsensusStateRequestProtoMsg): _112.QueryConnectionConsensusStateRequest;
+                    toProto(message: _112.QueryConnectionConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionConsensusStateRequest): _112.QueryConnectionConsensusStateRequestProtoMsg;
+                };
+                QueryConnectionConsensusStateResponse: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionConsensusStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionConsensusStateResponse;
+                    fromJSON(object: any): _112.QueryConnectionConsensusStateResponse;
+                    toJSON(message: _112.QueryConnectionConsensusStateResponse): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionConsensusStateResponse>): _112.QueryConnectionConsensusStateResponse;
+                    fromProtoMsg(message: _112.QueryConnectionConsensusStateResponseProtoMsg): _112.QueryConnectionConsensusStateResponse;
+                    toProto(message: _112.QueryConnectionConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionConsensusStateResponse): _112.QueryConnectionConsensusStateResponseProtoMsg;
+                };
+                QueryConnectionParamsRequest: {
+                    typeUrl: string;
+                    encode(_: _112.QueryConnectionParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionParamsRequest;
+                    fromJSON(_: any): _112.QueryConnectionParamsRequest;
+                    toJSON(_: _112.QueryConnectionParamsRequest): unknown;
+                    fromPartial(_: Partial<_112.QueryConnectionParamsRequest>): _112.QueryConnectionParamsRequest;
+                    fromProtoMsg(message: _112.QueryConnectionParamsRequestProtoMsg): _112.QueryConnectionParamsRequest;
+                    toProto(message: _112.QueryConnectionParamsRequest): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionParamsRequest): _112.QueryConnectionParamsRequestProtoMsg;
+                };
+                QueryConnectionParamsResponse: {
+                    typeUrl: string;
+                    encode(message: _112.QueryConnectionParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _112.QueryConnectionParamsResponse;
+                    fromJSON(object: any): _112.QueryConnectionParamsResponse;
+                    toJSON(message: _112.QueryConnectionParamsResponse): unknown;
+                    fromPartial(object: Partial<_112.QueryConnectionParamsResponse>): _112.QueryConnectionParamsResponse;
+                    fromProtoMsg(message: _112.QueryConnectionParamsResponseProtoMsg): _112.QueryConnectionParamsResponse;
+                    toProto(message: _112.QueryConnectionParamsResponse): Uint8Array;
+                    toProtoMsg(message: _112.QueryConnectionParamsResponse): _112.QueryConnectionParamsResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: string;
+                    encode(message: _111.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _111.GenesisState;
+                    fromJSON(object: any): _111.GenesisState;
+                    toJSON(message: _111.GenesisState): unknown;
+                    fromPartial(object: Partial<_111.GenesisState>): _111.GenesisState;
+                    fromProtoMsg(message: _111.GenesisStateProtoMsg): _111.GenesisState;
+                    toProto(message: _111.GenesisState): Uint8Array;
+                    toProtoMsg(message: _111.GenesisState): _111.GenesisStateProtoMsg;
+                };
+                stateFromJSON(object: any): _110.State;
+                stateToJSON(object: _110.State): string;
+                State: typeof _110.State;
+                StateSDKType: typeof _110.State;
+                ConnectionEnd: {
+                    typeUrl: string;
+                    encode(message: _110.ConnectionEnd, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _110.ConnectionEnd;
+                    fromJSON(object: any): _110.ConnectionEnd;
+                    toJSON(message: _110.ConnectionEnd): unknown;
+                    fromPartial(object: Partial<_110.ConnectionEnd>): _110.ConnectionEnd;
+                    fromProtoMsg(message: _110.ConnectionEndProtoMsg): _110.ConnectionEnd;
+                    toProto(message: _110.ConnectionEnd): Uint8Array;
+                    toProtoMsg(message: _110.ConnectionEnd): _110.ConnectionEndProtoMsg;
+                };
+                IdentifiedConnection: {
+                    typeUrl: string;
+                    encode(message: _110.IdentifiedConnection, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _110.IdentifiedConnection;
+                    fromJSON(object: any): _110.IdentifiedConnection;
+                    toJSON(message: _110.IdentifiedConnection): unknown;
+                    fromPartial(object: Partial<_110.IdentifiedConnection>): _110.IdentifiedConnection;
+                    fromProtoMsg(message: _110.IdentifiedConnectionProtoMsg): _110.IdentifiedConnection;
+                    toProto(message: _110.IdentifiedConnection): Uint8Array;
+                    toProtoMsg(message: _110.IdentifiedConnection): _110.IdentifiedConnectionProtoMsg;
+                };
+                Counterparty: {
+                    typeUrl: string;
+                    encode(message: _110.Counterparty, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _110.Counterparty;
+                    fromJSON(object: any): _110.Counterparty;
+                    toJSON(message: _110.Counterparty): unknown;
+                    fromPartial(object: Partial<_110.Counterparty>): _110.Counterparty;
+                    fromProtoMsg(message: _110.CounterpartyProtoMsg): _110.Counterparty;
+                    toProto(message: _110.Counterparty): Uint8Array;
+                    toProtoMsg(message: _110.Counterparty): _110.CounterpartyProtoMsg;
+                };
+                ClientPaths: {
+                    typeUrl: string;
+                    encode(message: _110.ClientPaths, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _110.ClientPaths;
+                    fromJSON(object: any): _110.ClientPaths;
+                    toJSON(message: _110.ClientPaths): unknown;
+                    fromPartial(object: Partial<_110.ClientPaths>): _110.ClientPaths;
+                    fromProtoMsg(message: _110.ClientPathsProtoMsg): _110.ClientPaths;
+                    toProto(message: _110.ClientPaths): Uint8Array;
+                    toProtoMsg(message: _110.ClientPaths): _110.ClientPathsProtoMsg;
+                };
+                ConnectionPaths: {
+                    typeUrl: string;
+                    encode(message: _110.ConnectionPaths, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _110.ConnectionPaths;
+                    fromJSON(object: any): _110.ConnectionPaths;
+                    toJSON(message: _110.ConnectionPaths): unknown;
+                    fromPartial(object: Partial<_110.ConnectionPaths>): _110.ConnectionPaths;
+                    fromProtoMsg(message: _110.ConnectionPathsProtoMsg): _110.ConnectionPaths;
+                    toProto(message: _110.ConnectionPaths): Uint8Array;
+                    toProtoMsg(message: _110.ConnectionPaths): _110.ConnectionPathsProtoMsg;
+                };
+                Version: {
+                    typeUrl: string;
+                    encode(message: _110.Version, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _110.Version;
+                    fromJSON(object: any): _110.Version;
+                    toJSON(message: _110.Version): unknown;
+                    fromPartial(object: Partial<_110.Version>): _110.Version;
+                    fromProtoMsg(message: _110.VersionProtoMsg): _110.Version;
+                    toProto(message: _110.Version): Uint8Array;
+                    toProtoMsg(message: _110.Version): _110.VersionProtoMsg;
                 };
                 Params: {
                     typeUrl: string;
-                    encode(message: _86.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _86.Params;
-                    fromJSON(object: any): _86.Params;
-                    toJSON(message: _86.Params): unknown;
-                    fromPartial(object: Partial<_86.Params>): _86.Params;
-                    fromProtoMsg(message: _86.ParamsProtoMsg): _86.Params;
-                    toProto(message: _86.Params): Uint8Array;
-                    toProtoMsg(message: _86.Params): _86.ParamsProtoMsg;
+                    encode(message: _110.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _110.Params;
+                    fromJSON(object: any): _110.Params;
+                    toJSON(message: _110.Params): unknown;
+                    fromPartial(object: Partial<_110.Params>): _110.Params;
+                    fromProtoMsg(message: _110.ParamsProtoMsg): _110.Params;
+                    toProto(message: _110.Params): Uint8Array;
+                    toProtoMsg(message: _110.Params): _110.ParamsProtoMsg;
+                };
+            };
+        }
+    }
+    namespace lightclients {
+        namespace localhost {
+            const v1: {
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _114.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _114.ClientState;
+                    fromJSON(object: any): _114.ClientState;
+                    toJSON(message: _114.ClientState): unknown;
+                    fromPartial(object: Partial<_114.ClientState>): _114.ClientState;
+                    fromProtoMsg(message: _114.ClientStateProtoMsg): _114.ClientState;
+                    toProto(message: _114.ClientState): Uint8Array;
+                    toProtoMsg(message: _114.ClientState): _114.ClientStateProtoMsg;
+                };
+            };
+        }
+        namespace solomachine {
+            const v1: {
+                dataTypeFromJSON(object: any): _115.DataType;
+                dataTypeToJSON(object: _115.DataType): string;
+                DataType: typeof _115.DataType;
+                DataTypeSDKType: typeof _115.DataType;
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _115.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.ClientState;
+                    fromJSON(object: any): _115.ClientState;
+                    toJSON(message: _115.ClientState): unknown;
+                    fromPartial(object: Partial<_115.ClientState>): _115.ClientState;
+                    fromProtoMsg(message: _115.ClientStateProtoMsg): _115.ClientState;
+                    toProto(message: _115.ClientState): Uint8Array;
+                    toProtoMsg(message: _115.ClientState): _115.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: string;
+                    encode(message: _115.ConsensusState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.ConsensusState;
+                    fromJSON(object: any): _115.ConsensusState;
+                    toJSON(message: _115.ConsensusState): unknown;
+                    fromPartial(object: Partial<_115.ConsensusState>): _115.ConsensusState;
+                    fromProtoMsg(message: _115.ConsensusStateProtoMsg): _115.ConsensusState;
+                    toProto(message: _115.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _115.ConsensusState): _115.ConsensusStateProtoMsg;
+                };
+                Header: {
+                    typeUrl: string;
+                    encode(message: _115.Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.Header;
+                    fromJSON(object: any): _115.Header;
+                    toJSON(message: _115.Header): unknown;
+                    fromPartial(object: Partial<_115.Header>): _115.Header;
+                    fromProtoMsg(message: _115.HeaderProtoMsg): _115.Header;
+                    toProto(message: _115.Header): Uint8Array;
+                    toProtoMsg(message: _115.Header): _115.HeaderProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: string;
+                    encode(message: _115.Misbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.Misbehaviour;
+                    fromJSON(object: any): _115.Misbehaviour;
+                    toJSON(message: _115.Misbehaviour): unknown;
+                    fromPartial(object: Partial<_115.Misbehaviour>): _115.Misbehaviour;
+                    fromProtoMsg(message: _115.MisbehaviourProtoMsg): _115.Misbehaviour;
+                    toProto(message: _115.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _115.Misbehaviour): _115.MisbehaviourProtoMsg;
+                };
+                SignatureAndData: {
+                    typeUrl: string;
+                    encode(message: _115.SignatureAndData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.SignatureAndData;
+                    fromJSON(object: any): _115.SignatureAndData;
+                    toJSON(message: _115.SignatureAndData): unknown;
+                    fromPartial(object: Partial<_115.SignatureAndData>): _115.SignatureAndData;
+                    fromProtoMsg(message: _115.SignatureAndDataProtoMsg): _115.SignatureAndData;
+                    toProto(message: _115.SignatureAndData): Uint8Array;
+                    toProtoMsg(message: _115.SignatureAndData): _115.SignatureAndDataProtoMsg;
+                };
+                TimestampedSignatureData: {
+                    typeUrl: string;
+                    encode(message: _115.TimestampedSignatureData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.TimestampedSignatureData;
+                    fromJSON(object: any): _115.TimestampedSignatureData;
+                    toJSON(message: _115.TimestampedSignatureData): unknown;
+                    fromPartial(object: Partial<_115.TimestampedSignatureData>): _115.TimestampedSignatureData;
+                    fromProtoMsg(message: _115.TimestampedSignatureDataProtoMsg): _115.TimestampedSignatureData;
+                    toProto(message: _115.TimestampedSignatureData): Uint8Array;
+                    toProtoMsg(message: _115.TimestampedSignatureData): _115.TimestampedSignatureDataProtoMsg;
+                };
+                SignBytes: {
+                    typeUrl: string;
+                    encode(message: _115.SignBytes, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.SignBytes;
+                    fromJSON(object: any): _115.SignBytes;
+                    toJSON(message: _115.SignBytes): unknown;
+                    fromPartial(object: Partial<_115.SignBytes>): _115.SignBytes;
+                    fromProtoMsg(message: _115.SignBytesProtoMsg): _115.SignBytes;
+                    toProto(message: _115.SignBytes): Uint8Array;
+                    toProtoMsg(message: _115.SignBytes): _115.SignBytesProtoMsg;
+                };
+                HeaderData: {
+                    typeUrl: string;
+                    encode(message: _115.HeaderData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.HeaderData;
+                    fromJSON(object: any): _115.HeaderData;
+                    toJSON(message: _115.HeaderData): unknown;
+                    fromPartial(object: Partial<_115.HeaderData>): _115.HeaderData;
+                    fromProtoMsg(message: _115.HeaderDataProtoMsg): _115.HeaderData;
+                    toProto(message: _115.HeaderData): Uint8Array;
+                    toProtoMsg(message: _115.HeaderData): _115.HeaderDataProtoMsg;
+                };
+                ClientStateData: {
+                    typeUrl: string;
+                    encode(message: _115.ClientStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.ClientStateData;
+                    fromJSON(object: any): _115.ClientStateData;
+                    toJSON(message: _115.ClientStateData): unknown;
+                    fromPartial(object: Partial<_115.ClientStateData>): _115.ClientStateData;
+                    fromProtoMsg(message: _115.ClientStateDataProtoMsg): _115.ClientStateData;
+                    toProto(message: _115.ClientStateData): Uint8Array;
+                    toProtoMsg(message: _115.ClientStateData): _115.ClientStateDataProtoMsg;
+                };
+                ConsensusStateData: {
+                    typeUrl: string;
+                    encode(message: _115.ConsensusStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.ConsensusStateData;
+                    fromJSON(object: any): _115.ConsensusStateData;
+                    toJSON(message: _115.ConsensusStateData): unknown;
+                    fromPartial(object: Partial<_115.ConsensusStateData>): _115.ConsensusStateData;
+                    fromProtoMsg(message: _115.ConsensusStateDataProtoMsg): _115.ConsensusStateData;
+                    toProto(message: _115.ConsensusStateData): Uint8Array;
+                    toProtoMsg(message: _115.ConsensusStateData): _115.ConsensusStateDataProtoMsg;
+                };
+                ConnectionStateData: {
+                    typeUrl: string;
+                    encode(message: _115.ConnectionStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.ConnectionStateData;
+                    fromJSON(object: any): _115.ConnectionStateData;
+                    toJSON(message: _115.ConnectionStateData): unknown;
+                    fromPartial(object: Partial<_115.ConnectionStateData>): _115.ConnectionStateData;
+                    fromProtoMsg(message: _115.ConnectionStateDataProtoMsg): _115.ConnectionStateData;
+                    toProto(message: _115.ConnectionStateData): Uint8Array;
+                    toProtoMsg(message: _115.ConnectionStateData): _115.ConnectionStateDataProtoMsg;
+                };
+                ChannelStateData: {
+                    typeUrl: string;
+                    encode(message: _115.ChannelStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.ChannelStateData;
+                    fromJSON(object: any): _115.ChannelStateData;
+                    toJSON(message: _115.ChannelStateData): unknown;
+                    fromPartial(object: Partial<_115.ChannelStateData>): _115.ChannelStateData;
+                    fromProtoMsg(message: _115.ChannelStateDataProtoMsg): _115.ChannelStateData;
+                    toProto(message: _115.ChannelStateData): Uint8Array;
+                    toProtoMsg(message: _115.ChannelStateData): _115.ChannelStateDataProtoMsg;
+                };
+                PacketCommitmentData: {
+                    typeUrl: string;
+                    encode(message: _115.PacketCommitmentData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.PacketCommitmentData;
+                    fromJSON(object: any): _115.PacketCommitmentData;
+                    toJSON(message: _115.PacketCommitmentData): unknown;
+                    fromPartial(object: Partial<_115.PacketCommitmentData>): _115.PacketCommitmentData;
+                    fromProtoMsg(message: _115.PacketCommitmentDataProtoMsg): _115.PacketCommitmentData;
+                    toProto(message: _115.PacketCommitmentData): Uint8Array;
+                    toProtoMsg(message: _115.PacketCommitmentData): _115.PacketCommitmentDataProtoMsg;
+                };
+                PacketAcknowledgementData: {
+                    typeUrl: string;
+                    encode(message: _115.PacketAcknowledgementData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.PacketAcknowledgementData;
+                    fromJSON(object: any): _115.PacketAcknowledgementData;
+                    toJSON(message: _115.PacketAcknowledgementData): unknown;
+                    fromPartial(object: Partial<_115.PacketAcknowledgementData>): _115.PacketAcknowledgementData;
+                    fromProtoMsg(message: _115.PacketAcknowledgementDataProtoMsg): _115.PacketAcknowledgementData;
+                    toProto(message: _115.PacketAcknowledgementData): Uint8Array;
+                    toProtoMsg(message: _115.PacketAcknowledgementData): _115.PacketAcknowledgementDataProtoMsg;
+                };
+                PacketReceiptAbsenceData: {
+                    typeUrl: string;
+                    encode(message: _115.PacketReceiptAbsenceData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.PacketReceiptAbsenceData;
+                    fromJSON(object: any): _115.PacketReceiptAbsenceData;
+                    toJSON(message: _115.PacketReceiptAbsenceData): unknown;
+                    fromPartial(object: Partial<_115.PacketReceiptAbsenceData>): _115.PacketReceiptAbsenceData;
+                    fromProtoMsg(message: _115.PacketReceiptAbsenceDataProtoMsg): _115.PacketReceiptAbsenceData;
+                    toProto(message: _115.PacketReceiptAbsenceData): Uint8Array;
+                    toProtoMsg(message: _115.PacketReceiptAbsenceData): _115.PacketReceiptAbsenceDataProtoMsg;
+                };
+                NextSequenceRecvData: {
+                    typeUrl: string;
+                    encode(message: _115.NextSequenceRecvData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _115.NextSequenceRecvData;
+                    fromJSON(object: any): _115.NextSequenceRecvData;
+                    toJSON(message: _115.NextSequenceRecvData): unknown;
+                    fromPartial(object: Partial<_115.NextSequenceRecvData>): _115.NextSequenceRecvData;
+                    fromProtoMsg(message: _115.NextSequenceRecvDataProtoMsg): _115.NextSequenceRecvData;
+                    toProto(message: _115.NextSequenceRecvData): Uint8Array;
+                    toProtoMsg(message: _115.NextSequenceRecvData): _115.NextSequenceRecvDataProtoMsg;
+                };
+            };
+            const v2: {
+                dataTypeFromJSON(object: any): _116.DataType;
+                dataTypeToJSON(object: _116.DataType): string;
+                DataType: typeof _116.DataType;
+                DataTypeSDKType: typeof _116.DataType;
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _116.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.ClientState;
+                    fromJSON(object: any): _116.ClientState;
+                    toJSON(message: _116.ClientState): unknown;
+                    fromPartial(object: Partial<_116.ClientState>): _116.ClientState;
+                    fromProtoMsg(message: _116.ClientStateProtoMsg): _116.ClientState;
+                    toProto(message: _116.ClientState): Uint8Array;
+                    toProtoMsg(message: _116.ClientState): _116.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: string;
+                    encode(message: _116.ConsensusState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.ConsensusState;
+                    fromJSON(object: any): _116.ConsensusState;
+                    toJSON(message: _116.ConsensusState): unknown;
+                    fromPartial(object: Partial<_116.ConsensusState>): _116.ConsensusState;
+                    fromProtoMsg(message: _116.ConsensusStateProtoMsg): _116.ConsensusState;
+                    toProto(message: _116.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _116.ConsensusState): _116.ConsensusStateProtoMsg;
+                };
+                Header: {
+                    typeUrl: string;
+                    encode(message: _116.Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.Header;
+                    fromJSON(object: any): _116.Header;
+                    toJSON(message: _116.Header): unknown;
+                    fromPartial(object: Partial<_116.Header>): _116.Header;
+                    fromProtoMsg(message: _116.HeaderProtoMsg): _116.Header;
+                    toProto(message: _116.Header): Uint8Array;
+                    toProtoMsg(message: _116.Header): _116.HeaderProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: string;
+                    encode(message: _116.Misbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.Misbehaviour;
+                    fromJSON(object: any): _116.Misbehaviour;
+                    toJSON(message: _116.Misbehaviour): unknown;
+                    fromPartial(object: Partial<_116.Misbehaviour>): _116.Misbehaviour;
+                    fromProtoMsg(message: _116.MisbehaviourProtoMsg): _116.Misbehaviour;
+                    toProto(message: _116.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _116.Misbehaviour): _116.MisbehaviourProtoMsg;
+                };
+                SignatureAndData: {
+                    typeUrl: string;
+                    encode(message: _116.SignatureAndData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.SignatureAndData;
+                    fromJSON(object: any): _116.SignatureAndData;
+                    toJSON(message: _116.SignatureAndData): unknown;
+                    fromPartial(object: Partial<_116.SignatureAndData>): _116.SignatureAndData;
+                    fromProtoMsg(message: _116.SignatureAndDataProtoMsg): _116.SignatureAndData;
+                    toProto(message: _116.SignatureAndData): Uint8Array;
+                    toProtoMsg(message: _116.SignatureAndData): _116.SignatureAndDataProtoMsg;
+                };
+                TimestampedSignatureData: {
+                    typeUrl: string;
+                    encode(message: _116.TimestampedSignatureData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.TimestampedSignatureData;
+                    fromJSON(object: any): _116.TimestampedSignatureData;
+                    toJSON(message: _116.TimestampedSignatureData): unknown;
+                    fromPartial(object: Partial<_116.TimestampedSignatureData>): _116.TimestampedSignatureData;
+                    fromProtoMsg(message: _116.TimestampedSignatureDataProtoMsg): _116.TimestampedSignatureData;
+                    toProto(message: _116.TimestampedSignatureData): Uint8Array;
+                    toProtoMsg(message: _116.TimestampedSignatureData): _116.TimestampedSignatureDataProtoMsg;
+                };
+                SignBytes: {
+                    typeUrl: string;
+                    encode(message: _116.SignBytes, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.SignBytes;
+                    fromJSON(object: any): _116.SignBytes;
+                    toJSON(message: _116.SignBytes): unknown;
+                    fromPartial(object: Partial<_116.SignBytes>): _116.SignBytes;
+                    fromProtoMsg(message: _116.SignBytesProtoMsg): _116.SignBytes;
+                    toProto(message: _116.SignBytes): Uint8Array;
+                    toProtoMsg(message: _116.SignBytes): _116.SignBytesProtoMsg;
+                };
+                HeaderData: {
+                    typeUrl: string;
+                    encode(message: _116.HeaderData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.HeaderData;
+                    fromJSON(object: any): _116.HeaderData;
+                    toJSON(message: _116.HeaderData): unknown;
+                    fromPartial(object: Partial<_116.HeaderData>): _116.HeaderData;
+                    fromProtoMsg(message: _116.HeaderDataProtoMsg): _116.HeaderData;
+                    toProto(message: _116.HeaderData): Uint8Array;
+                    toProtoMsg(message: _116.HeaderData): _116.HeaderDataProtoMsg;
+                };
+                ClientStateData: {
+                    typeUrl: string;
+                    encode(message: _116.ClientStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.ClientStateData;
+                    fromJSON(object: any): _116.ClientStateData;
+                    toJSON(message: _116.ClientStateData): unknown;
+                    fromPartial(object: Partial<_116.ClientStateData>): _116.ClientStateData;
+                    fromProtoMsg(message: _116.ClientStateDataProtoMsg): _116.ClientStateData;
+                    toProto(message: _116.ClientStateData): Uint8Array;
+                    toProtoMsg(message: _116.ClientStateData): _116.ClientStateDataProtoMsg;
+                };
+                ConsensusStateData: {
+                    typeUrl: string;
+                    encode(message: _116.ConsensusStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.ConsensusStateData;
+                    fromJSON(object: any): _116.ConsensusStateData;
+                    toJSON(message: _116.ConsensusStateData): unknown;
+                    fromPartial(object: Partial<_116.ConsensusStateData>): _116.ConsensusStateData;
+                    fromProtoMsg(message: _116.ConsensusStateDataProtoMsg): _116.ConsensusStateData;
+                    toProto(message: _116.ConsensusStateData): Uint8Array;
+                    toProtoMsg(message: _116.ConsensusStateData): _116.ConsensusStateDataProtoMsg;
+                };
+                ConnectionStateData: {
+                    typeUrl: string;
+                    encode(message: _116.ConnectionStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.ConnectionStateData;
+                    fromJSON(object: any): _116.ConnectionStateData;
+                    toJSON(message: _116.ConnectionStateData): unknown;
+                    fromPartial(object: Partial<_116.ConnectionStateData>): _116.ConnectionStateData;
+                    fromProtoMsg(message: _116.ConnectionStateDataProtoMsg): _116.ConnectionStateData;
+                    toProto(message: _116.ConnectionStateData): Uint8Array;
+                    toProtoMsg(message: _116.ConnectionStateData): _116.ConnectionStateDataProtoMsg;
+                };
+                ChannelStateData: {
+                    typeUrl: string;
+                    encode(message: _116.ChannelStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.ChannelStateData;
+                    fromJSON(object: any): _116.ChannelStateData;
+                    toJSON(message: _116.ChannelStateData): unknown;
+                    fromPartial(object: Partial<_116.ChannelStateData>): _116.ChannelStateData;
+                    fromProtoMsg(message: _116.ChannelStateDataProtoMsg): _116.ChannelStateData;
+                    toProto(message: _116.ChannelStateData): Uint8Array;
+                    toProtoMsg(message: _116.ChannelStateData): _116.ChannelStateDataProtoMsg;
+                };
+                PacketCommitmentData: {
+                    typeUrl: string;
+                    encode(message: _116.PacketCommitmentData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.PacketCommitmentData;
+                    fromJSON(object: any): _116.PacketCommitmentData;
+                    toJSON(message: _116.PacketCommitmentData): unknown;
+                    fromPartial(object: Partial<_116.PacketCommitmentData>): _116.PacketCommitmentData;
+                    fromProtoMsg(message: _116.PacketCommitmentDataProtoMsg): _116.PacketCommitmentData;
+                    toProto(message: _116.PacketCommitmentData): Uint8Array;
+                    toProtoMsg(message: _116.PacketCommitmentData): _116.PacketCommitmentDataProtoMsg;
+                };
+                PacketAcknowledgementData: {
+                    typeUrl: string;
+                    encode(message: _116.PacketAcknowledgementData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.PacketAcknowledgementData;
+                    fromJSON(object: any): _116.PacketAcknowledgementData;
+                    toJSON(message: _116.PacketAcknowledgementData): unknown;
+                    fromPartial(object: Partial<_116.PacketAcknowledgementData>): _116.PacketAcknowledgementData;
+                    fromProtoMsg(message: _116.PacketAcknowledgementDataProtoMsg): _116.PacketAcknowledgementData;
+                    toProto(message: _116.PacketAcknowledgementData): Uint8Array;
+                    toProtoMsg(message: _116.PacketAcknowledgementData): _116.PacketAcknowledgementDataProtoMsg;
+                };
+                PacketReceiptAbsenceData: {
+                    typeUrl: string;
+                    encode(message: _116.PacketReceiptAbsenceData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.PacketReceiptAbsenceData;
+                    fromJSON(object: any): _116.PacketReceiptAbsenceData;
+                    toJSON(message: _116.PacketReceiptAbsenceData): unknown;
+                    fromPartial(object: Partial<_116.PacketReceiptAbsenceData>): _116.PacketReceiptAbsenceData;
+                    fromProtoMsg(message: _116.PacketReceiptAbsenceDataProtoMsg): _116.PacketReceiptAbsenceData;
+                    toProto(message: _116.PacketReceiptAbsenceData): Uint8Array;
+                    toProtoMsg(message: _116.PacketReceiptAbsenceData): _116.PacketReceiptAbsenceDataProtoMsg;
+                };
+                NextSequenceRecvData: {
+                    typeUrl: string;
+                    encode(message: _116.NextSequenceRecvData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _116.NextSequenceRecvData;
+                    fromJSON(object: any): _116.NextSequenceRecvData;
+                    toJSON(message: _116.NextSequenceRecvData): unknown;
+                    fromPartial(object: Partial<_116.NextSequenceRecvData>): _116.NextSequenceRecvData;
+                    fromProtoMsg(message: _116.NextSequenceRecvDataProtoMsg): _116.NextSequenceRecvData;
+                    toProto(message: _116.NextSequenceRecvData): Uint8Array;
+                    toProtoMsg(message: _116.NextSequenceRecvData): _116.NextSequenceRecvDataProtoMsg;
+                };
+            };
+        }
+        namespace tendermint {
+            const v1: {
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _117.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _117.ClientState;
+                    fromJSON(object: any): _117.ClientState;
+                    toJSON(message: _117.ClientState): unknown;
+                    fromPartial(object: Partial<_117.ClientState>): _117.ClientState;
+                    fromProtoMsg(message: _117.ClientStateProtoMsg): _117.ClientState;
+                    toProto(message: _117.ClientState): Uint8Array;
+                    toProtoMsg(message: _117.ClientState): _117.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: string;
+                    encode(message: _117.ConsensusState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _117.ConsensusState;
+                    fromJSON(object: any): _117.ConsensusState;
+                    toJSON(message: _117.ConsensusState): unknown;
+                    fromPartial(object: Partial<_117.ConsensusState>): _117.ConsensusState;
+                    fromProtoMsg(message: _117.ConsensusStateProtoMsg): _117.ConsensusState;
+                    toProto(message: _117.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _117.ConsensusState): _117.ConsensusStateProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: string;
+                    encode(message: _117.Misbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _117.Misbehaviour;
+                    fromJSON(object: any): _117.Misbehaviour;
+                    toJSON(message: _117.Misbehaviour): unknown;
+                    fromPartial(object: Partial<_117.Misbehaviour>): _117.Misbehaviour;
+                    fromProtoMsg(message: _117.MisbehaviourProtoMsg): _117.Misbehaviour;
+                    toProto(message: _117.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _117.Misbehaviour): _117.MisbehaviourProtoMsg;
+                };
+                Header: {
+                    typeUrl: string;
+                    encode(message: _117.Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _117.Header;
+                    fromJSON(object: any): _117.Header;
+                    toJSON(message: _117.Header): unknown;
+                    fromPartial(object: Partial<_117.Header>): _117.Header;
+                    fromProtoMsg(message: _117.HeaderProtoMsg): _117.Header;
+                    toProto(message: _117.Header): Uint8Array;
+                    toProtoMsg(message: _117.Header): _117.HeaderProtoMsg;
+                };
+                Fraction: {
+                    typeUrl: string;
+                    encode(message: _117.Fraction, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _117.Fraction;
+                    fromJSON(object: any): _117.Fraction;
+                    toJSON(message: _117.Fraction): unknown;
+                    fromPartial(object: Partial<_117.Fraction>): _117.Fraction;
+                    fromProtoMsg(message: _117.FractionProtoMsg): _117.Fraction;
+                    toProto(message: _117.Fraction): Uint8Array;
+                    toProtoMsg(message: _117.Fraction): _117.FractionProtoMsg;
                 };
             };
         }