@agoric/cosmic-proto 0.4.1-orchestration-dev-096c4e8.0 → 0.4.1-other-dev-fbe72e7.0.fbe72e7

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

@@ -1,234 +1,2482 @@
-import * as _23 from './core/channel/v1/channel.js';
-import * as _24 from './core/client/v1/client.js';
+import * as _128 from './applications/interchain_accounts/controller/v1/controller.js';
+import * as _129 from './applications/interchain_accounts/controller/v1/query.js';
+import * as _130 from './applications/interchain_accounts/controller/v1/tx.js';
+import * as _131 from './applications/interchain_accounts/genesis/v1/genesis.js';
+import * as _132 from './applications/interchain_accounts/host/v1/host.js';
+import * as _133 from './applications/interchain_accounts/host/v1/query.js';
+import * as _134 from './applications/interchain_accounts/host/v1/tx.js';
+import * as _135 from './applications/interchain_accounts/v1/account.js';
+import * as _136 from './applications/interchain_accounts/v1/metadata.js';
+import * as _137 from './applications/interchain_accounts/v1/packet.js';
+import * as _138 from './applications/transfer/v1/authz.js';
+import * as _139 from './applications/transfer/v1/genesis.js';
+import * as _140 from './applications/transfer/v1/query.js';
+import * as _141 from './applications/transfer/v1/transfer.js';
+import * as _142 from './applications/transfer/v1/tx.js';
+import * as _143 from './applications/transfer/v2/packet.js';
+import * as _144 from './core/channel/v1/channel.js';
+import * as _145 from './core/channel/v1/genesis.js';
+import * as _146 from './core/channel/v1/query.js';
+import * as _147 from './core/channel/v1/tx.js';
+import * as _148 from './core/client/v1/client.js';
+import * as _149 from './core/client/v1/genesis.js';
+import * as _150 from './core/client/v1/query.js';
+import * as _151 from './core/client/v1/tx.js';
+import * as _152 from './core/commitment/v1/commitment.js';
+import * as _153 from './core/connection/v1/connection.js';
+import * as _154 from './core/connection/v1/genesis.js';
+import * as _155 from './core/connection/v1/query.js';
+import * as _156 from './core/connection/v1/tx.js';
+import * as _157 from './lightclients/localhost/v1/localhost.js';
+import * as _158 from './lightclients/localhost/v2/localhost.js';
+import * as _159 from './lightclients/solomachine/v1/solomachine.js';
+import * as _160 from './lightclients/solomachine/v2/solomachine.js';
+import * as _161 from './lightclients/solomachine/v3/solomachine.js';
+import * as _162 from './lightclients/tendermint/v1/tendermint.js';
 export declare namespace ibc {
+    namespace applications {
+        namespace interchain_accounts {
+            namespace controller {
+                const v1: {
+                    MsgRegisterInterchainAccount: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount";
+                        encode(message: _130.MsgRegisterInterchainAccount, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _130.MsgRegisterInterchainAccount;
+                        fromJSON(object: any): _130.MsgRegisterInterchainAccount;
+                        toJSON(message: _130.MsgRegisterInterchainAccount): import("../json-safe.ts").JsonSafe<_130.MsgRegisterInterchainAccount>;
+                        fromPartial(object: Partial<_130.MsgRegisterInterchainAccount>): _130.MsgRegisterInterchainAccount;
+                        fromProtoMsg(message: _130.MsgRegisterInterchainAccountProtoMsg): _130.MsgRegisterInterchainAccount;
+                        toProto(message: _130.MsgRegisterInterchainAccount): Uint8Array;
+                        toProtoMsg(message: _130.MsgRegisterInterchainAccount): _130.MsgRegisterInterchainAccountProtoMsg;
+                    };
+                    MsgRegisterInterchainAccountResponse: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse";
+                        encode(message: _130.MsgRegisterInterchainAccountResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _130.MsgRegisterInterchainAccountResponse;
+                        fromJSON(object: any): _130.MsgRegisterInterchainAccountResponse;
+                        toJSON(message: _130.MsgRegisterInterchainAccountResponse): import("../json-safe.ts").JsonSafe<_130.MsgRegisterInterchainAccountResponse>;
+                        fromPartial(object: Partial<_130.MsgRegisterInterchainAccountResponse>): _130.MsgRegisterInterchainAccountResponse;
+                        fromProtoMsg(message: _130.MsgRegisterInterchainAccountResponseProtoMsg): _130.MsgRegisterInterchainAccountResponse;
+                        toProto(message: _130.MsgRegisterInterchainAccountResponse): Uint8Array;
+                        toProtoMsg(message: _130.MsgRegisterInterchainAccountResponse): _130.MsgRegisterInterchainAccountResponseProtoMsg;
+                    };
+                    MsgSendTx: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgSendTx";
+                        encode(message: _130.MsgSendTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _130.MsgSendTx;
+                        fromJSON(object: any): _130.MsgSendTx;
+                        toJSON(message: _130.MsgSendTx): import("../json-safe.ts").JsonSafe<_130.MsgSendTx>;
+                        fromPartial(object: Partial<_130.MsgSendTx>): _130.MsgSendTx;
+                        fromProtoMsg(message: _130.MsgSendTxProtoMsg): _130.MsgSendTx;
+                        toProto(message: _130.MsgSendTx): Uint8Array;
+                        toProtoMsg(message: _130.MsgSendTx): _130.MsgSendTxProtoMsg;
+                    };
+                    MsgSendTxResponse: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse";
+                        encode(message: _130.MsgSendTxResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _130.MsgSendTxResponse;
+                        fromJSON(object: any): _130.MsgSendTxResponse;
+                        toJSON(message: _130.MsgSendTxResponse): import("../json-safe.ts").JsonSafe<_130.MsgSendTxResponse>;
+                        fromPartial(object: Partial<_130.MsgSendTxResponse>): _130.MsgSendTxResponse;
+                        fromProtoMsg(message: _130.MsgSendTxResponseProtoMsg): _130.MsgSendTxResponse;
+                        toProto(message: _130.MsgSendTxResponse): Uint8Array;
+                        toProtoMsg(message: _130.MsgSendTxResponse): _130.MsgSendTxResponseProtoMsg;
+                    };
+                    QueryInterchainAccountRequest: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest";
+                        encode(message: _129.QueryInterchainAccountRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _129.QueryInterchainAccountRequest;
+                        fromJSON(object: any): _129.QueryInterchainAccountRequest;
+                        toJSON(message: _129.QueryInterchainAccountRequest): import("../json-safe.ts").JsonSafe<_129.QueryInterchainAccountRequest>;
+                        fromPartial(object: Partial<_129.QueryInterchainAccountRequest>): _129.QueryInterchainAccountRequest;
+                        fromProtoMsg(message: _129.QueryInterchainAccountRequestProtoMsg): _129.QueryInterchainAccountRequest;
+                        toProto(message: _129.QueryInterchainAccountRequest): Uint8Array;
+                        toProtoMsg(message: _129.QueryInterchainAccountRequest): _129.QueryInterchainAccountRequestProtoMsg;
+                    };
+                    QueryInterchainAccountResponse: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse";
+                        encode(message: _129.QueryInterchainAccountResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _129.QueryInterchainAccountResponse;
+                        fromJSON(object: any): _129.QueryInterchainAccountResponse;
+                        toJSON(message: _129.QueryInterchainAccountResponse): import("../json-safe.ts").JsonSafe<_129.QueryInterchainAccountResponse>;
+                        fromPartial(object: Partial<_129.QueryInterchainAccountResponse>): _129.QueryInterchainAccountResponse;
+                        fromProtoMsg(message: _129.QueryInterchainAccountResponseProtoMsg): _129.QueryInterchainAccountResponse;
+                        toProto(message: _129.QueryInterchainAccountResponse): Uint8Array;
+                        toProtoMsg(message: _129.QueryInterchainAccountResponse): _129.QueryInterchainAccountResponseProtoMsg;
+                    };
+                    QueryParamsRequest: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest";
+                        encode(_: _129.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _129.QueryParamsRequest;
+                        fromJSON(_: any): _129.QueryParamsRequest;
+                        toJSON(_: _129.QueryParamsRequest): import("../json-safe.ts").JsonSafe<_129.QueryParamsRequest>;
+                        fromPartial(_: Partial<_129.QueryParamsRequest>): _129.QueryParamsRequest;
+                        fromProtoMsg(message: _129.QueryParamsRequestProtoMsg): _129.QueryParamsRequest;
+                        toProto(message: _129.QueryParamsRequest): Uint8Array;
+                        toProtoMsg(message: _129.QueryParamsRequest): _129.QueryParamsRequestProtoMsg;
+                    };
+                    QueryParamsResponse: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse";
+                        encode(message: _129.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _129.QueryParamsResponse;
+                        fromJSON(object: any): _129.QueryParamsResponse;
+                        toJSON(message: _129.QueryParamsResponse): import("../json-safe.ts").JsonSafe<_129.QueryParamsResponse>;
+                        fromPartial(object: Partial<_129.QueryParamsResponse>): _129.QueryParamsResponse;
+                        fromProtoMsg(message: _129.QueryParamsResponseProtoMsg): _129.QueryParamsResponse;
+                        toProto(message: _129.QueryParamsResponse): Uint8Array;
+                        toProtoMsg(message: _129.QueryParamsResponse): _129.QueryParamsResponseProtoMsg;
+                    };
+                    Params: {
+                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.Params";
+                        encode(message: _128.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _128.Params;
+                        fromJSON(object: any): _128.Params;
+                        toJSON(message: _128.Params): import("../json-safe.ts").JsonSafe<_128.Params>;
+                        fromPartial(object: Partial<_128.Params>): _128.Params;
+                        fromProtoMsg(message: _128.ParamsProtoMsg): _128.Params;
+                        toProto(message: _128.Params): Uint8Array;
+                        toProtoMsg(message: _128.Params): _128.ParamsProtoMsg;
+                    };
+                };
+            }
+            namespace genesis {
+                const v1: {
+                    GenesisState: {
+                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.GenesisState";
+                        encode(message: _131.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _131.GenesisState;
+                        fromJSON(object: any): _131.GenesisState;
+                        toJSON(message: _131.GenesisState): import("../json-safe.ts").JsonSafe<_131.GenesisState>;
+                        fromPartial(object: Partial<_131.GenesisState>): _131.GenesisState;
+                        fromProtoMsg(message: _131.GenesisStateProtoMsg): _131.GenesisState;
+                        toProto(message: _131.GenesisState): Uint8Array;
+                        toProtoMsg(message: _131.GenesisState): _131.GenesisStateProtoMsg;
+                    };
+                    ControllerGenesisState: {
+                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState";
+                        encode(message: _131.ControllerGenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _131.ControllerGenesisState;
+                        fromJSON(object: any): _131.ControllerGenesisState;
+                        toJSON(message: _131.ControllerGenesisState): import("../json-safe.ts").JsonSafe<_131.ControllerGenesisState>;
+                        fromPartial(object: Partial<_131.ControllerGenesisState>): _131.ControllerGenesisState;
+                        fromProtoMsg(message: _131.ControllerGenesisStateProtoMsg): _131.ControllerGenesisState;
+                        toProto(message: _131.ControllerGenesisState): Uint8Array;
+                        toProtoMsg(message: _131.ControllerGenesisState): _131.ControllerGenesisStateProtoMsg;
+                    };
+                    HostGenesisState: {
+                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.HostGenesisState";
+                        encode(message: _131.HostGenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _131.HostGenesisState;
+                        fromJSON(object: any): _131.HostGenesisState;
+                        toJSON(message: _131.HostGenesisState): import("../json-safe.ts").JsonSafe<_131.HostGenesisState>;
+                        fromPartial(object: Partial<_131.HostGenesisState>): _131.HostGenesisState;
+                        fromProtoMsg(message: _131.HostGenesisStateProtoMsg): _131.HostGenesisState;
+                        toProto(message: _131.HostGenesisState): Uint8Array;
+                        toProtoMsg(message: _131.HostGenesisState): _131.HostGenesisStateProtoMsg;
+                    };
+                    ActiveChannel: {
+                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.ActiveChannel";
+                        encode(message: _131.ActiveChannel, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _131.ActiveChannel;
+                        fromJSON(object: any): _131.ActiveChannel;
+                        toJSON(message: _131.ActiveChannel): import("../json-safe.ts").JsonSafe<_131.ActiveChannel>;
+                        fromPartial(object: Partial<_131.ActiveChannel>): _131.ActiveChannel;
+                        fromProtoMsg(message: _131.ActiveChannelProtoMsg): _131.ActiveChannel;
+                        toProto(message: _131.ActiveChannel): Uint8Array;
+                        toProtoMsg(message: _131.ActiveChannel): _131.ActiveChannelProtoMsg;
+                    };
+                    RegisteredInterchainAccount: {
+                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount";
+                        encode(message: _131.RegisteredInterchainAccount, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _131.RegisteredInterchainAccount;
+                        fromJSON(object: any): _131.RegisteredInterchainAccount;
+                        toJSON(message: _131.RegisteredInterchainAccount): import("../json-safe.ts").JsonSafe<_131.RegisteredInterchainAccount>;
+                        fromPartial(object: Partial<_131.RegisteredInterchainAccount>): _131.RegisteredInterchainAccount;
+                        fromProtoMsg(message: _131.RegisteredInterchainAccountProtoMsg): _131.RegisteredInterchainAccount;
+                        toProto(message: _131.RegisteredInterchainAccount): Uint8Array;
+                        toProtoMsg(message: _131.RegisteredInterchainAccount): _131.RegisteredInterchainAccountProtoMsg;
+                    };
+                };
+            }
+            namespace host {
+                const v1: {
+                    MsgModuleQuerySafe: {
+                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe";
+                        encode(message: _134.MsgModuleQuerySafe, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _134.MsgModuleQuerySafe;
+                        fromJSON(object: any): _134.MsgModuleQuerySafe;
+                        toJSON(message: _134.MsgModuleQuerySafe): import("../json-safe.ts").JsonSafe<_134.MsgModuleQuerySafe>;
+                        fromPartial(object: Partial<_134.MsgModuleQuerySafe>): _134.MsgModuleQuerySafe;
+                        fromProtoMsg(message: _134.MsgModuleQuerySafeProtoMsg): _134.MsgModuleQuerySafe;
+                        toProto(message: _134.MsgModuleQuerySafe): Uint8Array;
+                        toProtoMsg(message: _134.MsgModuleQuerySafe): _134.MsgModuleQuerySafeProtoMsg;
+                    };
+                    MsgModuleQuerySafeResponse: {
+                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse";
+                        encode(message: _134.MsgModuleQuerySafeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _134.MsgModuleQuerySafeResponse;
+                        fromJSON(object: any): _134.MsgModuleQuerySafeResponse;
+                        toJSON(message: _134.MsgModuleQuerySafeResponse): import("../json-safe.ts").JsonSafe<_134.MsgModuleQuerySafeResponse>;
+                        fromPartial(object: Partial<_134.MsgModuleQuerySafeResponse>): _134.MsgModuleQuerySafeResponse;
+                        fromProtoMsg(message: _134.MsgModuleQuerySafeResponseProtoMsg): _134.MsgModuleQuerySafeResponse;
+                        toProto(message: _134.MsgModuleQuerySafeResponse): Uint8Array;
+                        toProtoMsg(message: _134.MsgModuleQuerySafeResponse): _134.MsgModuleQuerySafeResponseProtoMsg;
+                    };
+                    QueryParamsRequest: {
+                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsRequest";
+                        encode(_: _133.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _133.QueryParamsRequest;
+                        fromJSON(_: any): _133.QueryParamsRequest;
+                        toJSON(_: _133.QueryParamsRequest): import("../json-safe.ts").JsonSafe<_133.QueryParamsRequest>;
+                        fromPartial(_: Partial<_133.QueryParamsRequest>): _133.QueryParamsRequest;
+                        fromProtoMsg(message: _133.QueryParamsRequestProtoMsg): _133.QueryParamsRequest;
+                        toProto(message: _133.QueryParamsRequest): Uint8Array;
+                        toProtoMsg(message: _133.QueryParamsRequest): _133.QueryParamsRequestProtoMsg;
+                    };
+                    QueryParamsResponse: {
+                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsResponse";
+                        encode(message: _133.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _133.QueryParamsResponse;
+                        fromJSON(object: any): _133.QueryParamsResponse;
+                        toJSON(message: _133.QueryParamsResponse): import("../json-safe.ts").JsonSafe<_133.QueryParamsResponse>;
+                        fromPartial(object: Partial<_133.QueryParamsResponse>): _133.QueryParamsResponse;
+                        fromProtoMsg(message: _133.QueryParamsResponseProtoMsg): _133.QueryParamsResponse;
+                        toProto(message: _133.QueryParamsResponse): Uint8Array;
+                        toProtoMsg(message: _133.QueryParamsResponse): _133.QueryParamsResponseProtoMsg;
+                    };
+                    Params: {
+                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.Params";
+                        encode(message: _132.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _132.Params;
+                        fromJSON(object: any): _132.Params;
+                        toJSON(message: _132.Params): import("../json-safe.ts").JsonSafe<_132.Params>;
+                        fromPartial(object: Partial<_132.Params>): _132.Params;
+                        fromProtoMsg(message: _132.ParamsProtoMsg): _132.Params;
+                        toProto(message: _132.Params): Uint8Array;
+                        toProtoMsg(message: _132.Params): _132.ParamsProtoMsg;
+                    };
+                    QueryRequest: {
+                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryRequest";
+                        encode(message: _132.QueryRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _132.QueryRequest;
+                        fromJSON(object: any): _132.QueryRequest;
+                        toJSON(message: _132.QueryRequest): import("../json-safe.ts").JsonSafe<_132.QueryRequest>;
+                        fromPartial(object: Partial<_132.QueryRequest>): _132.QueryRequest;
+                        fromProtoMsg(message: _132.QueryRequestProtoMsg): _132.QueryRequest;
+                        toProto(message: _132.QueryRequest): Uint8Array;
+                        toProtoMsg(message: _132.QueryRequest): _132.QueryRequestProtoMsg;
+                    };
+                };
+            }
+            const v1: {
+                typeFromJSON(object: any): _137.Type;
+                typeToJSON(object: _137.Type): string;
+                Type: typeof _137.Type;
+                TypeSDKType: typeof _137.Type;
+                InterchainAccountPacketData: {
+                    typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccountPacketData";
+                    encode(message: _137.InterchainAccountPacketData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _137.InterchainAccountPacketData;
+                    fromJSON(object: any): _137.InterchainAccountPacketData;
+                    toJSON(message: _137.InterchainAccountPacketData): import("../json-safe.ts").JsonSafe<_137.InterchainAccountPacketData>;
+                    fromPartial(object: Partial<_137.InterchainAccountPacketData>): _137.InterchainAccountPacketData;
+                    fromProtoMsg(message: _137.InterchainAccountPacketDataProtoMsg): _137.InterchainAccountPacketData;
+                    toProto(message: _137.InterchainAccountPacketData): Uint8Array;
+                    toProtoMsg(message: _137.InterchainAccountPacketData): _137.InterchainAccountPacketDataProtoMsg;
+                };
+                CosmosTx: {
+                    typeUrl: "/ibc.applications.interchain_accounts.v1.CosmosTx";
+                    encode(message: _137.CosmosTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _137.CosmosTx;
+                    fromJSON(object: any): _137.CosmosTx;
+                    toJSON(message: _137.CosmosTx): import("../json-safe.ts").JsonSafe<_137.CosmosTx>;
+                    fromPartial(object: Partial<_137.CosmosTx>): _137.CosmosTx;
+                    fromProtoMsg(message: _137.CosmosTxProtoMsg): _137.CosmosTx;
+                    toProto(message: _137.CosmosTx): Uint8Array;
+                    toProtoMsg(message: _137.CosmosTx): _137.CosmosTxProtoMsg;
+                };
+                Metadata: {
+                    typeUrl: "/ibc.applications.interchain_accounts.v1.Metadata";
+                    encode(message: _136.Metadata, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _136.Metadata;
+                    fromJSON(object: any): _136.Metadata;
+                    toJSON(message: _136.Metadata): import("../json-safe.ts").JsonSafe<_136.Metadata>;
+                    fromPartial(object: Partial<_136.Metadata>): _136.Metadata;
+                    fromProtoMsg(message: _136.MetadataProtoMsg): _136.Metadata;
+                    toProto(message: _136.Metadata): Uint8Array;
+                    toProtoMsg(message: _136.Metadata): _136.MetadataProtoMsg;
+                };
+                InterchainAccount: {
+                    typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccount";
+                    encode(message: _135.InterchainAccount, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _135.InterchainAccount;
+                    fromJSON(object: any): _135.InterchainAccount;
+                    toJSON(message: _135.InterchainAccount): import("../json-safe.ts").JsonSafe<_135.InterchainAccount>;
+                    fromPartial(object: Partial<_135.InterchainAccount>): _135.InterchainAccount;
+                    fromProtoMsg(message: _135.InterchainAccountProtoMsg): _135.InterchainAccount;
+                    toProto(message: _135.InterchainAccount): Uint8Array;
+                    toProtoMsg(message: _135.InterchainAccount): _135.InterchainAccountProtoMsg;
+                };
+            };
+        }
+        namespace transfer {
+            const v1: {
+                MsgTransfer: {
+                    typeUrl: "/ibc.applications.transfer.v1.MsgTransfer";
+                    encode(message: _142.MsgTransfer, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _142.MsgTransfer;
+                    fromJSON(object: any): _142.MsgTransfer;
+                    toJSON(message: _142.MsgTransfer): import("../json-safe.ts").JsonSafe<_142.MsgTransfer>;
+                    fromPartial(object: Partial<_142.MsgTransfer>): _142.MsgTransfer;
+                    fromProtoMsg(message: _142.MsgTransferProtoMsg): _142.MsgTransfer;
+                    toProto(message: _142.MsgTransfer): Uint8Array;
+                    toProtoMsg(message: _142.MsgTransfer): _142.MsgTransferProtoMsg;
+                };
+                MsgTransferResponse: {
+                    typeUrl: "/ibc.applications.transfer.v1.MsgTransferResponse";
+                    encode(message: _142.MsgTransferResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _142.MsgTransferResponse;
+                    fromJSON(object: any): _142.MsgTransferResponse;
+                    toJSON(message: _142.MsgTransferResponse): import("../json-safe.ts").JsonSafe<_142.MsgTransferResponse>;
+                    fromPartial(object: Partial<_142.MsgTransferResponse>): _142.MsgTransferResponse;
+                    fromProtoMsg(message: _142.MsgTransferResponseProtoMsg): _142.MsgTransferResponse;
+                    toProto(message: _142.MsgTransferResponse): Uint8Array;
+                    toProtoMsg(message: _142.MsgTransferResponse): _142.MsgTransferResponseProtoMsg;
+                };
+                DenomTrace: {
+                    typeUrl: "/ibc.applications.transfer.v1.DenomTrace";
+                    encode(message: _141.DenomTrace, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _141.DenomTrace;
+                    fromJSON(object: any): _141.DenomTrace;
+                    toJSON(message: _141.DenomTrace): import("../json-safe.ts").JsonSafe<_141.DenomTrace>;
+                    fromPartial(object: Partial<_141.DenomTrace>): _141.DenomTrace;
+                    fromProtoMsg(message: _141.DenomTraceProtoMsg): _141.DenomTrace;
+                    toProto(message: _141.DenomTrace): Uint8Array;
+                    toProtoMsg(message: _141.DenomTrace): _141.DenomTraceProtoMsg;
+                };
+                Params: {
+                    typeUrl: "/ibc.applications.transfer.v1.Params";
+                    encode(message: _141.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _141.Params;
+                    fromJSON(object: any): _141.Params;
+                    toJSON(message: _141.Params): import("../json-safe.ts").JsonSafe<_141.Params>;
+                    fromPartial(object: Partial<_141.Params>): _141.Params;
+                    fromProtoMsg(message: _141.ParamsProtoMsg): _141.Params;
+                    toProto(message: _141.Params): Uint8Array;
+                    toProtoMsg(message: _141.Params): _141.ParamsProtoMsg;
+                };
+                QueryDenomTraceRequest: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTraceRequest";
+                    encode(message: _140.QueryDenomTraceRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryDenomTraceRequest;
+                    fromJSON(object: any): _140.QueryDenomTraceRequest;
+                    toJSON(message: _140.QueryDenomTraceRequest): import("../json-safe.ts").JsonSafe<_140.QueryDenomTraceRequest>;
+                    fromPartial(object: Partial<_140.QueryDenomTraceRequest>): _140.QueryDenomTraceRequest;
+                    fromProtoMsg(message: _140.QueryDenomTraceRequestProtoMsg): _140.QueryDenomTraceRequest;
+                    toProto(message: _140.QueryDenomTraceRequest): Uint8Array;
+                    toProtoMsg(message: _140.QueryDenomTraceRequest): _140.QueryDenomTraceRequestProtoMsg;
+                };
+                QueryDenomTraceResponse: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTraceResponse";
+                    encode(message: _140.QueryDenomTraceResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryDenomTraceResponse;
+                    fromJSON(object: any): _140.QueryDenomTraceResponse;
+                    toJSON(message: _140.QueryDenomTraceResponse): import("../json-safe.ts").JsonSafe<_140.QueryDenomTraceResponse>;
+                    fromPartial(object: Partial<_140.QueryDenomTraceResponse>): _140.QueryDenomTraceResponse;
+                    fromProtoMsg(message: _140.QueryDenomTraceResponseProtoMsg): _140.QueryDenomTraceResponse;
+                    toProto(message: _140.QueryDenomTraceResponse): Uint8Array;
+                    toProtoMsg(message: _140.QueryDenomTraceResponse): _140.QueryDenomTraceResponseProtoMsg;
+                };
+                QueryDenomTracesRequest: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTracesRequest";
+                    encode(message: _140.QueryDenomTracesRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryDenomTracesRequest;
+                    fromJSON(object: any): _140.QueryDenomTracesRequest;
+                    toJSON(message: _140.QueryDenomTracesRequest): import("../json-safe.ts").JsonSafe<_140.QueryDenomTracesRequest>;
+                    fromPartial(object: Partial<_140.QueryDenomTracesRequest>): _140.QueryDenomTracesRequest;
+                    fromProtoMsg(message: _140.QueryDenomTracesRequestProtoMsg): _140.QueryDenomTracesRequest;
+                    toProto(message: _140.QueryDenomTracesRequest): Uint8Array;
+                    toProtoMsg(message: _140.QueryDenomTracesRequest): _140.QueryDenomTracesRequestProtoMsg;
+                };
+                QueryDenomTracesResponse: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTracesResponse";
+                    encode(message: _140.QueryDenomTracesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryDenomTracesResponse;
+                    fromJSON(object: any): _140.QueryDenomTracesResponse;
+                    toJSON(message: _140.QueryDenomTracesResponse): import("../json-safe.ts").JsonSafe<_140.QueryDenomTracesResponse>;
+                    fromPartial(object: Partial<_140.QueryDenomTracesResponse>): _140.QueryDenomTracesResponse;
+                    fromProtoMsg(message: _140.QueryDenomTracesResponseProtoMsg): _140.QueryDenomTracesResponse;
+                    toProto(message: _140.QueryDenomTracesResponse): Uint8Array;
+                    toProtoMsg(message: _140.QueryDenomTracesResponse): _140.QueryDenomTracesResponseProtoMsg;
+                };
+                QueryParamsRequest: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryParamsRequest";
+                    encode(_: _140.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryParamsRequest;
+                    fromJSON(_: any): _140.QueryParamsRequest;
+                    toJSON(_: _140.QueryParamsRequest): import("../json-safe.ts").JsonSafe<_140.QueryParamsRequest>;
+                    fromPartial(_: Partial<_140.QueryParamsRequest>): _140.QueryParamsRequest;
+                    fromProtoMsg(message: _140.QueryParamsRequestProtoMsg): _140.QueryParamsRequest;
+                    toProto(message: _140.QueryParamsRequest): Uint8Array;
+                    toProtoMsg(message: _140.QueryParamsRequest): _140.QueryParamsRequestProtoMsg;
+                };
+                QueryParamsResponse: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryParamsResponse";
+                    encode(message: _140.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryParamsResponse;
+                    fromJSON(object: any): _140.QueryParamsResponse;
+                    toJSON(message: _140.QueryParamsResponse): import("../json-safe.ts").JsonSafe<_140.QueryParamsResponse>;
+                    fromPartial(object: Partial<_140.QueryParamsResponse>): _140.QueryParamsResponse;
+                    fromProtoMsg(message: _140.QueryParamsResponseProtoMsg): _140.QueryParamsResponse;
+                    toProto(message: _140.QueryParamsResponse): Uint8Array;
+                    toProtoMsg(message: _140.QueryParamsResponse): _140.QueryParamsResponseProtoMsg;
+                };
+                QueryDenomHashRequest: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashRequest";
+                    encode(message: _140.QueryDenomHashRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryDenomHashRequest;
+                    fromJSON(object: any): _140.QueryDenomHashRequest;
+                    toJSON(message: _140.QueryDenomHashRequest): import("../json-safe.ts").JsonSafe<_140.QueryDenomHashRequest>;
+                    fromPartial(object: Partial<_140.QueryDenomHashRequest>): _140.QueryDenomHashRequest;
+                    fromProtoMsg(message: _140.QueryDenomHashRequestProtoMsg): _140.QueryDenomHashRequest;
+                    toProto(message: _140.QueryDenomHashRequest): Uint8Array;
+                    toProtoMsg(message: _140.QueryDenomHashRequest): _140.QueryDenomHashRequestProtoMsg;
+                };
+                QueryDenomHashResponse: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashResponse";
+                    encode(message: _140.QueryDenomHashResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryDenomHashResponse;
+                    fromJSON(object: any): _140.QueryDenomHashResponse;
+                    toJSON(message: _140.QueryDenomHashResponse): import("../json-safe.ts").JsonSafe<_140.QueryDenomHashResponse>;
+                    fromPartial(object: Partial<_140.QueryDenomHashResponse>): _140.QueryDenomHashResponse;
+                    fromProtoMsg(message: _140.QueryDenomHashResponseProtoMsg): _140.QueryDenomHashResponse;
+                    toProto(message: _140.QueryDenomHashResponse): Uint8Array;
+                    toProtoMsg(message: _140.QueryDenomHashResponse): _140.QueryDenomHashResponseProtoMsg;
+                };
+                QueryEscrowAddressRequest: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryEscrowAddressRequest";
+                    encode(message: _140.QueryEscrowAddressRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryEscrowAddressRequest;
+                    fromJSON(object: any): _140.QueryEscrowAddressRequest;
+                    toJSON(message: _140.QueryEscrowAddressRequest): import("../json-safe.ts").JsonSafe<_140.QueryEscrowAddressRequest>;
+                    fromPartial(object: Partial<_140.QueryEscrowAddressRequest>): _140.QueryEscrowAddressRequest;
+                    fromProtoMsg(message: _140.QueryEscrowAddressRequestProtoMsg): _140.QueryEscrowAddressRequest;
+                    toProto(message: _140.QueryEscrowAddressRequest): Uint8Array;
+                    toProtoMsg(message: _140.QueryEscrowAddressRequest): _140.QueryEscrowAddressRequestProtoMsg;
+                };
+                QueryEscrowAddressResponse: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryEscrowAddressResponse";
+                    encode(message: _140.QueryEscrowAddressResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryEscrowAddressResponse;
+                    fromJSON(object: any): _140.QueryEscrowAddressResponse;
+                    toJSON(message: _140.QueryEscrowAddressResponse): import("../json-safe.ts").JsonSafe<_140.QueryEscrowAddressResponse>;
+                    fromPartial(object: Partial<_140.QueryEscrowAddressResponse>): _140.QueryEscrowAddressResponse;
+                    fromProtoMsg(message: _140.QueryEscrowAddressResponseProtoMsg): _140.QueryEscrowAddressResponse;
+                    toProto(message: _140.QueryEscrowAddressResponse): Uint8Array;
+                    toProtoMsg(message: _140.QueryEscrowAddressResponse): _140.QueryEscrowAddressResponseProtoMsg;
+                };
+                QueryTotalEscrowForDenomRequest: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest";
+                    encode(message: _140.QueryTotalEscrowForDenomRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryTotalEscrowForDenomRequest;
+                    fromJSON(object: any): _140.QueryTotalEscrowForDenomRequest;
+                    toJSON(message: _140.QueryTotalEscrowForDenomRequest): import("../json-safe.ts").JsonSafe<_140.QueryTotalEscrowForDenomRequest>;
+                    fromPartial(object: Partial<_140.QueryTotalEscrowForDenomRequest>): _140.QueryTotalEscrowForDenomRequest;
+                    fromProtoMsg(message: _140.QueryTotalEscrowForDenomRequestProtoMsg): _140.QueryTotalEscrowForDenomRequest;
+                    toProto(message: _140.QueryTotalEscrowForDenomRequest): Uint8Array;
+                    toProtoMsg(message: _140.QueryTotalEscrowForDenomRequest): _140.QueryTotalEscrowForDenomRequestProtoMsg;
+                };
+                QueryTotalEscrowForDenomResponse: {
+                    typeUrl: "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse";
+                    encode(message: _140.QueryTotalEscrowForDenomResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.QueryTotalEscrowForDenomResponse;
+                    fromJSON(object: any): _140.QueryTotalEscrowForDenomResponse;
+                    toJSON(message: _140.QueryTotalEscrowForDenomResponse): import("../json-safe.ts").JsonSafe<_140.QueryTotalEscrowForDenomResponse>;
+                    fromPartial(object: Partial<_140.QueryTotalEscrowForDenomResponse>): _140.QueryTotalEscrowForDenomResponse;
+                    fromProtoMsg(message: _140.QueryTotalEscrowForDenomResponseProtoMsg): _140.QueryTotalEscrowForDenomResponse;
+                    toProto(message: _140.QueryTotalEscrowForDenomResponse): Uint8Array;
+                    toProtoMsg(message: _140.QueryTotalEscrowForDenomResponse): _140.QueryTotalEscrowForDenomResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: "/ibc.applications.transfer.v1.GenesisState";
+                    encode(message: _139.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _139.GenesisState;
+                    fromJSON(object: any): _139.GenesisState;
+                    toJSON(message: _139.GenesisState): import("../json-safe.ts").JsonSafe<_139.GenesisState>;
+                    fromPartial(object: Partial<_139.GenesisState>): _139.GenesisState;
+                    fromProtoMsg(message: _139.GenesisStateProtoMsg): _139.GenesisState;
+                    toProto(message: _139.GenesisState): Uint8Array;
+                    toProtoMsg(message: _139.GenesisState): _139.GenesisStateProtoMsg;
+                };
+                Allocation: {
+                    typeUrl: "/ibc.applications.transfer.v1.Allocation";
+                    encode(message: _138.Allocation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _138.Allocation;
+                    fromJSON(object: any): _138.Allocation;
+                    toJSON(message: _138.Allocation): import("../json-safe.ts").JsonSafe<_138.Allocation>;
+                    fromPartial(object: Partial<_138.Allocation>): _138.Allocation;
+                    fromProtoMsg(message: _138.AllocationProtoMsg): _138.Allocation;
+                    toProto(message: _138.Allocation): Uint8Array;
+                    toProtoMsg(message: _138.Allocation): _138.AllocationProtoMsg;
+                };
+                TransferAuthorization: {
+                    typeUrl: "/ibc.applications.transfer.v1.TransferAuthorization";
+                    encode(message: _138.TransferAuthorization, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _138.TransferAuthorization;
+                    fromJSON(object: any): _138.TransferAuthorization;
+                    toJSON(message: _138.TransferAuthorization): import("../json-safe.ts").JsonSafe<_138.TransferAuthorization>;
+                    fromPartial(object: Partial<_138.TransferAuthorization>): _138.TransferAuthorization;
+                    fromProtoMsg(message: _138.TransferAuthorizationProtoMsg): _138.TransferAuthorization;
+                    toProto(message: _138.TransferAuthorization): Uint8Array;
+                    toProtoMsg(message: _138.TransferAuthorization): _138.TransferAuthorizationProtoMsg;
+                };
+            };
+            const v2: {
+                FungibleTokenPacketData: {
+                    typeUrl: "/ibc.applications.transfer.v2.FungibleTokenPacketData";
+                    encode(message: _143.FungibleTokenPacketData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _143.FungibleTokenPacketData;
+                    fromJSON(object: any): _143.FungibleTokenPacketData;
+                    toJSON(message: _143.FungibleTokenPacketData): import("../json-safe.ts").JsonSafe<_143.FungibleTokenPacketData>;
+                    fromPartial(object: Partial<_143.FungibleTokenPacketData>): _143.FungibleTokenPacketData;
+                    fromProtoMsg(message: _143.FungibleTokenPacketDataProtoMsg): _143.FungibleTokenPacketData;
+                    toProto(message: _143.FungibleTokenPacketData): Uint8Array;
+                    toProtoMsg(message: _143.FungibleTokenPacketData): _143.FungibleTokenPacketDataProtoMsg;
+                };
+            };
+        }
+    }
     namespace core {
         namespace channel {
             const v1: {
-                stateFromJSON(object: any): _23.State;
-                stateToJSON(object: _23.State): string;
-                orderFromJSON(object: any): _23.Order;
-                orderToJSON(object: _23.Order): string;
-                State: typeof _23.State;
-                StateSDKType: typeof _23.State;
-                StateAmino: typeof _23.State;
-                Order: typeof _23.Order;
-                OrderSDKType: typeof _23.Order;
-                OrderAmino: typeof _23.Order;
+                responseResultTypeFromJSON(object: any): _147.ResponseResultType;
+                responseResultTypeToJSON(object: _147.ResponseResultType): string;
+                ResponseResultType: typeof _147.ResponseResultType;
+                ResponseResultTypeSDKType: typeof _147.ResponseResultType;
+                MsgChannelOpenInit: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenInit";
+                    encode(message: _147.MsgChannelOpenInit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelOpenInit;
+                    fromJSON(object: any): _147.MsgChannelOpenInit;
+                    toJSON(message: _147.MsgChannelOpenInit): import("../json-safe.ts").JsonSafe<_147.MsgChannelOpenInit>;
+                    fromPartial(object: Partial<_147.MsgChannelOpenInit>): _147.MsgChannelOpenInit;
+                    fromProtoMsg(message: _147.MsgChannelOpenInitProtoMsg): _147.MsgChannelOpenInit;
+                    toProto(message: _147.MsgChannelOpenInit): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelOpenInit): _147.MsgChannelOpenInitProtoMsg;
+                };
+                MsgChannelOpenInitResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenInitResponse";
+                    encode(message: _147.MsgChannelOpenInitResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelOpenInitResponse;
+                    fromJSON(object: any): _147.MsgChannelOpenInitResponse;
+                    toJSON(message: _147.MsgChannelOpenInitResponse): import("../json-safe.ts").JsonSafe<_147.MsgChannelOpenInitResponse>;
+                    fromPartial(object: Partial<_147.MsgChannelOpenInitResponse>): _147.MsgChannelOpenInitResponse;
+                    fromProtoMsg(message: _147.MsgChannelOpenInitResponseProtoMsg): _147.MsgChannelOpenInitResponse;
+                    toProto(message: _147.MsgChannelOpenInitResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelOpenInitResponse): _147.MsgChannelOpenInitResponseProtoMsg;
+                };
+                MsgChannelOpenTry: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenTry";
+                    encode(message: _147.MsgChannelOpenTry, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelOpenTry;
+                    fromJSON(object: any): _147.MsgChannelOpenTry;
+                    toJSON(message: _147.MsgChannelOpenTry): import("../json-safe.ts").JsonSafe<_147.MsgChannelOpenTry>;
+                    fromPartial(object: Partial<_147.MsgChannelOpenTry>): _147.MsgChannelOpenTry;
+                    fromProtoMsg(message: _147.MsgChannelOpenTryProtoMsg): _147.MsgChannelOpenTry;
+                    toProto(message: _147.MsgChannelOpenTry): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelOpenTry): _147.MsgChannelOpenTryProtoMsg;
+                };
+                MsgChannelOpenTryResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenTryResponse";
+                    encode(message: _147.MsgChannelOpenTryResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelOpenTryResponse;
+                    fromJSON(object: any): _147.MsgChannelOpenTryResponse;
+                    toJSON(message: _147.MsgChannelOpenTryResponse): import("../json-safe.ts").JsonSafe<_147.MsgChannelOpenTryResponse>;
+                    fromPartial(object: Partial<_147.MsgChannelOpenTryResponse>): _147.MsgChannelOpenTryResponse;
+                    fromProtoMsg(message: _147.MsgChannelOpenTryResponseProtoMsg): _147.MsgChannelOpenTryResponse;
+                    toProto(message: _147.MsgChannelOpenTryResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelOpenTryResponse): _147.MsgChannelOpenTryResponseProtoMsg;
+                };
+                MsgChannelOpenAck: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenAck";
+                    encode(message: _147.MsgChannelOpenAck, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelOpenAck;
+                    fromJSON(object: any): _147.MsgChannelOpenAck;
+                    toJSON(message: _147.MsgChannelOpenAck): import("../json-safe.ts").JsonSafe<_147.MsgChannelOpenAck>;
+                    fromPartial(object: Partial<_147.MsgChannelOpenAck>): _147.MsgChannelOpenAck;
+                    fromProtoMsg(message: _147.MsgChannelOpenAckProtoMsg): _147.MsgChannelOpenAck;
+                    toProto(message: _147.MsgChannelOpenAck): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelOpenAck): _147.MsgChannelOpenAckProtoMsg;
+                };
+                MsgChannelOpenAckResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenAckResponse";
+                    encode(_: _147.MsgChannelOpenAckResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelOpenAckResponse;
+                    fromJSON(_: any): _147.MsgChannelOpenAckResponse;
+                    toJSON(_: _147.MsgChannelOpenAckResponse): import("../json-safe.ts").JsonSafe<_147.MsgChannelOpenAckResponse>;
+                    fromPartial(_: Partial<_147.MsgChannelOpenAckResponse>): _147.MsgChannelOpenAckResponse;
+                    fromProtoMsg(message: _147.MsgChannelOpenAckResponseProtoMsg): _147.MsgChannelOpenAckResponse;
+                    toProto(message: _147.MsgChannelOpenAckResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelOpenAckResponse): _147.MsgChannelOpenAckResponseProtoMsg;
+                };
+                MsgChannelOpenConfirm: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenConfirm";
+                    encode(message: _147.MsgChannelOpenConfirm, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelOpenConfirm;
+                    fromJSON(object: any): _147.MsgChannelOpenConfirm;
+                    toJSON(message: _147.MsgChannelOpenConfirm): import("../json-safe.ts").JsonSafe<_147.MsgChannelOpenConfirm>;
+                    fromPartial(object: Partial<_147.MsgChannelOpenConfirm>): _147.MsgChannelOpenConfirm;
+                    fromProtoMsg(message: _147.MsgChannelOpenConfirmProtoMsg): _147.MsgChannelOpenConfirm;
+                    toProto(message: _147.MsgChannelOpenConfirm): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelOpenConfirm): _147.MsgChannelOpenConfirmProtoMsg;
+                };
+                MsgChannelOpenConfirmResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenConfirmResponse";
+                    encode(_: _147.MsgChannelOpenConfirmResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelOpenConfirmResponse;
+                    fromJSON(_: any): _147.MsgChannelOpenConfirmResponse;
+                    toJSON(_: _147.MsgChannelOpenConfirmResponse): import("../json-safe.ts").JsonSafe<_147.MsgChannelOpenConfirmResponse>;
+                    fromPartial(_: Partial<_147.MsgChannelOpenConfirmResponse>): _147.MsgChannelOpenConfirmResponse;
+                    fromProtoMsg(message: _147.MsgChannelOpenConfirmResponseProtoMsg): _147.MsgChannelOpenConfirmResponse;
+                    toProto(message: _147.MsgChannelOpenConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelOpenConfirmResponse): _147.MsgChannelOpenConfirmResponseProtoMsg;
+                };
+                MsgChannelCloseInit: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelCloseInit";
+                    encode(message: _147.MsgChannelCloseInit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelCloseInit;
+                    fromJSON(object: any): _147.MsgChannelCloseInit;
+                    toJSON(message: _147.MsgChannelCloseInit): import("../json-safe.ts").JsonSafe<_147.MsgChannelCloseInit>;
+                    fromPartial(object: Partial<_147.MsgChannelCloseInit>): _147.MsgChannelCloseInit;
+                    fromProtoMsg(message: _147.MsgChannelCloseInitProtoMsg): _147.MsgChannelCloseInit;
+                    toProto(message: _147.MsgChannelCloseInit): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelCloseInit): _147.MsgChannelCloseInitProtoMsg;
+                };
+                MsgChannelCloseInitResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelCloseInitResponse";
+                    encode(_: _147.MsgChannelCloseInitResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelCloseInitResponse;
+                    fromJSON(_: any): _147.MsgChannelCloseInitResponse;
+                    toJSON(_: _147.MsgChannelCloseInitResponse): import("../json-safe.ts").JsonSafe<_147.MsgChannelCloseInitResponse>;
+                    fromPartial(_: Partial<_147.MsgChannelCloseInitResponse>): _147.MsgChannelCloseInitResponse;
+                    fromProtoMsg(message: _147.MsgChannelCloseInitResponseProtoMsg): _147.MsgChannelCloseInitResponse;
+                    toProto(message: _147.MsgChannelCloseInitResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelCloseInitResponse): _147.MsgChannelCloseInitResponseProtoMsg;
+                };
+                MsgChannelCloseConfirm: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelCloseConfirm";
+                    encode(message: _147.MsgChannelCloseConfirm, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelCloseConfirm;
+                    fromJSON(object: any): _147.MsgChannelCloseConfirm;
+                    toJSON(message: _147.MsgChannelCloseConfirm): import("../json-safe.ts").JsonSafe<_147.MsgChannelCloseConfirm>;
+                    fromPartial(object: Partial<_147.MsgChannelCloseConfirm>): _147.MsgChannelCloseConfirm;
+                    fromProtoMsg(message: _147.MsgChannelCloseConfirmProtoMsg): _147.MsgChannelCloseConfirm;
+                    toProto(message: _147.MsgChannelCloseConfirm): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelCloseConfirm): _147.MsgChannelCloseConfirmProtoMsg;
+                };
+                MsgChannelCloseConfirmResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgChannelCloseConfirmResponse";
+                    encode(_: _147.MsgChannelCloseConfirmResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgChannelCloseConfirmResponse;
+                    fromJSON(_: any): _147.MsgChannelCloseConfirmResponse;
+                    toJSON(_: _147.MsgChannelCloseConfirmResponse): import("../json-safe.ts").JsonSafe<_147.MsgChannelCloseConfirmResponse>;
+                    fromPartial(_: Partial<_147.MsgChannelCloseConfirmResponse>): _147.MsgChannelCloseConfirmResponse;
+                    fromProtoMsg(message: _147.MsgChannelCloseConfirmResponseProtoMsg): _147.MsgChannelCloseConfirmResponse;
+                    toProto(message: _147.MsgChannelCloseConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgChannelCloseConfirmResponse): _147.MsgChannelCloseConfirmResponseProtoMsg;
+                };
+                MsgRecvPacket: {
+                    typeUrl: "/ibc.core.channel.v1.MsgRecvPacket";
+                    encode(message: _147.MsgRecvPacket, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgRecvPacket;
+                    fromJSON(object: any): _147.MsgRecvPacket;
+                    toJSON(message: _147.MsgRecvPacket): import("../json-safe.ts").JsonSafe<_147.MsgRecvPacket>;
+                    fromPartial(object: Partial<_147.MsgRecvPacket>): _147.MsgRecvPacket;
+                    fromProtoMsg(message: _147.MsgRecvPacketProtoMsg): _147.MsgRecvPacket;
+                    toProto(message: _147.MsgRecvPacket): Uint8Array;
+                    toProtoMsg(message: _147.MsgRecvPacket): _147.MsgRecvPacketProtoMsg;
+                };
+                MsgRecvPacketResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgRecvPacketResponse";
+                    encode(message: _147.MsgRecvPacketResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgRecvPacketResponse;
+                    fromJSON(object: any): _147.MsgRecvPacketResponse;
+                    toJSON(message: _147.MsgRecvPacketResponse): import("../json-safe.ts").JsonSafe<_147.MsgRecvPacketResponse>;
+                    fromPartial(object: Partial<_147.MsgRecvPacketResponse>): _147.MsgRecvPacketResponse;
+                    fromProtoMsg(message: _147.MsgRecvPacketResponseProtoMsg): _147.MsgRecvPacketResponse;
+                    toProto(message: _147.MsgRecvPacketResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgRecvPacketResponse): _147.MsgRecvPacketResponseProtoMsg;
+                };
+                MsgTimeout: {
+                    typeUrl: "/ibc.core.channel.v1.MsgTimeout";
+                    encode(message: _147.MsgTimeout, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgTimeout;
+                    fromJSON(object: any): _147.MsgTimeout;
+                    toJSON(message: _147.MsgTimeout): import("../json-safe.ts").JsonSafe<_147.MsgTimeout>;
+                    fromPartial(object: Partial<_147.MsgTimeout>): _147.MsgTimeout;
+                    fromProtoMsg(message: _147.MsgTimeoutProtoMsg): _147.MsgTimeout;
+                    toProto(message: _147.MsgTimeout): Uint8Array;
+                    toProtoMsg(message: _147.MsgTimeout): _147.MsgTimeoutProtoMsg;
+                };
+                MsgTimeoutResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgTimeoutResponse";
+                    encode(message: _147.MsgTimeoutResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgTimeoutResponse;
+                    fromJSON(object: any): _147.MsgTimeoutResponse;
+                    toJSON(message: _147.MsgTimeoutResponse): import("../json-safe.ts").JsonSafe<_147.MsgTimeoutResponse>;
+                    fromPartial(object: Partial<_147.MsgTimeoutResponse>): _147.MsgTimeoutResponse;
+                    fromProtoMsg(message: _147.MsgTimeoutResponseProtoMsg): _147.MsgTimeoutResponse;
+                    toProto(message: _147.MsgTimeoutResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgTimeoutResponse): _147.MsgTimeoutResponseProtoMsg;
+                };
+                MsgTimeoutOnClose: {
+                    typeUrl: "/ibc.core.channel.v1.MsgTimeoutOnClose";
+                    encode(message: _147.MsgTimeoutOnClose, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgTimeoutOnClose;
+                    fromJSON(object: any): _147.MsgTimeoutOnClose;
+                    toJSON(message: _147.MsgTimeoutOnClose): import("../json-safe.ts").JsonSafe<_147.MsgTimeoutOnClose>;
+                    fromPartial(object: Partial<_147.MsgTimeoutOnClose>): _147.MsgTimeoutOnClose;
+                    fromProtoMsg(message: _147.MsgTimeoutOnCloseProtoMsg): _147.MsgTimeoutOnClose;
+                    toProto(message: _147.MsgTimeoutOnClose): Uint8Array;
+                    toProtoMsg(message: _147.MsgTimeoutOnClose): _147.MsgTimeoutOnCloseProtoMsg;
+                };
+                MsgTimeoutOnCloseResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgTimeoutOnCloseResponse";
+                    encode(message: _147.MsgTimeoutOnCloseResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgTimeoutOnCloseResponse;
+                    fromJSON(object: any): _147.MsgTimeoutOnCloseResponse;
+                    toJSON(message: _147.MsgTimeoutOnCloseResponse): import("../json-safe.ts").JsonSafe<_147.MsgTimeoutOnCloseResponse>;
+                    fromPartial(object: Partial<_147.MsgTimeoutOnCloseResponse>): _147.MsgTimeoutOnCloseResponse;
+                    fromProtoMsg(message: _147.MsgTimeoutOnCloseResponseProtoMsg): _147.MsgTimeoutOnCloseResponse;
+                    toProto(message: _147.MsgTimeoutOnCloseResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgTimeoutOnCloseResponse): _147.MsgTimeoutOnCloseResponseProtoMsg;
+                };
+                MsgAcknowledgement: {
+                    typeUrl: "/ibc.core.channel.v1.MsgAcknowledgement";
+                    encode(message: _147.MsgAcknowledgement, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgAcknowledgement;
+                    fromJSON(object: any): _147.MsgAcknowledgement;
+                    toJSON(message: _147.MsgAcknowledgement): import("../json-safe.ts").JsonSafe<_147.MsgAcknowledgement>;
+                    fromPartial(object: Partial<_147.MsgAcknowledgement>): _147.MsgAcknowledgement;
+                    fromProtoMsg(message: _147.MsgAcknowledgementProtoMsg): _147.MsgAcknowledgement;
+                    toProto(message: _147.MsgAcknowledgement): Uint8Array;
+                    toProtoMsg(message: _147.MsgAcknowledgement): _147.MsgAcknowledgementProtoMsg;
+                };
+                MsgAcknowledgementResponse: {
+                    typeUrl: "/ibc.core.channel.v1.MsgAcknowledgementResponse";
+                    encode(message: _147.MsgAcknowledgementResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.MsgAcknowledgementResponse;
+                    fromJSON(object: any): _147.MsgAcknowledgementResponse;
+                    toJSON(message: _147.MsgAcknowledgementResponse): import("../json-safe.ts").JsonSafe<_147.MsgAcknowledgementResponse>;
+                    fromPartial(object: Partial<_147.MsgAcknowledgementResponse>): _147.MsgAcknowledgementResponse;
+                    fromProtoMsg(message: _147.MsgAcknowledgementResponseProtoMsg): _147.MsgAcknowledgementResponse;
+                    toProto(message: _147.MsgAcknowledgementResponse): Uint8Array;
+                    toProtoMsg(message: _147.MsgAcknowledgementResponse): _147.MsgAcknowledgementResponseProtoMsg;
+                };
+                QueryChannelRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryChannelRequest";
+                    encode(message: _146.QueryChannelRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryChannelRequest;
+                    fromJSON(object: any): _146.QueryChannelRequest;
+                    toJSON(message: _146.QueryChannelRequest): import("../json-safe.ts").JsonSafe<_146.QueryChannelRequest>;
+                    fromPartial(object: Partial<_146.QueryChannelRequest>): _146.QueryChannelRequest;
+                    fromProtoMsg(message: _146.QueryChannelRequestProtoMsg): _146.QueryChannelRequest;
+                    toProto(message: _146.QueryChannelRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryChannelRequest): _146.QueryChannelRequestProtoMsg;
+                };
+                QueryChannelResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryChannelResponse";
+                    encode(message: _146.QueryChannelResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryChannelResponse;
+                    fromJSON(object: any): _146.QueryChannelResponse;
+                    toJSON(message: _146.QueryChannelResponse): import("../json-safe.ts").JsonSafe<_146.QueryChannelResponse>;
+                    fromPartial(object: Partial<_146.QueryChannelResponse>): _146.QueryChannelResponse;
+                    fromProtoMsg(message: _146.QueryChannelResponseProtoMsg): _146.QueryChannelResponse;
+                    toProto(message: _146.QueryChannelResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryChannelResponse): _146.QueryChannelResponseProtoMsg;
+                };
+                QueryChannelsRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryChannelsRequest";
+                    encode(message: _146.QueryChannelsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryChannelsRequest;
+                    fromJSON(object: any): _146.QueryChannelsRequest;
+                    toJSON(message: _146.QueryChannelsRequest): import("../json-safe.ts").JsonSafe<_146.QueryChannelsRequest>;
+                    fromPartial(object: Partial<_146.QueryChannelsRequest>): _146.QueryChannelsRequest;
+                    fromProtoMsg(message: _146.QueryChannelsRequestProtoMsg): _146.QueryChannelsRequest;
+                    toProto(message: _146.QueryChannelsRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryChannelsRequest): _146.QueryChannelsRequestProtoMsg;
+                };
+                QueryChannelsResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryChannelsResponse";
+                    encode(message: _146.QueryChannelsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryChannelsResponse;
+                    fromJSON(object: any): _146.QueryChannelsResponse;
+                    toJSON(message: _146.QueryChannelsResponse): import("../json-safe.ts").JsonSafe<_146.QueryChannelsResponse>;
+                    fromPartial(object: Partial<_146.QueryChannelsResponse>): _146.QueryChannelsResponse;
+                    fromProtoMsg(message: _146.QueryChannelsResponseProtoMsg): _146.QueryChannelsResponse;
+                    toProto(message: _146.QueryChannelsResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryChannelsResponse): _146.QueryChannelsResponseProtoMsg;
+                };
+                QueryConnectionChannelsRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryConnectionChannelsRequest";
+                    encode(message: _146.QueryConnectionChannelsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryConnectionChannelsRequest;
+                    fromJSON(object: any): _146.QueryConnectionChannelsRequest;
+                    toJSON(message: _146.QueryConnectionChannelsRequest): import("../json-safe.ts").JsonSafe<_146.QueryConnectionChannelsRequest>;
+                    fromPartial(object: Partial<_146.QueryConnectionChannelsRequest>): _146.QueryConnectionChannelsRequest;
+                    fromProtoMsg(message: _146.QueryConnectionChannelsRequestProtoMsg): _146.QueryConnectionChannelsRequest;
+                    toProto(message: _146.QueryConnectionChannelsRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryConnectionChannelsRequest): _146.QueryConnectionChannelsRequestProtoMsg;
+                };
+                QueryConnectionChannelsResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryConnectionChannelsResponse";
+                    encode(message: _146.QueryConnectionChannelsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryConnectionChannelsResponse;
+                    fromJSON(object: any): _146.QueryConnectionChannelsResponse;
+                    toJSON(message: _146.QueryConnectionChannelsResponse): import("../json-safe.ts").JsonSafe<_146.QueryConnectionChannelsResponse>;
+                    fromPartial(object: Partial<_146.QueryConnectionChannelsResponse>): _146.QueryConnectionChannelsResponse;
+                    fromProtoMsg(message: _146.QueryConnectionChannelsResponseProtoMsg): _146.QueryConnectionChannelsResponse;
+                    toProto(message: _146.QueryConnectionChannelsResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryConnectionChannelsResponse): _146.QueryConnectionChannelsResponseProtoMsg;
+                };
+                QueryChannelClientStateRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryChannelClientStateRequest";
+                    encode(message: _146.QueryChannelClientStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryChannelClientStateRequest;
+                    fromJSON(object: any): _146.QueryChannelClientStateRequest;
+                    toJSON(message: _146.QueryChannelClientStateRequest): import("../json-safe.ts").JsonSafe<_146.QueryChannelClientStateRequest>;
+                    fromPartial(object: Partial<_146.QueryChannelClientStateRequest>): _146.QueryChannelClientStateRequest;
+                    fromProtoMsg(message: _146.QueryChannelClientStateRequestProtoMsg): _146.QueryChannelClientStateRequest;
+                    toProto(message: _146.QueryChannelClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryChannelClientStateRequest): _146.QueryChannelClientStateRequestProtoMsg;
+                };
+                QueryChannelClientStateResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryChannelClientStateResponse";
+                    encode(message: _146.QueryChannelClientStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryChannelClientStateResponse;
+                    fromJSON(object: any): _146.QueryChannelClientStateResponse;
+                    toJSON(message: _146.QueryChannelClientStateResponse): import("../json-safe.ts").JsonSafe<_146.QueryChannelClientStateResponse>;
+                    fromPartial(object: Partial<_146.QueryChannelClientStateResponse>): _146.QueryChannelClientStateResponse;
+                    fromProtoMsg(message: _146.QueryChannelClientStateResponseProtoMsg): _146.QueryChannelClientStateResponse;
+                    toProto(message: _146.QueryChannelClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryChannelClientStateResponse): _146.QueryChannelClientStateResponseProtoMsg;
+                };
+                QueryChannelConsensusStateRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryChannelConsensusStateRequest";
+                    encode(message: _146.QueryChannelConsensusStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryChannelConsensusStateRequest;
+                    fromJSON(object: any): _146.QueryChannelConsensusStateRequest;
+                    toJSON(message: _146.QueryChannelConsensusStateRequest): import("../json-safe.ts").JsonSafe<_146.QueryChannelConsensusStateRequest>;
+                    fromPartial(object: Partial<_146.QueryChannelConsensusStateRequest>): _146.QueryChannelConsensusStateRequest;
+                    fromProtoMsg(message: _146.QueryChannelConsensusStateRequestProtoMsg): _146.QueryChannelConsensusStateRequest;
+                    toProto(message: _146.QueryChannelConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryChannelConsensusStateRequest): _146.QueryChannelConsensusStateRequestProtoMsg;
+                };
+                QueryChannelConsensusStateResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryChannelConsensusStateResponse";
+                    encode(message: _146.QueryChannelConsensusStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryChannelConsensusStateResponse;
+                    fromJSON(object: any): _146.QueryChannelConsensusStateResponse;
+                    toJSON(message: _146.QueryChannelConsensusStateResponse): import("../json-safe.ts").JsonSafe<_146.QueryChannelConsensusStateResponse>;
+                    fromPartial(object: Partial<_146.QueryChannelConsensusStateResponse>): _146.QueryChannelConsensusStateResponse;
+                    fromProtoMsg(message: _146.QueryChannelConsensusStateResponseProtoMsg): _146.QueryChannelConsensusStateResponse;
+                    toProto(message: _146.QueryChannelConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryChannelConsensusStateResponse): _146.QueryChannelConsensusStateResponseProtoMsg;
+                };
+                QueryPacketCommitmentRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketCommitmentRequest";
+                    encode(message: _146.QueryPacketCommitmentRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketCommitmentRequest;
+                    fromJSON(object: any): _146.QueryPacketCommitmentRequest;
+                    toJSON(message: _146.QueryPacketCommitmentRequest): import("../json-safe.ts").JsonSafe<_146.QueryPacketCommitmentRequest>;
+                    fromPartial(object: Partial<_146.QueryPacketCommitmentRequest>): _146.QueryPacketCommitmentRequest;
+                    fromProtoMsg(message: _146.QueryPacketCommitmentRequestProtoMsg): _146.QueryPacketCommitmentRequest;
+                    toProto(message: _146.QueryPacketCommitmentRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketCommitmentRequest): _146.QueryPacketCommitmentRequestProtoMsg;
+                };
+                QueryPacketCommitmentResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketCommitmentResponse";
+                    encode(message: _146.QueryPacketCommitmentResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketCommitmentResponse;
+                    fromJSON(object: any): _146.QueryPacketCommitmentResponse;
+                    toJSON(message: _146.QueryPacketCommitmentResponse): import("../json-safe.ts").JsonSafe<_146.QueryPacketCommitmentResponse>;
+                    fromPartial(object: Partial<_146.QueryPacketCommitmentResponse>): _146.QueryPacketCommitmentResponse;
+                    fromProtoMsg(message: _146.QueryPacketCommitmentResponseProtoMsg): _146.QueryPacketCommitmentResponse;
+                    toProto(message: _146.QueryPacketCommitmentResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketCommitmentResponse): _146.QueryPacketCommitmentResponseProtoMsg;
+                };
+                QueryPacketCommitmentsRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketCommitmentsRequest";
+                    encode(message: _146.QueryPacketCommitmentsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketCommitmentsRequest;
+                    fromJSON(object: any): _146.QueryPacketCommitmentsRequest;
+                    toJSON(message: _146.QueryPacketCommitmentsRequest): import("../json-safe.ts").JsonSafe<_146.QueryPacketCommitmentsRequest>;
+                    fromPartial(object: Partial<_146.QueryPacketCommitmentsRequest>): _146.QueryPacketCommitmentsRequest;
+                    fromProtoMsg(message: _146.QueryPacketCommitmentsRequestProtoMsg): _146.QueryPacketCommitmentsRequest;
+                    toProto(message: _146.QueryPacketCommitmentsRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketCommitmentsRequest): _146.QueryPacketCommitmentsRequestProtoMsg;
+                };
+                QueryPacketCommitmentsResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketCommitmentsResponse";
+                    encode(message: _146.QueryPacketCommitmentsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketCommitmentsResponse;
+                    fromJSON(object: any): _146.QueryPacketCommitmentsResponse;
+                    toJSON(message: _146.QueryPacketCommitmentsResponse): import("../json-safe.ts").JsonSafe<_146.QueryPacketCommitmentsResponse>;
+                    fromPartial(object: Partial<_146.QueryPacketCommitmentsResponse>): _146.QueryPacketCommitmentsResponse;
+                    fromProtoMsg(message: _146.QueryPacketCommitmentsResponseProtoMsg): _146.QueryPacketCommitmentsResponse;
+                    toProto(message: _146.QueryPacketCommitmentsResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketCommitmentsResponse): _146.QueryPacketCommitmentsResponseProtoMsg;
+                };
+                QueryPacketReceiptRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketReceiptRequest";
+                    encode(message: _146.QueryPacketReceiptRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketReceiptRequest;
+                    fromJSON(object: any): _146.QueryPacketReceiptRequest;
+                    toJSON(message: _146.QueryPacketReceiptRequest): import("../json-safe.ts").JsonSafe<_146.QueryPacketReceiptRequest>;
+                    fromPartial(object: Partial<_146.QueryPacketReceiptRequest>): _146.QueryPacketReceiptRequest;
+                    fromProtoMsg(message: _146.QueryPacketReceiptRequestProtoMsg): _146.QueryPacketReceiptRequest;
+                    toProto(message: _146.QueryPacketReceiptRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketReceiptRequest): _146.QueryPacketReceiptRequestProtoMsg;
+                };
+                QueryPacketReceiptResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketReceiptResponse";
+                    encode(message: _146.QueryPacketReceiptResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketReceiptResponse;
+                    fromJSON(object: any): _146.QueryPacketReceiptResponse;
+                    toJSON(message: _146.QueryPacketReceiptResponse): import("../json-safe.ts").JsonSafe<_146.QueryPacketReceiptResponse>;
+                    fromPartial(object: Partial<_146.QueryPacketReceiptResponse>): _146.QueryPacketReceiptResponse;
+                    fromProtoMsg(message: _146.QueryPacketReceiptResponseProtoMsg): _146.QueryPacketReceiptResponse;
+                    toProto(message: _146.QueryPacketReceiptResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketReceiptResponse): _146.QueryPacketReceiptResponseProtoMsg;
+                };
+                QueryPacketAcknowledgementRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketAcknowledgementRequest";
+                    encode(message: _146.QueryPacketAcknowledgementRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketAcknowledgementRequest;
+                    fromJSON(object: any): _146.QueryPacketAcknowledgementRequest;
+                    toJSON(message: _146.QueryPacketAcknowledgementRequest): import("../json-safe.ts").JsonSafe<_146.QueryPacketAcknowledgementRequest>;
+                    fromPartial(object: Partial<_146.QueryPacketAcknowledgementRequest>): _146.QueryPacketAcknowledgementRequest;
+                    fromProtoMsg(message: _146.QueryPacketAcknowledgementRequestProtoMsg): _146.QueryPacketAcknowledgementRequest;
+                    toProto(message: _146.QueryPacketAcknowledgementRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketAcknowledgementRequest): _146.QueryPacketAcknowledgementRequestProtoMsg;
+                };
+                QueryPacketAcknowledgementResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketAcknowledgementResponse";
+                    encode(message: _146.QueryPacketAcknowledgementResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketAcknowledgementResponse;
+                    fromJSON(object: any): _146.QueryPacketAcknowledgementResponse;
+                    toJSON(message: _146.QueryPacketAcknowledgementResponse): import("../json-safe.ts").JsonSafe<_146.QueryPacketAcknowledgementResponse>;
+                    fromPartial(object: Partial<_146.QueryPacketAcknowledgementResponse>): _146.QueryPacketAcknowledgementResponse;
+                    fromProtoMsg(message: _146.QueryPacketAcknowledgementResponseProtoMsg): _146.QueryPacketAcknowledgementResponse;
+                    toProto(message: _146.QueryPacketAcknowledgementResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketAcknowledgementResponse): _146.QueryPacketAcknowledgementResponseProtoMsg;
+                };
+                QueryPacketAcknowledgementsRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketAcknowledgementsRequest";
+                    encode(message: _146.QueryPacketAcknowledgementsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketAcknowledgementsRequest;
+                    fromJSON(object: any): _146.QueryPacketAcknowledgementsRequest;
+                    toJSON(message: _146.QueryPacketAcknowledgementsRequest): import("../json-safe.ts").JsonSafe<_146.QueryPacketAcknowledgementsRequest>;
+                    fromPartial(object: Partial<_146.QueryPacketAcknowledgementsRequest>): _146.QueryPacketAcknowledgementsRequest;
+                    fromProtoMsg(message: _146.QueryPacketAcknowledgementsRequestProtoMsg): _146.QueryPacketAcknowledgementsRequest;
+                    toProto(message: _146.QueryPacketAcknowledgementsRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketAcknowledgementsRequest): _146.QueryPacketAcknowledgementsRequestProtoMsg;
+                };
+                QueryPacketAcknowledgementsResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryPacketAcknowledgementsResponse";
+                    encode(message: _146.QueryPacketAcknowledgementsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryPacketAcknowledgementsResponse;
+                    fromJSON(object: any): _146.QueryPacketAcknowledgementsResponse;
+                    toJSON(message: _146.QueryPacketAcknowledgementsResponse): import("../json-safe.ts").JsonSafe<_146.QueryPacketAcknowledgementsResponse>;
+                    fromPartial(object: Partial<_146.QueryPacketAcknowledgementsResponse>): _146.QueryPacketAcknowledgementsResponse;
+                    fromProtoMsg(message: _146.QueryPacketAcknowledgementsResponseProtoMsg): _146.QueryPacketAcknowledgementsResponse;
+                    toProto(message: _146.QueryPacketAcknowledgementsResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryPacketAcknowledgementsResponse): _146.QueryPacketAcknowledgementsResponseProtoMsg;
+                };
+                QueryUnreceivedPacketsRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryUnreceivedPacketsRequest";
+                    encode(message: _146.QueryUnreceivedPacketsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryUnreceivedPacketsRequest;
+                    fromJSON(object: any): _146.QueryUnreceivedPacketsRequest;
+                    toJSON(message: _146.QueryUnreceivedPacketsRequest): import("../json-safe.ts").JsonSafe<_146.QueryUnreceivedPacketsRequest>;
+                    fromPartial(object: Partial<_146.QueryUnreceivedPacketsRequest>): _146.QueryUnreceivedPacketsRequest;
+                    fromProtoMsg(message: _146.QueryUnreceivedPacketsRequestProtoMsg): _146.QueryUnreceivedPacketsRequest;
+                    toProto(message: _146.QueryUnreceivedPacketsRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryUnreceivedPacketsRequest): _146.QueryUnreceivedPacketsRequestProtoMsg;
+                };
+                QueryUnreceivedPacketsResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryUnreceivedPacketsResponse";
+                    encode(message: _146.QueryUnreceivedPacketsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryUnreceivedPacketsResponse;
+                    fromJSON(object: any): _146.QueryUnreceivedPacketsResponse;
+                    toJSON(message: _146.QueryUnreceivedPacketsResponse): import("../json-safe.ts").JsonSafe<_146.QueryUnreceivedPacketsResponse>;
+                    fromPartial(object: Partial<_146.QueryUnreceivedPacketsResponse>): _146.QueryUnreceivedPacketsResponse;
+                    fromProtoMsg(message: _146.QueryUnreceivedPacketsResponseProtoMsg): _146.QueryUnreceivedPacketsResponse;
+                    toProto(message: _146.QueryUnreceivedPacketsResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryUnreceivedPacketsResponse): _146.QueryUnreceivedPacketsResponseProtoMsg;
+                };
+                QueryUnreceivedAcksRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryUnreceivedAcksRequest";
+                    encode(message: _146.QueryUnreceivedAcksRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryUnreceivedAcksRequest;
+                    fromJSON(object: any): _146.QueryUnreceivedAcksRequest;
+                    toJSON(message: _146.QueryUnreceivedAcksRequest): import("../json-safe.ts").JsonSafe<_146.QueryUnreceivedAcksRequest>;
+                    fromPartial(object: Partial<_146.QueryUnreceivedAcksRequest>): _146.QueryUnreceivedAcksRequest;
+                    fromProtoMsg(message: _146.QueryUnreceivedAcksRequestProtoMsg): _146.QueryUnreceivedAcksRequest;
+                    toProto(message: _146.QueryUnreceivedAcksRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryUnreceivedAcksRequest): _146.QueryUnreceivedAcksRequestProtoMsg;
+                };
+                QueryUnreceivedAcksResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryUnreceivedAcksResponse";
+                    encode(message: _146.QueryUnreceivedAcksResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryUnreceivedAcksResponse;
+                    fromJSON(object: any): _146.QueryUnreceivedAcksResponse;
+                    toJSON(message: _146.QueryUnreceivedAcksResponse): import("../json-safe.ts").JsonSafe<_146.QueryUnreceivedAcksResponse>;
+                    fromPartial(object: Partial<_146.QueryUnreceivedAcksResponse>): _146.QueryUnreceivedAcksResponse;
+                    fromProtoMsg(message: _146.QueryUnreceivedAcksResponseProtoMsg): _146.QueryUnreceivedAcksResponse;
+                    toProto(message: _146.QueryUnreceivedAcksResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryUnreceivedAcksResponse): _146.QueryUnreceivedAcksResponseProtoMsg;
+                };
+                QueryNextSequenceReceiveRequest: {
+                    typeUrl: "/ibc.core.channel.v1.QueryNextSequenceReceiveRequest";
+                    encode(message: _146.QueryNextSequenceReceiveRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryNextSequenceReceiveRequest;
+                    fromJSON(object: any): _146.QueryNextSequenceReceiveRequest;
+                    toJSON(message: _146.QueryNextSequenceReceiveRequest): import("../json-safe.ts").JsonSafe<_146.QueryNextSequenceReceiveRequest>;
+                    fromPartial(object: Partial<_146.QueryNextSequenceReceiveRequest>): _146.QueryNextSequenceReceiveRequest;
+                    fromProtoMsg(message: _146.QueryNextSequenceReceiveRequestProtoMsg): _146.QueryNextSequenceReceiveRequest;
+                    toProto(message: _146.QueryNextSequenceReceiveRequest): Uint8Array;
+                    toProtoMsg(message: _146.QueryNextSequenceReceiveRequest): _146.QueryNextSequenceReceiveRequestProtoMsg;
+                };
+                QueryNextSequenceReceiveResponse: {
+                    typeUrl: "/ibc.core.channel.v1.QueryNextSequenceReceiveResponse";
+                    encode(message: _146.QueryNextSequenceReceiveResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.QueryNextSequenceReceiveResponse;
+                    fromJSON(object: any): _146.QueryNextSequenceReceiveResponse;
+                    toJSON(message: _146.QueryNextSequenceReceiveResponse): import("../json-safe.ts").JsonSafe<_146.QueryNextSequenceReceiveResponse>;
+                    fromPartial(object: Partial<_146.QueryNextSequenceReceiveResponse>): _146.QueryNextSequenceReceiveResponse;
+                    fromProtoMsg(message: _146.QueryNextSequenceReceiveResponseProtoMsg): _146.QueryNextSequenceReceiveResponse;
+                    toProto(message: _146.QueryNextSequenceReceiveResponse): Uint8Array;
+                    toProtoMsg(message: _146.QueryNextSequenceReceiveResponse): _146.QueryNextSequenceReceiveResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: "/ibc.core.channel.v1.GenesisState";
+                    encode(message: _145.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _145.GenesisState;
+                    fromJSON(object: any): _145.GenesisState;
+                    toJSON(message: _145.GenesisState): import("../json-safe.ts").JsonSafe<_145.GenesisState>;
+                    fromPartial(object: Partial<_145.GenesisState>): _145.GenesisState;
+                    fromProtoMsg(message: _145.GenesisStateProtoMsg): _145.GenesisState;
+                    toProto(message: _145.GenesisState): Uint8Array;
+                    toProtoMsg(message: _145.GenesisState): _145.GenesisStateProtoMsg;
+                };
+                PacketSequence: {
+                    typeUrl: "/ibc.core.channel.v1.PacketSequence";
+                    encode(message: _145.PacketSequence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _145.PacketSequence;
+                    fromJSON(object: any): _145.PacketSequence;
+                    toJSON(message: _145.PacketSequence): import("../json-safe.ts").JsonSafe<_145.PacketSequence>;
+                    fromPartial(object: Partial<_145.PacketSequence>): _145.PacketSequence;
+                    fromProtoMsg(message: _145.PacketSequenceProtoMsg): _145.PacketSequence;
+                    toProto(message: _145.PacketSequence): Uint8Array;
+                    toProtoMsg(message: _145.PacketSequence): _145.PacketSequenceProtoMsg;
+                };
+                stateFromJSON(object: any): _144.State;
+                stateToJSON(object: _144.State): string;
+                orderFromJSON(object: any): _144.Order;
+                orderToJSON(object: _144.Order): string;
+                State: typeof _144.State;
+                StateSDKType: typeof _144.State;
+                Order: typeof _144.Order;
+                OrderSDKType: typeof _144.Order;
                 Channel: {
-                    typeUrl: string;
-                    encode(message: _23.Channel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _23.Channel;
-                    fromJSON(object: any): _23.Channel;
-                    toJSON(message: _23.Channel): unknown;
-                    fromPartial(object: Partial<_23.Channel>): _23.Channel;
-                    fromAmino(object: _23.ChannelAmino): _23.Channel;
-                    toAmino(message: _23.Channel): _23.ChannelAmino;
-                    fromAminoMsg(object: _23.ChannelAminoMsg): _23.Channel;
-                    toAminoMsg(message: _23.Channel): _23.ChannelAminoMsg;
-                    fromProtoMsg(message: _23.ChannelProtoMsg): _23.Channel;
-                    toProto(message: _23.Channel): Uint8Array;
-                    toProtoMsg(message: _23.Channel): _23.ChannelProtoMsg;
+                    typeUrl: "/ibc.core.channel.v1.Channel";
+                    encode(message: _144.Channel, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _144.Channel;
+                    fromJSON(object: any): _144.Channel;
+                    toJSON(message: _144.Channel): import("../json-safe.ts").JsonSafe<_144.Channel>;
+                    fromPartial(object: Partial<_144.Channel>): _144.Channel;
+                    fromProtoMsg(message: _144.ChannelProtoMsg): _144.Channel;
+                    toProto(message: _144.Channel): Uint8Array;
+                    toProtoMsg(message: _144.Channel): _144.ChannelProtoMsg;
                 };
                 IdentifiedChannel: {
-                    typeUrl: string;
-                    encode(message: _23.IdentifiedChannel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _23.IdentifiedChannel;
-                    fromJSON(object: any): _23.IdentifiedChannel;
-                    toJSON(message: _23.IdentifiedChannel): unknown;
-                    fromPartial(object: Partial<_23.IdentifiedChannel>): _23.IdentifiedChannel;
-                    fromAmino(object: _23.IdentifiedChannelAmino): _23.IdentifiedChannel;
-                    toAmino(message: _23.IdentifiedChannel): _23.IdentifiedChannelAmino;
-                    fromAminoMsg(object: _23.IdentifiedChannelAminoMsg): _23.IdentifiedChannel;
-                    toAminoMsg(message: _23.IdentifiedChannel): _23.IdentifiedChannelAminoMsg;
-                    fromProtoMsg(message: _23.IdentifiedChannelProtoMsg): _23.IdentifiedChannel;
-                    toProto(message: _23.IdentifiedChannel): Uint8Array;
-                    toProtoMsg(message: _23.IdentifiedChannel): _23.IdentifiedChannelProtoMsg;
+                    typeUrl: "/ibc.core.channel.v1.IdentifiedChannel";
+                    encode(message: _144.IdentifiedChannel, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _144.IdentifiedChannel;
+                    fromJSON(object: any): _144.IdentifiedChannel;
+                    toJSON(message: _144.IdentifiedChannel): import("../json-safe.ts").JsonSafe<_144.IdentifiedChannel>;
+                    fromPartial(object: Partial<_144.IdentifiedChannel>): _144.IdentifiedChannel;
+                    fromProtoMsg(message: _144.IdentifiedChannelProtoMsg): _144.IdentifiedChannel;
+                    toProto(message: _144.IdentifiedChannel): Uint8Array;
+                    toProtoMsg(message: _144.IdentifiedChannel): _144.IdentifiedChannelProtoMsg;
                 };
                 Counterparty: {
-                    typeUrl: string;
-                    encode(message: _23.Counterparty, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _23.Counterparty;
-                    fromJSON(object: any): _23.Counterparty;
-                    toJSON(message: _23.Counterparty): unknown;
-                    fromPartial(object: Partial<_23.Counterparty>): _23.Counterparty;
-                    fromAmino(object: _23.CounterpartyAmino): _23.Counterparty;
-                    toAmino(message: _23.Counterparty): _23.CounterpartyAmino;
-                    fromAminoMsg(object: _23.CounterpartyAminoMsg): _23.Counterparty;
-                    toAminoMsg(message: _23.Counterparty): _23.CounterpartyAminoMsg;
-                    fromProtoMsg(message: _23.CounterpartyProtoMsg): _23.Counterparty;
-                    toProto(message: _23.Counterparty): Uint8Array;
-                    toProtoMsg(message: _23.Counterparty): _23.CounterpartyProtoMsg;
+                    typeUrl: "/ibc.core.channel.v1.Counterparty";
+                    encode(message: _144.Counterparty, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _144.Counterparty;
+                    fromJSON(object: any): _144.Counterparty;
+                    toJSON(message: _144.Counterparty): import("../json-safe.ts").JsonSafe<_144.Counterparty>;
+                    fromPartial(object: Partial<_144.Counterparty>): _144.Counterparty;
+                    fromProtoMsg(message: _144.CounterpartyProtoMsg): _144.Counterparty;
+                    toProto(message: _144.Counterparty): Uint8Array;
+                    toProtoMsg(message: _144.Counterparty): _144.CounterpartyProtoMsg;
                 };
                 Packet: {
-                    typeUrl: string;
-                    encode(message: _23.Packet, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _23.Packet;
-                    fromJSON(object: any): _23.Packet;
-                    toJSON(message: _23.Packet): unknown;
-                    fromPartial(object: Partial<_23.Packet>): _23.Packet;
-                    fromAmino(object: _23.PacketAmino): _23.Packet;
-                    toAmino(message: _23.Packet): _23.PacketAmino;
-                    fromAminoMsg(object: _23.PacketAminoMsg): _23.Packet;
-                    toAminoMsg(message: _23.Packet): _23.PacketAminoMsg;
-                    fromProtoMsg(message: _23.PacketProtoMsg): _23.Packet;
-                    toProto(message: _23.Packet): Uint8Array;
-                    toProtoMsg(message: _23.Packet): _23.PacketProtoMsg;
+                    typeUrl: "/ibc.core.channel.v1.Packet";
+                    encode(message: _144.Packet, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _144.Packet;
+                    fromJSON(object: any): _144.Packet;
+                    toJSON(message: _144.Packet): import("../json-safe.ts").JsonSafe<_144.Packet>;
+                    fromPartial(object: Partial<_144.Packet>): _144.Packet;
+                    fromProtoMsg(message: _144.PacketProtoMsg): _144.Packet;
+                    toProto(message: _144.Packet): Uint8Array;
+                    toProtoMsg(message: _144.Packet): _144.PacketProtoMsg;
                 };
                 PacketState: {
-                    typeUrl: string;
-                    encode(message: _23.PacketState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _23.PacketState;
-                    fromJSON(object: any): _23.PacketState;
-                    toJSON(message: _23.PacketState): unknown;
-                    fromPartial(object: Partial<_23.PacketState>): _23.PacketState;
-                    fromAmino(object: _23.PacketStateAmino): _23.PacketState;
-                    toAmino(message: _23.PacketState): _23.PacketStateAmino;
-                    fromAminoMsg(object: _23.PacketStateAminoMsg): _23.PacketState;
-                    toAminoMsg(message: _23.PacketState): _23.PacketStateAminoMsg;
-                    fromProtoMsg(message: _23.PacketStateProtoMsg): _23.PacketState;
-                    toProto(message: _23.PacketState): Uint8Array;
-                    toProtoMsg(message: _23.PacketState): _23.PacketStateProtoMsg;
+                    typeUrl: "/ibc.core.channel.v1.PacketState";
+                    encode(message: _144.PacketState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _144.PacketState;
+                    fromJSON(object: any): _144.PacketState;
+                    toJSON(message: _144.PacketState): import("../json-safe.ts").JsonSafe<_144.PacketState>;
+                    fromPartial(object: Partial<_144.PacketState>): _144.PacketState;
+                    fromProtoMsg(message: _144.PacketStateProtoMsg): _144.PacketState;
+                    toProto(message: _144.PacketState): Uint8Array;
+                    toProtoMsg(message: _144.PacketState): _144.PacketStateProtoMsg;
                 };
                 PacketId: {
-                    typeUrl: string;
-                    encode(message: _23.PacketId, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _23.PacketId;
-                    fromJSON(object: any): _23.PacketId;
-                    toJSON(message: _23.PacketId): unknown;
-                    fromPartial(object: Partial<_23.PacketId>): _23.PacketId;
-                    fromAmino(object: _23.PacketIdAmino): _23.PacketId;
-                    toAmino(message: _23.PacketId): _23.PacketIdAmino;
-                    fromAminoMsg(object: _23.PacketIdAminoMsg): _23.PacketId;
-                    toAminoMsg(message: _23.PacketId): _23.PacketIdAminoMsg;
-                    fromProtoMsg(message: _23.PacketIdProtoMsg): _23.PacketId;
-                    toProto(message: _23.PacketId): Uint8Array;
-                    toProtoMsg(message: _23.PacketId): _23.PacketIdProtoMsg;
+                    typeUrl: "/ibc.core.channel.v1.PacketId";
+                    encode(message: _144.PacketId, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _144.PacketId;
+                    fromJSON(object: any): _144.PacketId;
+                    toJSON(message: _144.PacketId): import("../json-safe.ts").JsonSafe<_144.PacketId>;
+                    fromPartial(object: Partial<_144.PacketId>): _144.PacketId;
+                    fromProtoMsg(message: _144.PacketIdProtoMsg): _144.PacketId;
+                    toProto(message: _144.PacketId): Uint8Array;
+                    toProtoMsg(message: _144.PacketId): _144.PacketIdProtoMsg;
                 };
                 Acknowledgement: {
-                    typeUrl: string;
-                    encode(message: _23.Acknowledgement, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _23.Acknowledgement;
-                    fromJSON(object: any): _23.Acknowledgement;
-                    toJSON(message: _23.Acknowledgement): unknown;
-                    fromPartial(object: Partial<_23.Acknowledgement>): _23.Acknowledgement;
-                    fromAmino(object: _23.AcknowledgementAmino): _23.Acknowledgement;
-                    toAmino(message: _23.Acknowledgement): _23.AcknowledgementAmino;
-                    fromAminoMsg(object: _23.AcknowledgementAminoMsg): _23.Acknowledgement;
-                    toAminoMsg(message: _23.Acknowledgement): _23.AcknowledgementAminoMsg;
-                    fromProtoMsg(message: _23.AcknowledgementProtoMsg): _23.Acknowledgement;
-                    toProto(message: _23.Acknowledgement): Uint8Array;
-                    toProtoMsg(message: _23.Acknowledgement): _23.AcknowledgementProtoMsg;
+                    typeUrl: "/ibc.core.channel.v1.Acknowledgement";
+                    encode(message: _144.Acknowledgement, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _144.Acknowledgement;
+                    fromJSON(object: any): _144.Acknowledgement;
+                    toJSON(message: _144.Acknowledgement): import("../json-safe.ts").JsonSafe<_144.Acknowledgement>;
+                    fromPartial(object: Partial<_144.Acknowledgement>): _144.Acknowledgement;
+                    fromProtoMsg(message: _144.AcknowledgementProtoMsg): _144.Acknowledgement;
+                    toProto(message: _144.Acknowledgement): Uint8Array;
+                    toProtoMsg(message: _144.Acknowledgement): _144.AcknowledgementProtoMsg;
                 };
             };
         }
         namespace client {
             const v1: {
+                MsgCreateClient: {
+                    typeUrl: "/ibc.core.client.v1.MsgCreateClient";
+                    encode(message: _151.MsgCreateClient, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgCreateClient;
+                    fromJSON(object: any): _151.MsgCreateClient;
+                    toJSON(message: _151.MsgCreateClient): import("../json-safe.ts").JsonSafe<_151.MsgCreateClient>;
+                    fromPartial(object: Partial<_151.MsgCreateClient>): _151.MsgCreateClient;
+                    fromProtoMsg(message: _151.MsgCreateClientProtoMsg): _151.MsgCreateClient;
+                    toProto(message: _151.MsgCreateClient): Uint8Array;
+                    toProtoMsg(message: _151.MsgCreateClient): _151.MsgCreateClientProtoMsg;
+                };
+                MsgCreateClientResponse: {
+                    typeUrl: "/ibc.core.client.v1.MsgCreateClientResponse";
+                    encode(_: _151.MsgCreateClientResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgCreateClientResponse;
+                    fromJSON(_: any): _151.MsgCreateClientResponse;
+                    toJSON(_: _151.MsgCreateClientResponse): import("../json-safe.ts").JsonSafe<_151.MsgCreateClientResponse>;
+                    fromPartial(_: Partial<_151.MsgCreateClientResponse>): _151.MsgCreateClientResponse;
+                    fromProtoMsg(message: _151.MsgCreateClientResponseProtoMsg): _151.MsgCreateClientResponse;
+                    toProto(message: _151.MsgCreateClientResponse): Uint8Array;
+                    toProtoMsg(message: _151.MsgCreateClientResponse): _151.MsgCreateClientResponseProtoMsg;
+                };
+                MsgUpdateClient: {
+                    typeUrl: "/ibc.core.client.v1.MsgUpdateClient";
+                    encode(message: _151.MsgUpdateClient, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgUpdateClient;
+                    fromJSON(object: any): _151.MsgUpdateClient;
+                    toJSON(message: _151.MsgUpdateClient): import("../json-safe.ts").JsonSafe<_151.MsgUpdateClient>;
+                    fromPartial(object: Partial<_151.MsgUpdateClient>): _151.MsgUpdateClient;
+                    fromProtoMsg(message: _151.MsgUpdateClientProtoMsg): _151.MsgUpdateClient;
+                    toProto(message: _151.MsgUpdateClient): Uint8Array;
+                    toProtoMsg(message: _151.MsgUpdateClient): _151.MsgUpdateClientProtoMsg;
+                };
+                MsgUpdateClientResponse: {
+                    typeUrl: "/ibc.core.client.v1.MsgUpdateClientResponse";
+                    encode(_: _151.MsgUpdateClientResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgUpdateClientResponse;
+                    fromJSON(_: any): _151.MsgUpdateClientResponse;
+                    toJSON(_: _151.MsgUpdateClientResponse): import("../json-safe.ts").JsonSafe<_151.MsgUpdateClientResponse>;
+                    fromPartial(_: Partial<_151.MsgUpdateClientResponse>): _151.MsgUpdateClientResponse;
+                    fromProtoMsg(message: _151.MsgUpdateClientResponseProtoMsg): _151.MsgUpdateClientResponse;
+                    toProto(message: _151.MsgUpdateClientResponse): Uint8Array;
+                    toProtoMsg(message: _151.MsgUpdateClientResponse): _151.MsgUpdateClientResponseProtoMsg;
+                };
+                MsgUpgradeClient: {
+                    typeUrl: "/ibc.core.client.v1.MsgUpgradeClient";
+                    encode(message: _151.MsgUpgradeClient, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgUpgradeClient;
+                    fromJSON(object: any): _151.MsgUpgradeClient;
+                    toJSON(message: _151.MsgUpgradeClient): import("../json-safe.ts").JsonSafe<_151.MsgUpgradeClient>;
+                    fromPartial(object: Partial<_151.MsgUpgradeClient>): _151.MsgUpgradeClient;
+                    fromProtoMsg(message: _151.MsgUpgradeClientProtoMsg): _151.MsgUpgradeClient;
+                    toProto(message: _151.MsgUpgradeClient): Uint8Array;
+                    toProtoMsg(message: _151.MsgUpgradeClient): _151.MsgUpgradeClientProtoMsg;
+                };
+                MsgUpgradeClientResponse: {
+                    typeUrl: "/ibc.core.client.v1.MsgUpgradeClientResponse";
+                    encode(_: _151.MsgUpgradeClientResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgUpgradeClientResponse;
+                    fromJSON(_: any): _151.MsgUpgradeClientResponse;
+                    toJSON(_: _151.MsgUpgradeClientResponse): import("../json-safe.ts").JsonSafe<_151.MsgUpgradeClientResponse>;
+                    fromPartial(_: Partial<_151.MsgUpgradeClientResponse>): _151.MsgUpgradeClientResponse;
+                    fromProtoMsg(message: _151.MsgUpgradeClientResponseProtoMsg): _151.MsgUpgradeClientResponse;
+                    toProto(message: _151.MsgUpgradeClientResponse): Uint8Array;
+                    toProtoMsg(message: _151.MsgUpgradeClientResponse): _151.MsgUpgradeClientResponseProtoMsg;
+                };
+                MsgSubmitMisbehaviour: {
+                    typeUrl: "/ibc.core.client.v1.MsgSubmitMisbehaviour";
+                    encode(message: _151.MsgSubmitMisbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgSubmitMisbehaviour;
+                    fromJSON(object: any): _151.MsgSubmitMisbehaviour;
+                    toJSON(message: _151.MsgSubmitMisbehaviour): import("../json-safe.ts").JsonSafe<_151.MsgSubmitMisbehaviour>;
+                    fromPartial(object: Partial<_151.MsgSubmitMisbehaviour>): _151.MsgSubmitMisbehaviour;
+                    fromProtoMsg(message: _151.MsgSubmitMisbehaviourProtoMsg): _151.MsgSubmitMisbehaviour;
+                    toProto(message: _151.MsgSubmitMisbehaviour): Uint8Array;
+                    toProtoMsg(message: _151.MsgSubmitMisbehaviour): _151.MsgSubmitMisbehaviourProtoMsg;
+                };
+                MsgSubmitMisbehaviourResponse: {
+                    typeUrl: "/ibc.core.client.v1.MsgSubmitMisbehaviourResponse";
+                    encode(_: _151.MsgSubmitMisbehaviourResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgSubmitMisbehaviourResponse;
+                    fromJSON(_: any): _151.MsgSubmitMisbehaviourResponse;
+                    toJSON(_: _151.MsgSubmitMisbehaviourResponse): import("../json-safe.ts").JsonSafe<_151.MsgSubmitMisbehaviourResponse>;
+                    fromPartial(_: Partial<_151.MsgSubmitMisbehaviourResponse>): _151.MsgSubmitMisbehaviourResponse;
+                    fromProtoMsg(message: _151.MsgSubmitMisbehaviourResponseProtoMsg): _151.MsgSubmitMisbehaviourResponse;
+                    toProto(message: _151.MsgSubmitMisbehaviourResponse): Uint8Array;
+                    toProtoMsg(message: _151.MsgSubmitMisbehaviourResponse): _151.MsgSubmitMisbehaviourResponseProtoMsg;
+                };
+                QueryClientStateRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryClientStateRequest";
+                    encode(message: _150.QueryClientStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryClientStateRequest;
+                    fromJSON(object: any): _150.QueryClientStateRequest;
+                    toJSON(message: _150.QueryClientStateRequest): import("../json-safe.ts").JsonSafe<_150.QueryClientStateRequest>;
+                    fromPartial(object: Partial<_150.QueryClientStateRequest>): _150.QueryClientStateRequest;
+                    fromProtoMsg(message: _150.QueryClientStateRequestProtoMsg): _150.QueryClientStateRequest;
+                    toProto(message: _150.QueryClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryClientStateRequest): _150.QueryClientStateRequestProtoMsg;
+                };
+                QueryClientStateResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryClientStateResponse";
+                    encode(message: _150.QueryClientStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryClientStateResponse;
+                    fromJSON(object: any): _150.QueryClientStateResponse;
+                    toJSON(message: _150.QueryClientStateResponse): import("../json-safe.ts").JsonSafe<_150.QueryClientStateResponse>;
+                    fromPartial(object: Partial<_150.QueryClientStateResponse>): _150.QueryClientStateResponse;
+                    fromProtoMsg(message: _150.QueryClientStateResponseProtoMsg): _150.QueryClientStateResponse;
+                    toProto(message: _150.QueryClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryClientStateResponse): _150.QueryClientStateResponseProtoMsg;
+                };
+                QueryClientStatesRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryClientStatesRequest";
+                    encode(message: _150.QueryClientStatesRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryClientStatesRequest;
+                    fromJSON(object: any): _150.QueryClientStatesRequest;
+                    toJSON(message: _150.QueryClientStatesRequest): import("../json-safe.ts").JsonSafe<_150.QueryClientStatesRequest>;
+                    fromPartial(object: Partial<_150.QueryClientStatesRequest>): _150.QueryClientStatesRequest;
+                    fromProtoMsg(message: _150.QueryClientStatesRequestProtoMsg): _150.QueryClientStatesRequest;
+                    toProto(message: _150.QueryClientStatesRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryClientStatesRequest): _150.QueryClientStatesRequestProtoMsg;
+                };
+                QueryClientStatesResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryClientStatesResponse";
+                    encode(message: _150.QueryClientStatesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryClientStatesResponse;
+                    fromJSON(object: any): _150.QueryClientStatesResponse;
+                    toJSON(message: _150.QueryClientStatesResponse): import("../json-safe.ts").JsonSafe<_150.QueryClientStatesResponse>;
+                    fromPartial(object: Partial<_150.QueryClientStatesResponse>): _150.QueryClientStatesResponse;
+                    fromProtoMsg(message: _150.QueryClientStatesResponseProtoMsg): _150.QueryClientStatesResponse;
+                    toProto(message: _150.QueryClientStatesResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryClientStatesResponse): _150.QueryClientStatesResponseProtoMsg;
+                };
+                QueryConsensusStateRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryConsensusStateRequest";
+                    encode(message: _150.QueryConsensusStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryConsensusStateRequest;
+                    fromJSON(object: any): _150.QueryConsensusStateRequest;
+                    toJSON(message: _150.QueryConsensusStateRequest): import("../json-safe.ts").JsonSafe<_150.QueryConsensusStateRequest>;
+                    fromPartial(object: Partial<_150.QueryConsensusStateRequest>): _150.QueryConsensusStateRequest;
+                    fromProtoMsg(message: _150.QueryConsensusStateRequestProtoMsg): _150.QueryConsensusStateRequest;
+                    toProto(message: _150.QueryConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryConsensusStateRequest): _150.QueryConsensusStateRequestProtoMsg;
+                };
+                QueryConsensusStateResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryConsensusStateResponse";
+                    encode(message: _150.QueryConsensusStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryConsensusStateResponse;
+                    fromJSON(object: any): _150.QueryConsensusStateResponse;
+                    toJSON(message: _150.QueryConsensusStateResponse): import("../json-safe.ts").JsonSafe<_150.QueryConsensusStateResponse>;
+                    fromPartial(object: Partial<_150.QueryConsensusStateResponse>): _150.QueryConsensusStateResponse;
+                    fromProtoMsg(message: _150.QueryConsensusStateResponseProtoMsg): _150.QueryConsensusStateResponse;
+                    toProto(message: _150.QueryConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryConsensusStateResponse): _150.QueryConsensusStateResponseProtoMsg;
+                };
+                QueryConsensusStatesRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryConsensusStatesRequest";
+                    encode(message: _150.QueryConsensusStatesRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryConsensusStatesRequest;
+                    fromJSON(object: any): _150.QueryConsensusStatesRequest;
+                    toJSON(message: _150.QueryConsensusStatesRequest): import("../json-safe.ts").JsonSafe<_150.QueryConsensusStatesRequest>;
+                    fromPartial(object: Partial<_150.QueryConsensusStatesRequest>): _150.QueryConsensusStatesRequest;
+                    fromProtoMsg(message: _150.QueryConsensusStatesRequestProtoMsg): _150.QueryConsensusStatesRequest;
+                    toProto(message: _150.QueryConsensusStatesRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryConsensusStatesRequest): _150.QueryConsensusStatesRequestProtoMsg;
+                };
+                QueryConsensusStatesResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryConsensusStatesResponse";
+                    encode(message: _150.QueryConsensusStatesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryConsensusStatesResponse;
+                    fromJSON(object: any): _150.QueryConsensusStatesResponse;
+                    toJSON(message: _150.QueryConsensusStatesResponse): import("../json-safe.ts").JsonSafe<_150.QueryConsensusStatesResponse>;
+                    fromPartial(object: Partial<_150.QueryConsensusStatesResponse>): _150.QueryConsensusStatesResponse;
+                    fromProtoMsg(message: _150.QueryConsensusStatesResponseProtoMsg): _150.QueryConsensusStatesResponse;
+                    toProto(message: _150.QueryConsensusStatesResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryConsensusStatesResponse): _150.QueryConsensusStatesResponseProtoMsg;
+                };
+                QueryConsensusStateHeightsRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryConsensusStateHeightsRequest";
+                    encode(message: _150.QueryConsensusStateHeightsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryConsensusStateHeightsRequest;
+                    fromJSON(object: any): _150.QueryConsensusStateHeightsRequest;
+                    toJSON(message: _150.QueryConsensusStateHeightsRequest): import("../json-safe.ts").JsonSafe<_150.QueryConsensusStateHeightsRequest>;
+                    fromPartial(object: Partial<_150.QueryConsensusStateHeightsRequest>): _150.QueryConsensusStateHeightsRequest;
+                    fromProtoMsg(message: _150.QueryConsensusStateHeightsRequestProtoMsg): _150.QueryConsensusStateHeightsRequest;
+                    toProto(message: _150.QueryConsensusStateHeightsRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryConsensusStateHeightsRequest): _150.QueryConsensusStateHeightsRequestProtoMsg;
+                };
+                QueryConsensusStateHeightsResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryConsensusStateHeightsResponse";
+                    encode(message: _150.QueryConsensusStateHeightsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryConsensusStateHeightsResponse;
+                    fromJSON(object: any): _150.QueryConsensusStateHeightsResponse;
+                    toJSON(message: _150.QueryConsensusStateHeightsResponse): import("../json-safe.ts").JsonSafe<_150.QueryConsensusStateHeightsResponse>;
+                    fromPartial(object: Partial<_150.QueryConsensusStateHeightsResponse>): _150.QueryConsensusStateHeightsResponse;
+                    fromProtoMsg(message: _150.QueryConsensusStateHeightsResponseProtoMsg): _150.QueryConsensusStateHeightsResponse;
+                    toProto(message: _150.QueryConsensusStateHeightsResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryConsensusStateHeightsResponse): _150.QueryConsensusStateHeightsResponseProtoMsg;
+                };
+                QueryClientStatusRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryClientStatusRequest";
+                    encode(message: _150.QueryClientStatusRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryClientStatusRequest;
+                    fromJSON(object: any): _150.QueryClientStatusRequest;
+                    toJSON(message: _150.QueryClientStatusRequest): import("../json-safe.ts").JsonSafe<_150.QueryClientStatusRequest>;
+                    fromPartial(object: Partial<_150.QueryClientStatusRequest>): _150.QueryClientStatusRequest;
+                    fromProtoMsg(message: _150.QueryClientStatusRequestProtoMsg): _150.QueryClientStatusRequest;
+                    toProto(message: _150.QueryClientStatusRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryClientStatusRequest): _150.QueryClientStatusRequestProtoMsg;
+                };
+                QueryClientStatusResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryClientStatusResponse";
+                    encode(message: _150.QueryClientStatusResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryClientStatusResponse;
+                    fromJSON(object: any): _150.QueryClientStatusResponse;
+                    toJSON(message: _150.QueryClientStatusResponse): import("../json-safe.ts").JsonSafe<_150.QueryClientStatusResponse>;
+                    fromPartial(object: Partial<_150.QueryClientStatusResponse>): _150.QueryClientStatusResponse;
+                    fromProtoMsg(message: _150.QueryClientStatusResponseProtoMsg): _150.QueryClientStatusResponse;
+                    toProto(message: _150.QueryClientStatusResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryClientStatusResponse): _150.QueryClientStatusResponseProtoMsg;
+                };
+                QueryClientParamsRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryClientParamsRequest";
+                    encode(_: _150.QueryClientParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryClientParamsRequest;
+                    fromJSON(_: any): _150.QueryClientParamsRequest;
+                    toJSON(_: _150.QueryClientParamsRequest): import("../json-safe.ts").JsonSafe<_150.QueryClientParamsRequest>;
+                    fromPartial(_: Partial<_150.QueryClientParamsRequest>): _150.QueryClientParamsRequest;
+                    fromProtoMsg(message: _150.QueryClientParamsRequestProtoMsg): _150.QueryClientParamsRequest;
+                    toProto(message: _150.QueryClientParamsRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryClientParamsRequest): _150.QueryClientParamsRequestProtoMsg;
+                };
+                QueryClientParamsResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryClientParamsResponse";
+                    encode(message: _150.QueryClientParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryClientParamsResponse;
+                    fromJSON(object: any): _150.QueryClientParamsResponse;
+                    toJSON(message: _150.QueryClientParamsResponse): import("../json-safe.ts").JsonSafe<_150.QueryClientParamsResponse>;
+                    fromPartial(object: Partial<_150.QueryClientParamsResponse>): _150.QueryClientParamsResponse;
+                    fromProtoMsg(message: _150.QueryClientParamsResponseProtoMsg): _150.QueryClientParamsResponse;
+                    toProto(message: _150.QueryClientParamsResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryClientParamsResponse): _150.QueryClientParamsResponseProtoMsg;
+                };
+                QueryUpgradedClientStateRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryUpgradedClientStateRequest";
+                    encode(_: _150.QueryUpgradedClientStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryUpgradedClientStateRequest;
+                    fromJSON(_: any): _150.QueryUpgradedClientStateRequest;
+                    toJSON(_: _150.QueryUpgradedClientStateRequest): import("../json-safe.ts").JsonSafe<_150.QueryUpgradedClientStateRequest>;
+                    fromPartial(_: Partial<_150.QueryUpgradedClientStateRequest>): _150.QueryUpgradedClientStateRequest;
+                    fromProtoMsg(message: _150.QueryUpgradedClientStateRequestProtoMsg): _150.QueryUpgradedClientStateRequest;
+                    toProto(message: _150.QueryUpgradedClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryUpgradedClientStateRequest): _150.QueryUpgradedClientStateRequestProtoMsg;
+                };
+                QueryUpgradedClientStateResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryUpgradedClientStateResponse";
+                    encode(message: _150.QueryUpgradedClientStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryUpgradedClientStateResponse;
+                    fromJSON(object: any): _150.QueryUpgradedClientStateResponse;
+                    toJSON(message: _150.QueryUpgradedClientStateResponse): import("../json-safe.ts").JsonSafe<_150.QueryUpgradedClientStateResponse>;
+                    fromPartial(object: Partial<_150.QueryUpgradedClientStateResponse>): _150.QueryUpgradedClientStateResponse;
+                    fromProtoMsg(message: _150.QueryUpgradedClientStateResponseProtoMsg): _150.QueryUpgradedClientStateResponse;
+                    toProto(message: _150.QueryUpgradedClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryUpgradedClientStateResponse): _150.QueryUpgradedClientStateResponseProtoMsg;
+                };
+                QueryUpgradedConsensusStateRequest: {
+                    typeUrl: "/ibc.core.client.v1.QueryUpgradedConsensusStateRequest";
+                    encode(_: _150.QueryUpgradedConsensusStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryUpgradedConsensusStateRequest;
+                    fromJSON(_: any): _150.QueryUpgradedConsensusStateRequest;
+                    toJSON(_: _150.QueryUpgradedConsensusStateRequest): import("../json-safe.ts").JsonSafe<_150.QueryUpgradedConsensusStateRequest>;
+                    fromPartial(_: Partial<_150.QueryUpgradedConsensusStateRequest>): _150.QueryUpgradedConsensusStateRequest;
+                    fromProtoMsg(message: _150.QueryUpgradedConsensusStateRequestProtoMsg): _150.QueryUpgradedConsensusStateRequest;
+                    toProto(message: _150.QueryUpgradedConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _150.QueryUpgradedConsensusStateRequest): _150.QueryUpgradedConsensusStateRequestProtoMsg;
+                };
+                QueryUpgradedConsensusStateResponse: {
+                    typeUrl: "/ibc.core.client.v1.QueryUpgradedConsensusStateResponse";
+                    encode(message: _150.QueryUpgradedConsensusStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.QueryUpgradedConsensusStateResponse;
+                    fromJSON(object: any): _150.QueryUpgradedConsensusStateResponse;
+                    toJSON(message: _150.QueryUpgradedConsensusStateResponse): import("../json-safe.ts").JsonSafe<_150.QueryUpgradedConsensusStateResponse>;
+                    fromPartial(object: Partial<_150.QueryUpgradedConsensusStateResponse>): _150.QueryUpgradedConsensusStateResponse;
+                    fromProtoMsg(message: _150.QueryUpgradedConsensusStateResponseProtoMsg): _150.QueryUpgradedConsensusStateResponse;
+                    toProto(message: _150.QueryUpgradedConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _150.QueryUpgradedConsensusStateResponse): _150.QueryUpgradedConsensusStateResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: "/ibc.core.client.v1.GenesisState";
+                    encode(message: _149.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.GenesisState;
+                    fromJSON(object: any): _149.GenesisState;
+                    toJSON(message: _149.GenesisState): import("../json-safe.ts").JsonSafe<_149.GenesisState>;
+                    fromPartial(object: Partial<_149.GenesisState>): _149.GenesisState;
+                    fromProtoMsg(message: _149.GenesisStateProtoMsg): _149.GenesisState;
+                    toProto(message: _149.GenesisState): Uint8Array;
+                    toProtoMsg(message: _149.GenesisState): _149.GenesisStateProtoMsg;
+                };
+                GenesisMetadata: {
+                    typeUrl: "/ibc.core.client.v1.GenesisMetadata";
+                    encode(message: _149.GenesisMetadata, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.GenesisMetadata;
+                    fromJSON(object: any): _149.GenesisMetadata;
+                    toJSON(message: _149.GenesisMetadata): import("../json-safe.ts").JsonSafe<_149.GenesisMetadata>;
+                    fromPartial(object: Partial<_149.GenesisMetadata>): _149.GenesisMetadata;
+                    fromProtoMsg(message: _149.GenesisMetadataProtoMsg): _149.GenesisMetadata;
+                    toProto(message: _149.GenesisMetadata): Uint8Array;
+                    toProtoMsg(message: _149.GenesisMetadata): _149.GenesisMetadataProtoMsg;
+                };
+                IdentifiedGenesisMetadata: {
+                    typeUrl: "/ibc.core.client.v1.IdentifiedGenesisMetadata";
+                    encode(message: _149.IdentifiedGenesisMetadata, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.IdentifiedGenesisMetadata;
+                    fromJSON(object: any): _149.IdentifiedGenesisMetadata;
+                    toJSON(message: _149.IdentifiedGenesisMetadata): import("../json-safe.ts").JsonSafe<_149.IdentifiedGenesisMetadata>;
+                    fromPartial(object: Partial<_149.IdentifiedGenesisMetadata>): _149.IdentifiedGenesisMetadata;
+                    fromProtoMsg(message: _149.IdentifiedGenesisMetadataProtoMsg): _149.IdentifiedGenesisMetadata;
+                    toProto(message: _149.IdentifiedGenesisMetadata): Uint8Array;
+                    toProtoMsg(message: _149.IdentifiedGenesisMetadata): _149.IdentifiedGenesisMetadataProtoMsg;
+                };
                 IdentifiedClientState: {
-                    typeUrl: string;
-                    encode(message: _24.IdentifiedClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _24.IdentifiedClientState;
-                    fromJSON(object: any): _24.IdentifiedClientState;
-                    toJSON(message: _24.IdentifiedClientState): unknown;
-                    fromPartial(object: Partial<_24.IdentifiedClientState>): _24.IdentifiedClientState;
-                    fromAmino(object: _24.IdentifiedClientStateAmino): _24.IdentifiedClientState;
-                    toAmino(message: _24.IdentifiedClientState): _24.IdentifiedClientStateAmino;
-                    fromAminoMsg(object: _24.IdentifiedClientStateAminoMsg): _24.IdentifiedClientState;
-                    toAminoMsg(message: _24.IdentifiedClientState): _24.IdentifiedClientStateAminoMsg;
-                    fromProtoMsg(message: _24.IdentifiedClientStateProtoMsg): _24.IdentifiedClientState;
-                    toProto(message: _24.IdentifiedClientState): Uint8Array;
-                    toProtoMsg(message: _24.IdentifiedClientState): _24.IdentifiedClientStateProtoMsg;
+                    typeUrl: "/ibc.core.client.v1.IdentifiedClientState";
+                    encode(message: _148.IdentifiedClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _148.IdentifiedClientState;
+                    fromJSON(object: any): _148.IdentifiedClientState;
+                    toJSON(message: _148.IdentifiedClientState): import("../json-safe.ts").JsonSafe<_148.IdentifiedClientState>;
+                    fromPartial(object: Partial<_148.IdentifiedClientState>): _148.IdentifiedClientState;
+                    fromProtoMsg(message: _148.IdentifiedClientStateProtoMsg): _148.IdentifiedClientState;
+                    toProto(message: _148.IdentifiedClientState): Uint8Array;
+                    toProtoMsg(message: _148.IdentifiedClientState): _148.IdentifiedClientStateProtoMsg;
                 };
                 ConsensusStateWithHeight: {
-                    typeUrl: string;
-                    encode(message: _24.ConsensusStateWithHeight, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _24.ConsensusStateWithHeight;
-                    fromJSON(object: any): _24.ConsensusStateWithHeight;
-                    toJSON(message: _24.ConsensusStateWithHeight): unknown;
-                    fromPartial(object: Partial<_24.ConsensusStateWithHeight>): _24.ConsensusStateWithHeight;
-                    fromAmino(object: _24.ConsensusStateWithHeightAmino): _24.ConsensusStateWithHeight;
-                    toAmino(message: _24.ConsensusStateWithHeight): _24.ConsensusStateWithHeightAmino;
-                    fromAminoMsg(object: _24.ConsensusStateWithHeightAminoMsg): _24.ConsensusStateWithHeight;
-                    toAminoMsg(message: _24.ConsensusStateWithHeight): _24.ConsensusStateWithHeightAminoMsg;
-                    fromProtoMsg(message: _24.ConsensusStateWithHeightProtoMsg): _24.ConsensusStateWithHeight;
-                    toProto(message: _24.ConsensusStateWithHeight): Uint8Array;
-                    toProtoMsg(message: _24.ConsensusStateWithHeight): _24.ConsensusStateWithHeightProtoMsg;
+                    typeUrl: "/ibc.core.client.v1.ConsensusStateWithHeight";
+                    encode(message: _148.ConsensusStateWithHeight, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _148.ConsensusStateWithHeight;
+                    fromJSON(object: any): _148.ConsensusStateWithHeight;
+                    toJSON(message: _148.ConsensusStateWithHeight): import("../json-safe.ts").JsonSafe<_148.ConsensusStateWithHeight>;
+                    fromPartial(object: Partial<_148.ConsensusStateWithHeight>): _148.ConsensusStateWithHeight;
+                    fromProtoMsg(message: _148.ConsensusStateWithHeightProtoMsg): _148.ConsensusStateWithHeight;
+                    toProto(message: _148.ConsensusStateWithHeight): Uint8Array;
+                    toProtoMsg(message: _148.ConsensusStateWithHeight): _148.ConsensusStateWithHeightProtoMsg;
                 };
                 ClientConsensusStates: {
-                    typeUrl: string;
-                    encode(message: _24.ClientConsensusStates, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _24.ClientConsensusStates;
-                    fromJSON(object: any): _24.ClientConsensusStates;
-                    toJSON(message: _24.ClientConsensusStates): unknown;
-                    fromPartial(object: Partial<_24.ClientConsensusStates>): _24.ClientConsensusStates;
-                    fromAmino(object: _24.ClientConsensusStatesAmino): _24.ClientConsensusStates;
-                    toAmino(message: _24.ClientConsensusStates): _24.ClientConsensusStatesAmino;
-                    fromAminoMsg(object: _24.ClientConsensusStatesAminoMsg): _24.ClientConsensusStates;
-                    toAminoMsg(message: _24.ClientConsensusStates): _24.ClientConsensusStatesAminoMsg;
-                    fromProtoMsg(message: _24.ClientConsensusStatesProtoMsg): _24.ClientConsensusStates;
-                    toProto(message: _24.ClientConsensusStates): Uint8Array;
-                    toProtoMsg(message: _24.ClientConsensusStates): _24.ClientConsensusStatesProtoMsg;
+                    typeUrl: "/ibc.core.client.v1.ClientConsensusStates";
+                    encode(message: _148.ClientConsensusStates, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _148.ClientConsensusStates;
+                    fromJSON(object: any): _148.ClientConsensusStates;
+                    toJSON(message: _148.ClientConsensusStates): import("../json-safe.ts").JsonSafe<_148.ClientConsensusStates>;
+                    fromPartial(object: Partial<_148.ClientConsensusStates>): _148.ClientConsensusStates;
+                    fromProtoMsg(message: _148.ClientConsensusStatesProtoMsg): _148.ClientConsensusStates;
+                    toProto(message: _148.ClientConsensusStates): Uint8Array;
+                    toProtoMsg(message: _148.ClientConsensusStates): _148.ClientConsensusStatesProtoMsg;
                 };
                 ClientUpdateProposal: {
-                    typeUrl: string;
-                    encode(message: _24.ClientUpdateProposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _24.ClientUpdateProposal;
-                    fromJSON(object: any): _24.ClientUpdateProposal;
-                    toJSON(message: _24.ClientUpdateProposal): unknown;
-                    fromPartial(object: Partial<_24.ClientUpdateProposal>): _24.ClientUpdateProposal;
-                    fromAmino(object: _24.ClientUpdateProposalAmino): _24.ClientUpdateProposal;
-                    toAmino(message: _24.ClientUpdateProposal): _24.ClientUpdateProposalAmino;
-                    fromAminoMsg(object: _24.ClientUpdateProposalAminoMsg): _24.ClientUpdateProposal;
-                    toAminoMsg(message: _24.ClientUpdateProposal): _24.ClientUpdateProposalAminoMsg;
-                    fromProtoMsg(message: _24.ClientUpdateProposalProtoMsg): _24.ClientUpdateProposal;
-                    toProto(message: _24.ClientUpdateProposal): Uint8Array;
-                    toProtoMsg(message: _24.ClientUpdateProposal): _24.ClientUpdateProposalProtoMsg;
+                    typeUrl: "/ibc.core.client.v1.ClientUpdateProposal";
+                    encode(message: _148.ClientUpdateProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _148.ClientUpdateProposal;
+                    fromJSON(object: any): _148.ClientUpdateProposal;
+                    toJSON(message: _148.ClientUpdateProposal): import("../json-safe.ts").JsonSafe<_148.ClientUpdateProposal>;
+                    fromPartial(object: Partial<_148.ClientUpdateProposal>): _148.ClientUpdateProposal;
+                    fromProtoMsg(message: _148.ClientUpdateProposalProtoMsg): _148.ClientUpdateProposal;
+                    toProto(message: _148.ClientUpdateProposal): Uint8Array;
+                    toProtoMsg(message: _148.ClientUpdateProposal): _148.ClientUpdateProposalProtoMsg;
                 };
                 UpgradeProposal: {
-                    typeUrl: string;
-                    encode(message: _24.UpgradeProposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _24.UpgradeProposal;
-                    fromJSON(object: any): _24.UpgradeProposal;
-                    toJSON(message: _24.UpgradeProposal): unknown;
-                    fromPartial(object: Partial<_24.UpgradeProposal>): _24.UpgradeProposal;
-                    fromAmino(object: _24.UpgradeProposalAmino): _24.UpgradeProposal;
-                    toAmino(message: _24.UpgradeProposal): _24.UpgradeProposalAmino;
-                    fromAminoMsg(object: _24.UpgradeProposalAminoMsg): _24.UpgradeProposal;
-                    toAminoMsg(message: _24.UpgradeProposal): _24.UpgradeProposalAminoMsg;
-                    fromProtoMsg(message: _24.UpgradeProposalProtoMsg): _24.UpgradeProposal;
-                    toProto(message: _24.UpgradeProposal): Uint8Array;
-                    toProtoMsg(message: _24.UpgradeProposal): _24.UpgradeProposalProtoMsg;
+                    typeUrl: "/ibc.core.client.v1.UpgradeProposal";
+                    encode(message: _148.UpgradeProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _148.UpgradeProposal;
+                    fromJSON(object: any): _148.UpgradeProposal;
+                    toJSON(message: _148.UpgradeProposal): import("../json-safe.ts").JsonSafe<_148.UpgradeProposal>;
+                    fromPartial(object: Partial<_148.UpgradeProposal>): _148.UpgradeProposal;
+                    fromProtoMsg(message: _148.UpgradeProposalProtoMsg): _148.UpgradeProposal;
+                    toProto(message: _148.UpgradeProposal): Uint8Array;
+                    toProtoMsg(message: _148.UpgradeProposal): _148.UpgradeProposalProtoMsg;
                 };
                 Height: {
-                    typeUrl: string;
-                    encode(message: _24.Height, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _24.Height;
-                    fromJSON(object: any): _24.Height;
-                    toJSON(message: _24.Height): unknown;
-                    fromPartial(object: Partial<_24.Height>): _24.Height;
-                    fromAmino(object: _24.HeightAmino): _24.Height;
-                    toAmino(message: _24.Height): _24.HeightAmino;
-                    fromAminoMsg(object: _24.HeightAminoMsg): _24.Height;
-                    toAminoMsg(message: _24.Height): _24.HeightAminoMsg;
-                    fromProtoMsg(message: _24.HeightProtoMsg): _24.Height;
-                    toProto(message: _24.Height): Uint8Array;
-                    toProtoMsg(message: _24.Height): _24.HeightProtoMsg;
+                    typeUrl: "/ibc.core.client.v1.Height";
+                    encode(message: _148.Height, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _148.Height;
+                    fromJSON(object: any): _148.Height;
+                    toJSON(message: _148.Height): import("../json-safe.ts").JsonSafe<_148.Height>;
+                    fromPartial(object: Partial<_148.Height>): _148.Height;
+                    fromProtoMsg(message: _148.HeightProtoMsg): _148.Height;
+                    toProto(message: _148.Height): Uint8Array;
+                    toProtoMsg(message: _148.Height): _148.HeightProtoMsg;
                 };
                 Params: {
-                    typeUrl: string;
-                    encode(message: _24.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
-                    decode(input: Uint8Array | import("../binary.js").BinaryReader, length?: number | undefined): _24.Params;
-                    fromJSON(object: any): _24.Params;
-                    toJSON(message: _24.Params): unknown;
-                    fromPartial(object: Partial<_24.Params>): _24.Params;
-                    fromAmino(object: _24.ParamsAmino): _24.Params;
-                    toAmino(message: _24.Params): _24.ParamsAmino;
-                    fromAminoMsg(object: _24.ParamsAminoMsg): _24.Params;
-                    toAminoMsg(message: _24.Params): _24.ParamsAminoMsg;
-                    fromProtoMsg(message: _24.ParamsProtoMsg): _24.Params;
-                    toProto(message: _24.Params): Uint8Array;
-                    toProtoMsg(message: _24.Params): _24.ParamsProtoMsg;
+                    typeUrl: "/ibc.core.client.v1.Params";
+                    encode(message: _148.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _148.Params;
+                    fromJSON(object: any): _148.Params;
+                    toJSON(message: _148.Params): import("../json-safe.ts").JsonSafe<_148.Params>;
+                    fromPartial(object: Partial<_148.Params>): _148.Params;
+                    fromProtoMsg(message: _148.ParamsProtoMsg): _148.Params;
+                    toProto(message: _148.Params): Uint8Array;
+                    toProtoMsg(message: _148.Params): _148.ParamsProtoMsg;
+                };
+            };
+        }
+        namespace commitment {
+            const v1: {
+                MerkleRoot: {
+                    typeUrl: "/ibc.core.commitment.v1.MerkleRoot";
+                    encode(message: _152.MerkleRoot, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _152.MerkleRoot;
+                    fromJSON(object: any): _152.MerkleRoot;
+                    toJSON(message: _152.MerkleRoot): import("../json-safe.ts").JsonSafe<_152.MerkleRoot>;
+                    fromPartial(object: Partial<_152.MerkleRoot>): _152.MerkleRoot;
+                    fromProtoMsg(message: _152.MerkleRootProtoMsg): _152.MerkleRoot;
+                    toProto(message: _152.MerkleRoot): Uint8Array;
+                    toProtoMsg(message: _152.MerkleRoot): _152.MerkleRootProtoMsg;
+                };
+                MerklePrefix: {
+                    typeUrl: "/ibc.core.commitment.v1.MerklePrefix";
+                    encode(message: _152.MerklePrefix, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _152.MerklePrefix;
+                    fromJSON(object: any): _152.MerklePrefix;
+                    toJSON(message: _152.MerklePrefix): import("../json-safe.ts").JsonSafe<_152.MerklePrefix>;
+                    fromPartial(object: Partial<_152.MerklePrefix>): _152.MerklePrefix;
+                    fromProtoMsg(message: _152.MerklePrefixProtoMsg): _152.MerklePrefix;
+                    toProto(message: _152.MerklePrefix): Uint8Array;
+                    toProtoMsg(message: _152.MerklePrefix): _152.MerklePrefixProtoMsg;
+                };
+                MerklePath: {
+                    typeUrl: "/ibc.core.commitment.v1.MerklePath";
+                    encode(message: _152.MerklePath, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _152.MerklePath;
+                    fromJSON(object: any): _152.MerklePath;
+                    toJSON(message: _152.MerklePath): import("../json-safe.ts").JsonSafe<_152.MerklePath>;
+                    fromPartial(object: Partial<_152.MerklePath>): _152.MerklePath;
+                    fromProtoMsg(message: _152.MerklePathProtoMsg): _152.MerklePath;
+                    toProto(message: _152.MerklePath): Uint8Array;
+                    toProtoMsg(message: _152.MerklePath): _152.MerklePathProtoMsg;
+                };
+                MerkleProof: {
+                    typeUrl: "/ibc.core.commitment.v1.MerkleProof";
+                    encode(message: _152.MerkleProof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _152.MerkleProof;
+                    fromJSON(object: any): _152.MerkleProof;
+                    toJSON(message: _152.MerkleProof): import("../json-safe.ts").JsonSafe<_152.MerkleProof>;
+                    fromPartial(object: Partial<_152.MerkleProof>): _152.MerkleProof;
+                    fromProtoMsg(message: _152.MerkleProofProtoMsg): _152.MerkleProof;
+                    toProto(message: _152.MerkleProof): Uint8Array;
+                    toProtoMsg(message: _152.MerkleProof): _152.MerkleProofProtoMsg;
+                };
+            };
+        }
+        namespace connection {
+            const v1: {
+                MsgConnectionOpenInit: {
+                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenInit";
+                    encode(message: _156.MsgConnectionOpenInit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgConnectionOpenInit;
+                    fromJSON(object: any): _156.MsgConnectionOpenInit;
+                    toJSON(message: _156.MsgConnectionOpenInit): import("../json-safe.ts").JsonSafe<_156.MsgConnectionOpenInit>;
+                    fromPartial(object: Partial<_156.MsgConnectionOpenInit>): _156.MsgConnectionOpenInit;
+                    fromProtoMsg(message: _156.MsgConnectionOpenInitProtoMsg): _156.MsgConnectionOpenInit;
+                    toProto(message: _156.MsgConnectionOpenInit): Uint8Array;
+                    toProtoMsg(message: _156.MsgConnectionOpenInit): _156.MsgConnectionOpenInitProtoMsg;
+                };
+                MsgConnectionOpenInitResponse: {
+                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenInitResponse";
+                    encode(_: _156.MsgConnectionOpenInitResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgConnectionOpenInitResponse;
+                    fromJSON(_: any): _156.MsgConnectionOpenInitResponse;
+                    toJSON(_: _156.MsgConnectionOpenInitResponse): import("../json-safe.ts").JsonSafe<_156.MsgConnectionOpenInitResponse>;
+                    fromPartial(_: Partial<_156.MsgConnectionOpenInitResponse>): _156.MsgConnectionOpenInitResponse;
+                    fromProtoMsg(message: _156.MsgConnectionOpenInitResponseProtoMsg): _156.MsgConnectionOpenInitResponse;
+                    toProto(message: _156.MsgConnectionOpenInitResponse): Uint8Array;
+                    toProtoMsg(message: _156.MsgConnectionOpenInitResponse): _156.MsgConnectionOpenInitResponseProtoMsg;
+                };
+                MsgConnectionOpenTry: {
+                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenTry";
+                    encode(message: _156.MsgConnectionOpenTry, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgConnectionOpenTry;
+                    fromJSON(object: any): _156.MsgConnectionOpenTry;
+                    toJSON(message: _156.MsgConnectionOpenTry): import("../json-safe.ts").JsonSafe<_156.MsgConnectionOpenTry>;
+                    fromPartial(object: Partial<_156.MsgConnectionOpenTry>): _156.MsgConnectionOpenTry;
+                    fromProtoMsg(message: _156.MsgConnectionOpenTryProtoMsg): _156.MsgConnectionOpenTry;
+                    toProto(message: _156.MsgConnectionOpenTry): Uint8Array;
+                    toProtoMsg(message: _156.MsgConnectionOpenTry): _156.MsgConnectionOpenTryProtoMsg;
+                };
+                MsgConnectionOpenTryResponse: {
+                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenTryResponse";
+                    encode(_: _156.MsgConnectionOpenTryResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgConnectionOpenTryResponse;
+                    fromJSON(_: any): _156.MsgConnectionOpenTryResponse;
+                    toJSON(_: _156.MsgConnectionOpenTryResponse): import("../json-safe.ts").JsonSafe<_156.MsgConnectionOpenTryResponse>;
+                    fromPartial(_: Partial<_156.MsgConnectionOpenTryResponse>): _156.MsgConnectionOpenTryResponse;
+                    fromProtoMsg(message: _156.MsgConnectionOpenTryResponseProtoMsg): _156.MsgConnectionOpenTryResponse;
+                    toProto(message: _156.MsgConnectionOpenTryResponse): Uint8Array;
+                    toProtoMsg(message: _156.MsgConnectionOpenTryResponse): _156.MsgConnectionOpenTryResponseProtoMsg;
+                };
+                MsgConnectionOpenAck: {
+                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenAck";
+                    encode(message: _156.MsgConnectionOpenAck, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgConnectionOpenAck;
+                    fromJSON(object: any): _156.MsgConnectionOpenAck;
+                    toJSON(message: _156.MsgConnectionOpenAck): import("../json-safe.ts").JsonSafe<_156.MsgConnectionOpenAck>;
+                    fromPartial(object: Partial<_156.MsgConnectionOpenAck>): _156.MsgConnectionOpenAck;
+                    fromProtoMsg(message: _156.MsgConnectionOpenAckProtoMsg): _156.MsgConnectionOpenAck;
+                    toProto(message: _156.MsgConnectionOpenAck): Uint8Array;
+                    toProtoMsg(message: _156.MsgConnectionOpenAck): _156.MsgConnectionOpenAckProtoMsg;
+                };
+                MsgConnectionOpenAckResponse: {
+                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenAckResponse";
+                    encode(_: _156.MsgConnectionOpenAckResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgConnectionOpenAckResponse;
+                    fromJSON(_: any): _156.MsgConnectionOpenAckResponse;
+                    toJSON(_: _156.MsgConnectionOpenAckResponse): import("../json-safe.ts").JsonSafe<_156.MsgConnectionOpenAckResponse>;
+                    fromPartial(_: Partial<_156.MsgConnectionOpenAckResponse>): _156.MsgConnectionOpenAckResponse;
+                    fromProtoMsg(message: _156.MsgConnectionOpenAckResponseProtoMsg): _156.MsgConnectionOpenAckResponse;
+                    toProto(message: _156.MsgConnectionOpenAckResponse): Uint8Array;
+                    toProtoMsg(message: _156.MsgConnectionOpenAckResponse): _156.MsgConnectionOpenAckResponseProtoMsg;
+                };
+                MsgConnectionOpenConfirm: {
+                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenConfirm";
+                    encode(message: _156.MsgConnectionOpenConfirm, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgConnectionOpenConfirm;
+                    fromJSON(object: any): _156.MsgConnectionOpenConfirm;
+                    toJSON(message: _156.MsgConnectionOpenConfirm): import("../json-safe.ts").JsonSafe<_156.MsgConnectionOpenConfirm>;
+                    fromPartial(object: Partial<_156.MsgConnectionOpenConfirm>): _156.MsgConnectionOpenConfirm;
+                    fromProtoMsg(message: _156.MsgConnectionOpenConfirmProtoMsg): _156.MsgConnectionOpenConfirm;
+                    toProto(message: _156.MsgConnectionOpenConfirm): Uint8Array;
+                    toProtoMsg(message: _156.MsgConnectionOpenConfirm): _156.MsgConnectionOpenConfirmProtoMsg;
+                };
+                MsgConnectionOpenConfirmResponse: {
+                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenConfirmResponse";
+                    encode(_: _156.MsgConnectionOpenConfirmResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgConnectionOpenConfirmResponse;
+                    fromJSON(_: any): _156.MsgConnectionOpenConfirmResponse;
+                    toJSON(_: _156.MsgConnectionOpenConfirmResponse): import("../json-safe.ts").JsonSafe<_156.MsgConnectionOpenConfirmResponse>;
+                    fromPartial(_: Partial<_156.MsgConnectionOpenConfirmResponse>): _156.MsgConnectionOpenConfirmResponse;
+                    fromProtoMsg(message: _156.MsgConnectionOpenConfirmResponseProtoMsg): _156.MsgConnectionOpenConfirmResponse;
+                    toProto(message: _156.MsgConnectionOpenConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _156.MsgConnectionOpenConfirmResponse): _156.MsgConnectionOpenConfirmResponseProtoMsg;
+                };
+                QueryConnectionRequest: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionRequest";
+                    encode(message: _155.QueryConnectionRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionRequest;
+                    fromJSON(object: any): _155.QueryConnectionRequest;
+                    toJSON(message: _155.QueryConnectionRequest): import("../json-safe.ts").JsonSafe<_155.QueryConnectionRequest>;
+                    fromPartial(object: Partial<_155.QueryConnectionRequest>): _155.QueryConnectionRequest;
+                    fromProtoMsg(message: _155.QueryConnectionRequestProtoMsg): _155.QueryConnectionRequest;
+                    toProto(message: _155.QueryConnectionRequest): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionRequest): _155.QueryConnectionRequestProtoMsg;
+                };
+                QueryConnectionResponse: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionResponse";
+                    encode(message: _155.QueryConnectionResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionResponse;
+                    fromJSON(object: any): _155.QueryConnectionResponse;
+                    toJSON(message: _155.QueryConnectionResponse): import("../json-safe.ts").JsonSafe<_155.QueryConnectionResponse>;
+                    fromPartial(object: Partial<_155.QueryConnectionResponse>): _155.QueryConnectionResponse;
+                    fromProtoMsg(message: _155.QueryConnectionResponseProtoMsg): _155.QueryConnectionResponse;
+                    toProto(message: _155.QueryConnectionResponse): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionResponse): _155.QueryConnectionResponseProtoMsg;
+                };
+                QueryConnectionsRequest: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionsRequest";
+                    encode(message: _155.QueryConnectionsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionsRequest;
+                    fromJSON(object: any): _155.QueryConnectionsRequest;
+                    toJSON(message: _155.QueryConnectionsRequest): import("../json-safe.ts").JsonSafe<_155.QueryConnectionsRequest>;
+                    fromPartial(object: Partial<_155.QueryConnectionsRequest>): _155.QueryConnectionsRequest;
+                    fromProtoMsg(message: _155.QueryConnectionsRequestProtoMsg): _155.QueryConnectionsRequest;
+                    toProto(message: _155.QueryConnectionsRequest): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionsRequest): _155.QueryConnectionsRequestProtoMsg;
+                };
+                QueryConnectionsResponse: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionsResponse";
+                    encode(message: _155.QueryConnectionsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionsResponse;
+                    fromJSON(object: any): _155.QueryConnectionsResponse;
+                    toJSON(message: _155.QueryConnectionsResponse): import("../json-safe.ts").JsonSafe<_155.QueryConnectionsResponse>;
+                    fromPartial(object: Partial<_155.QueryConnectionsResponse>): _155.QueryConnectionsResponse;
+                    fromProtoMsg(message: _155.QueryConnectionsResponseProtoMsg): _155.QueryConnectionsResponse;
+                    toProto(message: _155.QueryConnectionsResponse): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionsResponse): _155.QueryConnectionsResponseProtoMsg;
+                };
+                QueryClientConnectionsRequest: {
+                    typeUrl: "/ibc.core.connection.v1.QueryClientConnectionsRequest";
+                    encode(message: _155.QueryClientConnectionsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryClientConnectionsRequest;
+                    fromJSON(object: any): _155.QueryClientConnectionsRequest;
+                    toJSON(message: _155.QueryClientConnectionsRequest): import("../json-safe.ts").JsonSafe<_155.QueryClientConnectionsRequest>;
+                    fromPartial(object: Partial<_155.QueryClientConnectionsRequest>): _155.QueryClientConnectionsRequest;
+                    fromProtoMsg(message: _155.QueryClientConnectionsRequestProtoMsg): _155.QueryClientConnectionsRequest;
+                    toProto(message: _155.QueryClientConnectionsRequest): Uint8Array;
+                    toProtoMsg(message: _155.QueryClientConnectionsRequest): _155.QueryClientConnectionsRequestProtoMsg;
+                };
+                QueryClientConnectionsResponse: {
+                    typeUrl: "/ibc.core.connection.v1.QueryClientConnectionsResponse";
+                    encode(message: _155.QueryClientConnectionsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryClientConnectionsResponse;
+                    fromJSON(object: any): _155.QueryClientConnectionsResponse;
+                    toJSON(message: _155.QueryClientConnectionsResponse): import("../json-safe.ts").JsonSafe<_155.QueryClientConnectionsResponse>;
+                    fromPartial(object: Partial<_155.QueryClientConnectionsResponse>): _155.QueryClientConnectionsResponse;
+                    fromProtoMsg(message: _155.QueryClientConnectionsResponseProtoMsg): _155.QueryClientConnectionsResponse;
+                    toProto(message: _155.QueryClientConnectionsResponse): Uint8Array;
+                    toProtoMsg(message: _155.QueryClientConnectionsResponse): _155.QueryClientConnectionsResponseProtoMsg;
+                };
+                QueryConnectionClientStateRequest: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionClientStateRequest";
+                    encode(message: _155.QueryConnectionClientStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionClientStateRequest;
+                    fromJSON(object: any): _155.QueryConnectionClientStateRequest;
+                    toJSON(message: _155.QueryConnectionClientStateRequest): import("../json-safe.ts").JsonSafe<_155.QueryConnectionClientStateRequest>;
+                    fromPartial(object: Partial<_155.QueryConnectionClientStateRequest>): _155.QueryConnectionClientStateRequest;
+                    fromProtoMsg(message: _155.QueryConnectionClientStateRequestProtoMsg): _155.QueryConnectionClientStateRequest;
+                    toProto(message: _155.QueryConnectionClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionClientStateRequest): _155.QueryConnectionClientStateRequestProtoMsg;
+                };
+                QueryConnectionClientStateResponse: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionClientStateResponse";
+                    encode(message: _155.QueryConnectionClientStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionClientStateResponse;
+                    fromJSON(object: any): _155.QueryConnectionClientStateResponse;
+                    toJSON(message: _155.QueryConnectionClientStateResponse): import("../json-safe.ts").JsonSafe<_155.QueryConnectionClientStateResponse>;
+                    fromPartial(object: Partial<_155.QueryConnectionClientStateResponse>): _155.QueryConnectionClientStateResponse;
+                    fromProtoMsg(message: _155.QueryConnectionClientStateResponseProtoMsg): _155.QueryConnectionClientStateResponse;
+                    toProto(message: _155.QueryConnectionClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionClientStateResponse): _155.QueryConnectionClientStateResponseProtoMsg;
+                };
+                QueryConnectionConsensusStateRequest: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionConsensusStateRequest";
+                    encode(message: _155.QueryConnectionConsensusStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionConsensusStateRequest;
+                    fromJSON(object: any): _155.QueryConnectionConsensusStateRequest;
+                    toJSON(message: _155.QueryConnectionConsensusStateRequest): import("../json-safe.ts").JsonSafe<_155.QueryConnectionConsensusStateRequest>;
+                    fromPartial(object: Partial<_155.QueryConnectionConsensusStateRequest>): _155.QueryConnectionConsensusStateRequest;
+                    fromProtoMsg(message: _155.QueryConnectionConsensusStateRequestProtoMsg): _155.QueryConnectionConsensusStateRequest;
+                    toProto(message: _155.QueryConnectionConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionConsensusStateRequest): _155.QueryConnectionConsensusStateRequestProtoMsg;
+                };
+                QueryConnectionConsensusStateResponse: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionConsensusStateResponse";
+                    encode(message: _155.QueryConnectionConsensusStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionConsensusStateResponse;
+                    fromJSON(object: any): _155.QueryConnectionConsensusStateResponse;
+                    toJSON(message: _155.QueryConnectionConsensusStateResponse): import("../json-safe.ts").JsonSafe<_155.QueryConnectionConsensusStateResponse>;
+                    fromPartial(object: Partial<_155.QueryConnectionConsensusStateResponse>): _155.QueryConnectionConsensusStateResponse;
+                    fromProtoMsg(message: _155.QueryConnectionConsensusStateResponseProtoMsg): _155.QueryConnectionConsensusStateResponse;
+                    toProto(message: _155.QueryConnectionConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionConsensusStateResponse): _155.QueryConnectionConsensusStateResponseProtoMsg;
+                };
+                QueryConnectionParamsRequest: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionParamsRequest";
+                    encode(_: _155.QueryConnectionParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionParamsRequest;
+                    fromJSON(_: any): _155.QueryConnectionParamsRequest;
+                    toJSON(_: _155.QueryConnectionParamsRequest): import("../json-safe.ts").JsonSafe<_155.QueryConnectionParamsRequest>;
+                    fromPartial(_: Partial<_155.QueryConnectionParamsRequest>): _155.QueryConnectionParamsRequest;
+                    fromProtoMsg(message: _155.QueryConnectionParamsRequestProtoMsg): _155.QueryConnectionParamsRequest;
+                    toProto(message: _155.QueryConnectionParamsRequest): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionParamsRequest): _155.QueryConnectionParamsRequestProtoMsg;
+                };
+                QueryConnectionParamsResponse: {
+                    typeUrl: "/ibc.core.connection.v1.QueryConnectionParamsResponse";
+                    encode(message: _155.QueryConnectionParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionParamsResponse;
+                    fromJSON(object: any): _155.QueryConnectionParamsResponse;
+                    toJSON(message: _155.QueryConnectionParamsResponse): import("../json-safe.ts").JsonSafe<_155.QueryConnectionParamsResponse>;
+                    fromPartial(object: Partial<_155.QueryConnectionParamsResponse>): _155.QueryConnectionParamsResponse;
+                    fromProtoMsg(message: _155.QueryConnectionParamsResponseProtoMsg): _155.QueryConnectionParamsResponse;
+                    toProto(message: _155.QueryConnectionParamsResponse): Uint8Array;
+                    toProtoMsg(message: _155.QueryConnectionParamsResponse): _155.QueryConnectionParamsResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: "/ibc.core.connection.v1.GenesisState";
+                    encode(message: _154.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _154.GenesisState;
+                    fromJSON(object: any): _154.GenesisState;
+                    toJSON(message: _154.GenesisState): import("../json-safe.ts").JsonSafe<_154.GenesisState>;
+                    fromPartial(object: Partial<_154.GenesisState>): _154.GenesisState;
+                    fromProtoMsg(message: _154.GenesisStateProtoMsg): _154.GenesisState;
+                    toProto(message: _154.GenesisState): Uint8Array;
+                    toProtoMsg(message: _154.GenesisState): _154.GenesisStateProtoMsg;
+                };
+                stateFromJSON(object: any): _153.State;
+                stateToJSON(object: _153.State): string;
+                State: typeof _153.State;
+                StateSDKType: typeof _153.State;
+                ConnectionEnd: {
+                    typeUrl: "/ibc.core.connection.v1.ConnectionEnd";
+                    encode(message: _153.ConnectionEnd, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.ConnectionEnd;
+                    fromJSON(object: any): _153.ConnectionEnd;
+                    toJSON(message: _153.ConnectionEnd): import("../json-safe.ts").JsonSafe<_153.ConnectionEnd>;
+                    fromPartial(object: Partial<_153.ConnectionEnd>): _153.ConnectionEnd;
+                    fromProtoMsg(message: _153.ConnectionEndProtoMsg): _153.ConnectionEnd;
+                    toProto(message: _153.ConnectionEnd): Uint8Array;
+                    toProtoMsg(message: _153.ConnectionEnd): _153.ConnectionEndProtoMsg;
+                };
+                IdentifiedConnection: {
+                    typeUrl: "/ibc.core.connection.v1.IdentifiedConnection";
+                    encode(message: _153.IdentifiedConnection, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.IdentifiedConnection;
+                    fromJSON(object: any): _153.IdentifiedConnection;
+                    toJSON(message: _153.IdentifiedConnection): import("../json-safe.ts").JsonSafe<_153.IdentifiedConnection>;
+                    fromPartial(object: Partial<_153.IdentifiedConnection>): _153.IdentifiedConnection;
+                    fromProtoMsg(message: _153.IdentifiedConnectionProtoMsg): _153.IdentifiedConnection;
+                    toProto(message: _153.IdentifiedConnection): Uint8Array;
+                    toProtoMsg(message: _153.IdentifiedConnection): _153.IdentifiedConnectionProtoMsg;
+                };
+                Counterparty: {
+                    typeUrl: "/ibc.core.connection.v1.Counterparty";
+                    encode(message: _153.Counterparty, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Counterparty;
+                    fromJSON(object: any): _153.Counterparty;
+                    toJSON(message: _153.Counterparty): import("../json-safe.ts").JsonSafe<_153.Counterparty>;
+                    fromPartial(object: Partial<_153.Counterparty>): _153.Counterparty;
+                    fromProtoMsg(message: _153.CounterpartyProtoMsg): _153.Counterparty;
+                    toProto(message: _153.Counterparty): Uint8Array;
+                    toProtoMsg(message: _153.Counterparty): _153.CounterpartyProtoMsg;
+                };
+                ClientPaths: {
+                    typeUrl: "/ibc.core.connection.v1.ClientPaths";
+                    encode(message: _153.ClientPaths, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.ClientPaths;
+                    fromJSON(object: any): _153.ClientPaths;
+                    toJSON(message: _153.ClientPaths): import("../json-safe.ts").JsonSafe<_153.ClientPaths>;
+                    fromPartial(object: Partial<_153.ClientPaths>): _153.ClientPaths;
+                    fromProtoMsg(message: _153.ClientPathsProtoMsg): _153.ClientPaths;
+                    toProto(message: _153.ClientPaths): Uint8Array;
+                    toProtoMsg(message: _153.ClientPaths): _153.ClientPathsProtoMsg;
+                };
+                ConnectionPaths: {
+                    typeUrl: "/ibc.core.connection.v1.ConnectionPaths";
+                    encode(message: _153.ConnectionPaths, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.ConnectionPaths;
+                    fromJSON(object: any): _153.ConnectionPaths;
+                    toJSON(message: _153.ConnectionPaths): import("../json-safe.ts").JsonSafe<_153.ConnectionPaths>;
+                    fromPartial(object: Partial<_153.ConnectionPaths>): _153.ConnectionPaths;
+                    fromProtoMsg(message: _153.ConnectionPathsProtoMsg): _153.ConnectionPaths;
+                    toProto(message: _153.ConnectionPaths): Uint8Array;
+                    toProtoMsg(message: _153.ConnectionPaths): _153.ConnectionPathsProtoMsg;
+                };
+                Version: {
+                    typeUrl: "/ibc.core.connection.v1.Version";
+                    encode(message: _153.Version, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Version;
+                    fromJSON(object: any): _153.Version;
+                    toJSON(message: _153.Version): import("../json-safe.ts").JsonSafe<_153.Version>;
+                    fromPartial(object: Partial<_153.Version>): _153.Version;
+                    fromProtoMsg(message: _153.VersionProtoMsg): _153.Version;
+                    toProto(message: _153.Version): Uint8Array;
+                    toProtoMsg(message: _153.Version): _153.VersionProtoMsg;
+                };
+                Params: {
+                    typeUrl: "/ibc.core.connection.v1.Params";
+                    encode(message: _153.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Params;
+                    fromJSON(object: any): _153.Params;
+                    toJSON(message: _153.Params): import("../json-safe.ts").JsonSafe<_153.Params>;
+                    fromPartial(object: Partial<_153.Params>): _153.Params;
+                    fromProtoMsg(message: _153.ParamsProtoMsg): _153.Params;
+                    toProto(message: _153.Params): Uint8Array;
+                    toProtoMsg(message: _153.Params): _153.ParamsProtoMsg;
+                };
+            };
+        }
+    }
+    namespace lightclients {
+        namespace localhost {
+            const v1: {
+                ClientState: {
+                    typeUrl: "/ibc.lightclients.localhost.v1.ClientState";
+                    encode(message: _157.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _157.ClientState;
+                    fromJSON(object: any): _157.ClientState;
+                    toJSON(message: _157.ClientState): import("../json-safe.ts").JsonSafe<_157.ClientState>;
+                    fromPartial(object: Partial<_157.ClientState>): _157.ClientState;
+                    fromProtoMsg(message: _157.ClientStateProtoMsg): _157.ClientState;
+                    toProto(message: _157.ClientState): Uint8Array;
+                    toProtoMsg(message: _157.ClientState): _157.ClientStateProtoMsg;
+                };
+            };
+            const v2: {
+                ClientState: {
+                    typeUrl: "/ibc.lightclients.localhost.v2.ClientState";
+                    encode(message: _158.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _158.ClientState;
+                    fromJSON(object: any): _158.ClientState;
+                    toJSON(message: _158.ClientState): import("../json-safe.ts").JsonSafe<_158.ClientState>;
+                    fromPartial(object: Partial<_158.ClientState>): _158.ClientState;
+                    fromProtoMsg(message: _158.ClientStateProtoMsg): _158.ClientState;
+                    toProto(message: _158.ClientState): Uint8Array;
+                    toProtoMsg(message: _158.ClientState): _158.ClientStateProtoMsg;
+                };
+            };
+        }
+        namespace solomachine {
+            const v1: {
+                dataTypeFromJSON(object: any): _159.DataType;
+                dataTypeToJSON(object: _159.DataType): string;
+                DataType: typeof _159.DataType;
+                DataTypeSDKType: typeof _159.DataType;
+                ClientState: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.ClientState";
+                    encode(message: _159.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.ClientState;
+                    fromJSON(object: any): _159.ClientState;
+                    toJSON(message: _159.ClientState): import("../json-safe.ts").JsonSafe<_159.ClientState>;
+                    fromPartial(object: Partial<_159.ClientState>): _159.ClientState;
+                    fromProtoMsg(message: _159.ClientStateProtoMsg): _159.ClientState;
+                    toProto(message: _159.ClientState): Uint8Array;
+                    toProtoMsg(message: _159.ClientState): _159.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.ConsensusState";
+                    encode(message: _159.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.ConsensusState;
+                    fromJSON(object: any): _159.ConsensusState;
+                    toJSON(message: _159.ConsensusState): import("../json-safe.ts").JsonSafe<_159.ConsensusState>;
+                    fromPartial(object: Partial<_159.ConsensusState>): _159.ConsensusState;
+                    fromProtoMsg(message: _159.ConsensusStateProtoMsg): _159.ConsensusState;
+                    toProto(message: _159.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _159.ConsensusState): _159.ConsensusStateProtoMsg;
+                };
+                Header: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.Header";
+                    encode(message: _159.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.Header;
+                    fromJSON(object: any): _159.Header;
+                    toJSON(message: _159.Header): import("../json-safe.ts").JsonSafe<_159.Header>;
+                    fromPartial(object: Partial<_159.Header>): _159.Header;
+                    fromProtoMsg(message: _159.HeaderProtoMsg): _159.Header;
+                    toProto(message: _159.Header): Uint8Array;
+                    toProtoMsg(message: _159.Header): _159.HeaderProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.Misbehaviour";
+                    encode(message: _159.Misbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.Misbehaviour;
+                    fromJSON(object: any): _159.Misbehaviour;
+                    toJSON(message: _159.Misbehaviour): import("../json-safe.ts").JsonSafe<_159.Misbehaviour>;
+                    fromPartial(object: Partial<_159.Misbehaviour>): _159.Misbehaviour;
+                    fromProtoMsg(message: _159.MisbehaviourProtoMsg): _159.Misbehaviour;
+                    toProto(message: _159.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _159.Misbehaviour): _159.MisbehaviourProtoMsg;
+                };
+                SignatureAndData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.SignatureAndData";
+                    encode(message: _159.SignatureAndData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.SignatureAndData;
+                    fromJSON(object: any): _159.SignatureAndData;
+                    toJSON(message: _159.SignatureAndData): import("../json-safe.ts").JsonSafe<_159.SignatureAndData>;
+                    fromPartial(object: Partial<_159.SignatureAndData>): _159.SignatureAndData;
+                    fromProtoMsg(message: _159.SignatureAndDataProtoMsg): _159.SignatureAndData;
+                    toProto(message: _159.SignatureAndData): Uint8Array;
+                    toProtoMsg(message: _159.SignatureAndData): _159.SignatureAndDataProtoMsg;
+                };
+                TimestampedSignatureData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.TimestampedSignatureData";
+                    encode(message: _159.TimestampedSignatureData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.TimestampedSignatureData;
+                    fromJSON(object: any): _159.TimestampedSignatureData;
+                    toJSON(message: _159.TimestampedSignatureData): import("../json-safe.ts").JsonSafe<_159.TimestampedSignatureData>;
+                    fromPartial(object: Partial<_159.TimestampedSignatureData>): _159.TimestampedSignatureData;
+                    fromProtoMsg(message: _159.TimestampedSignatureDataProtoMsg): _159.TimestampedSignatureData;
+                    toProto(message: _159.TimestampedSignatureData): Uint8Array;
+                    toProtoMsg(message: _159.TimestampedSignatureData): _159.TimestampedSignatureDataProtoMsg;
+                };
+                SignBytes: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.SignBytes";
+                    encode(message: _159.SignBytes, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.SignBytes;
+                    fromJSON(object: any): _159.SignBytes;
+                    toJSON(message: _159.SignBytes): import("../json-safe.ts").JsonSafe<_159.SignBytes>;
+                    fromPartial(object: Partial<_159.SignBytes>): _159.SignBytes;
+                    fromProtoMsg(message: _159.SignBytesProtoMsg): _159.SignBytes;
+                    toProto(message: _159.SignBytes): Uint8Array;
+                    toProtoMsg(message: _159.SignBytes): _159.SignBytesProtoMsg;
+                };
+                HeaderData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.HeaderData";
+                    encode(message: _159.HeaderData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.HeaderData;
+                    fromJSON(object: any): _159.HeaderData;
+                    toJSON(message: _159.HeaderData): import("../json-safe.ts").JsonSafe<_159.HeaderData>;
+                    fromPartial(object: Partial<_159.HeaderData>): _159.HeaderData;
+                    fromProtoMsg(message: _159.HeaderDataProtoMsg): _159.HeaderData;
+                    toProto(message: _159.HeaderData): Uint8Array;
+                    toProtoMsg(message: _159.HeaderData): _159.HeaderDataProtoMsg;
+                };
+                ClientStateData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.ClientStateData";
+                    encode(message: _159.ClientStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.ClientStateData;
+                    fromJSON(object: any): _159.ClientStateData;
+                    toJSON(message: _159.ClientStateData): import("../json-safe.ts").JsonSafe<_159.ClientStateData>;
+                    fromPartial(object: Partial<_159.ClientStateData>): _159.ClientStateData;
+                    fromProtoMsg(message: _159.ClientStateDataProtoMsg): _159.ClientStateData;
+                    toProto(message: _159.ClientStateData): Uint8Array;
+                    toProtoMsg(message: _159.ClientStateData): _159.ClientStateDataProtoMsg;
+                };
+                ConsensusStateData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.ConsensusStateData";
+                    encode(message: _159.ConsensusStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.ConsensusStateData;
+                    fromJSON(object: any): _159.ConsensusStateData;
+                    toJSON(message: _159.ConsensusStateData): import("../json-safe.ts").JsonSafe<_159.ConsensusStateData>;
+                    fromPartial(object: Partial<_159.ConsensusStateData>): _159.ConsensusStateData;
+                    fromProtoMsg(message: _159.ConsensusStateDataProtoMsg): _159.ConsensusStateData;
+                    toProto(message: _159.ConsensusStateData): Uint8Array;
+                    toProtoMsg(message: _159.ConsensusStateData): _159.ConsensusStateDataProtoMsg;
+                };
+                ConnectionStateData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.ConnectionStateData";
+                    encode(message: _159.ConnectionStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.ConnectionStateData;
+                    fromJSON(object: any): _159.ConnectionStateData;
+                    toJSON(message: _159.ConnectionStateData): import("../json-safe.ts").JsonSafe<_159.ConnectionStateData>;
+                    fromPartial(object: Partial<_159.ConnectionStateData>): _159.ConnectionStateData;
+                    fromProtoMsg(message: _159.ConnectionStateDataProtoMsg): _159.ConnectionStateData;
+                    toProto(message: _159.ConnectionStateData): Uint8Array;
+                    toProtoMsg(message: _159.ConnectionStateData): _159.ConnectionStateDataProtoMsg;
+                };
+                ChannelStateData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.ChannelStateData";
+                    encode(message: _159.ChannelStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.ChannelStateData;
+                    fromJSON(object: any): _159.ChannelStateData;
+                    toJSON(message: _159.ChannelStateData): import("../json-safe.ts").JsonSafe<_159.ChannelStateData>;
+                    fromPartial(object: Partial<_159.ChannelStateData>): _159.ChannelStateData;
+                    fromProtoMsg(message: _159.ChannelStateDataProtoMsg): _159.ChannelStateData;
+                    toProto(message: _159.ChannelStateData): Uint8Array;
+                    toProtoMsg(message: _159.ChannelStateData): _159.ChannelStateDataProtoMsg;
+                };
+                PacketCommitmentData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.PacketCommitmentData";
+                    encode(message: _159.PacketCommitmentData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.PacketCommitmentData;
+                    fromJSON(object: any): _159.PacketCommitmentData;
+                    toJSON(message: _159.PacketCommitmentData): import("../json-safe.ts").JsonSafe<_159.PacketCommitmentData>;
+                    fromPartial(object: Partial<_159.PacketCommitmentData>): _159.PacketCommitmentData;
+                    fromProtoMsg(message: _159.PacketCommitmentDataProtoMsg): _159.PacketCommitmentData;
+                    toProto(message: _159.PacketCommitmentData): Uint8Array;
+                    toProtoMsg(message: _159.PacketCommitmentData): _159.PacketCommitmentDataProtoMsg;
+                };
+                PacketAcknowledgementData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.PacketAcknowledgementData";
+                    encode(message: _159.PacketAcknowledgementData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.PacketAcknowledgementData;
+                    fromJSON(object: any): _159.PacketAcknowledgementData;
+                    toJSON(message: _159.PacketAcknowledgementData): import("../json-safe.ts").JsonSafe<_159.PacketAcknowledgementData>;
+                    fromPartial(object: Partial<_159.PacketAcknowledgementData>): _159.PacketAcknowledgementData;
+                    fromProtoMsg(message: _159.PacketAcknowledgementDataProtoMsg): _159.PacketAcknowledgementData;
+                    toProto(message: _159.PacketAcknowledgementData): Uint8Array;
+                    toProtoMsg(message: _159.PacketAcknowledgementData): _159.PacketAcknowledgementDataProtoMsg;
+                };
+                PacketReceiptAbsenceData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.PacketReceiptAbsenceData";
+                    encode(message: _159.PacketReceiptAbsenceData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.PacketReceiptAbsenceData;
+                    fromJSON(object: any): _159.PacketReceiptAbsenceData;
+                    toJSON(message: _159.PacketReceiptAbsenceData): import("../json-safe.ts").JsonSafe<_159.PacketReceiptAbsenceData>;
+                    fromPartial(object: Partial<_159.PacketReceiptAbsenceData>): _159.PacketReceiptAbsenceData;
+                    fromProtoMsg(message: _159.PacketReceiptAbsenceDataProtoMsg): _159.PacketReceiptAbsenceData;
+                    toProto(message: _159.PacketReceiptAbsenceData): Uint8Array;
+                    toProtoMsg(message: _159.PacketReceiptAbsenceData): _159.PacketReceiptAbsenceDataProtoMsg;
+                };
+                NextSequenceRecvData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v1.NextSequenceRecvData";
+                    encode(message: _159.NextSequenceRecvData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.NextSequenceRecvData;
+                    fromJSON(object: any): _159.NextSequenceRecvData;
+                    toJSON(message: _159.NextSequenceRecvData): import("../json-safe.ts").JsonSafe<_159.NextSequenceRecvData>;
+                    fromPartial(object: Partial<_159.NextSequenceRecvData>): _159.NextSequenceRecvData;
+                    fromProtoMsg(message: _159.NextSequenceRecvDataProtoMsg): _159.NextSequenceRecvData;
+                    toProto(message: _159.NextSequenceRecvData): Uint8Array;
+                    toProtoMsg(message: _159.NextSequenceRecvData): _159.NextSequenceRecvDataProtoMsg;
+                };
+            };
+            const v2: {
+                dataTypeFromJSON(object: any): _160.DataType;
+                dataTypeToJSON(object: _160.DataType): string;
+                DataType: typeof _160.DataType;
+                DataTypeSDKType: typeof _160.DataType;
+                ClientState: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.ClientState";
+                    encode(message: _160.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.ClientState;
+                    fromJSON(object: any): _160.ClientState;
+                    toJSON(message: _160.ClientState): import("../json-safe.ts").JsonSafe<_160.ClientState>;
+                    fromPartial(object: Partial<_160.ClientState>): _160.ClientState;
+                    fromProtoMsg(message: _160.ClientStateProtoMsg): _160.ClientState;
+                    toProto(message: _160.ClientState): Uint8Array;
+                    toProtoMsg(message: _160.ClientState): _160.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.ConsensusState";
+                    encode(message: _160.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.ConsensusState;
+                    fromJSON(object: any): _160.ConsensusState;
+                    toJSON(message: _160.ConsensusState): import("../json-safe.ts").JsonSafe<_160.ConsensusState>;
+                    fromPartial(object: Partial<_160.ConsensusState>): _160.ConsensusState;
+                    fromProtoMsg(message: _160.ConsensusStateProtoMsg): _160.ConsensusState;
+                    toProto(message: _160.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _160.ConsensusState): _160.ConsensusStateProtoMsg;
+                };
+                Header: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.Header";
+                    encode(message: _160.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.Header;
+                    fromJSON(object: any): _160.Header;
+                    toJSON(message: _160.Header): import("../json-safe.ts").JsonSafe<_160.Header>;
+                    fromPartial(object: Partial<_160.Header>): _160.Header;
+                    fromProtoMsg(message: _160.HeaderProtoMsg): _160.Header;
+                    toProto(message: _160.Header): Uint8Array;
+                    toProtoMsg(message: _160.Header): _160.HeaderProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.Misbehaviour";
+                    encode(message: _160.Misbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.Misbehaviour;
+                    fromJSON(object: any): _160.Misbehaviour;
+                    toJSON(message: _160.Misbehaviour): import("../json-safe.ts").JsonSafe<_160.Misbehaviour>;
+                    fromPartial(object: Partial<_160.Misbehaviour>): _160.Misbehaviour;
+                    fromProtoMsg(message: _160.MisbehaviourProtoMsg): _160.Misbehaviour;
+                    toProto(message: _160.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _160.Misbehaviour): _160.MisbehaviourProtoMsg;
+                };
+                SignatureAndData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.SignatureAndData";
+                    encode(message: _160.SignatureAndData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.SignatureAndData;
+                    fromJSON(object: any): _160.SignatureAndData;
+                    toJSON(message: _160.SignatureAndData): import("../json-safe.ts").JsonSafe<_160.SignatureAndData>;
+                    fromPartial(object: Partial<_160.SignatureAndData>): _160.SignatureAndData;
+                    fromProtoMsg(message: _160.SignatureAndDataProtoMsg): _160.SignatureAndData;
+                    toProto(message: _160.SignatureAndData): Uint8Array;
+                    toProtoMsg(message: _160.SignatureAndData): _160.SignatureAndDataProtoMsg;
+                };
+                TimestampedSignatureData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.TimestampedSignatureData";
+                    encode(message: _160.TimestampedSignatureData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.TimestampedSignatureData;
+                    fromJSON(object: any): _160.TimestampedSignatureData;
+                    toJSON(message: _160.TimestampedSignatureData): import("../json-safe.ts").JsonSafe<_160.TimestampedSignatureData>;
+                    fromPartial(object: Partial<_160.TimestampedSignatureData>): _160.TimestampedSignatureData;
+                    fromProtoMsg(message: _160.TimestampedSignatureDataProtoMsg): _160.TimestampedSignatureData;
+                    toProto(message: _160.TimestampedSignatureData): Uint8Array;
+                    toProtoMsg(message: _160.TimestampedSignatureData): _160.TimestampedSignatureDataProtoMsg;
+                };
+                SignBytes: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.SignBytes";
+                    encode(message: _160.SignBytes, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.SignBytes;
+                    fromJSON(object: any): _160.SignBytes;
+                    toJSON(message: _160.SignBytes): import("../json-safe.ts").JsonSafe<_160.SignBytes>;
+                    fromPartial(object: Partial<_160.SignBytes>): _160.SignBytes;
+                    fromProtoMsg(message: _160.SignBytesProtoMsg): _160.SignBytes;
+                    toProto(message: _160.SignBytes): Uint8Array;
+                    toProtoMsg(message: _160.SignBytes): _160.SignBytesProtoMsg;
+                };
+                HeaderData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.HeaderData";
+                    encode(message: _160.HeaderData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.HeaderData;
+                    fromJSON(object: any): _160.HeaderData;
+                    toJSON(message: _160.HeaderData): import("../json-safe.ts").JsonSafe<_160.HeaderData>;
+                    fromPartial(object: Partial<_160.HeaderData>): _160.HeaderData;
+                    fromProtoMsg(message: _160.HeaderDataProtoMsg): _160.HeaderData;
+                    toProto(message: _160.HeaderData): Uint8Array;
+                    toProtoMsg(message: _160.HeaderData): _160.HeaderDataProtoMsg;
+                };
+                ClientStateData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.ClientStateData";
+                    encode(message: _160.ClientStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.ClientStateData;
+                    fromJSON(object: any): _160.ClientStateData;
+                    toJSON(message: _160.ClientStateData): import("../json-safe.ts").JsonSafe<_160.ClientStateData>;
+                    fromPartial(object: Partial<_160.ClientStateData>): _160.ClientStateData;
+                    fromProtoMsg(message: _160.ClientStateDataProtoMsg): _160.ClientStateData;
+                    toProto(message: _160.ClientStateData): Uint8Array;
+                    toProtoMsg(message: _160.ClientStateData): _160.ClientStateDataProtoMsg;
+                };
+                ConsensusStateData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.ConsensusStateData";
+                    encode(message: _160.ConsensusStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.ConsensusStateData;
+                    fromJSON(object: any): _160.ConsensusStateData;
+                    toJSON(message: _160.ConsensusStateData): import("../json-safe.ts").JsonSafe<_160.ConsensusStateData>;
+                    fromPartial(object: Partial<_160.ConsensusStateData>): _160.ConsensusStateData;
+                    fromProtoMsg(message: _160.ConsensusStateDataProtoMsg): _160.ConsensusStateData;
+                    toProto(message: _160.ConsensusStateData): Uint8Array;
+                    toProtoMsg(message: _160.ConsensusStateData): _160.ConsensusStateDataProtoMsg;
+                };
+                ConnectionStateData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.ConnectionStateData";
+                    encode(message: _160.ConnectionStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.ConnectionStateData;
+                    fromJSON(object: any): _160.ConnectionStateData;
+                    toJSON(message: _160.ConnectionStateData): import("../json-safe.ts").JsonSafe<_160.ConnectionStateData>;
+                    fromPartial(object: Partial<_160.ConnectionStateData>): _160.ConnectionStateData;
+                    fromProtoMsg(message: _160.ConnectionStateDataProtoMsg): _160.ConnectionStateData;
+                    toProto(message: _160.ConnectionStateData): Uint8Array;
+                    toProtoMsg(message: _160.ConnectionStateData): _160.ConnectionStateDataProtoMsg;
+                };
+                ChannelStateData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.ChannelStateData";
+                    encode(message: _160.ChannelStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.ChannelStateData;
+                    fromJSON(object: any): _160.ChannelStateData;
+                    toJSON(message: _160.ChannelStateData): import("../json-safe.ts").JsonSafe<_160.ChannelStateData>;
+                    fromPartial(object: Partial<_160.ChannelStateData>): _160.ChannelStateData;
+                    fromProtoMsg(message: _160.ChannelStateDataProtoMsg): _160.ChannelStateData;
+                    toProto(message: _160.ChannelStateData): Uint8Array;
+                    toProtoMsg(message: _160.ChannelStateData): _160.ChannelStateDataProtoMsg;
+                };
+                PacketCommitmentData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.PacketCommitmentData";
+                    encode(message: _160.PacketCommitmentData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.PacketCommitmentData;
+                    fromJSON(object: any): _160.PacketCommitmentData;
+                    toJSON(message: _160.PacketCommitmentData): import("../json-safe.ts").JsonSafe<_160.PacketCommitmentData>;
+                    fromPartial(object: Partial<_160.PacketCommitmentData>): _160.PacketCommitmentData;
+                    fromProtoMsg(message: _160.PacketCommitmentDataProtoMsg): _160.PacketCommitmentData;
+                    toProto(message: _160.PacketCommitmentData): Uint8Array;
+                    toProtoMsg(message: _160.PacketCommitmentData): _160.PacketCommitmentDataProtoMsg;
+                };
+                PacketAcknowledgementData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.PacketAcknowledgementData";
+                    encode(message: _160.PacketAcknowledgementData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.PacketAcknowledgementData;
+                    fromJSON(object: any): _160.PacketAcknowledgementData;
+                    toJSON(message: _160.PacketAcknowledgementData): import("../json-safe.ts").JsonSafe<_160.PacketAcknowledgementData>;
+                    fromPartial(object: Partial<_160.PacketAcknowledgementData>): _160.PacketAcknowledgementData;
+                    fromProtoMsg(message: _160.PacketAcknowledgementDataProtoMsg): _160.PacketAcknowledgementData;
+                    toProto(message: _160.PacketAcknowledgementData): Uint8Array;
+                    toProtoMsg(message: _160.PacketAcknowledgementData): _160.PacketAcknowledgementDataProtoMsg;
+                };
+                PacketReceiptAbsenceData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData";
+                    encode(message: _160.PacketReceiptAbsenceData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.PacketReceiptAbsenceData;
+                    fromJSON(object: any): _160.PacketReceiptAbsenceData;
+                    toJSON(message: _160.PacketReceiptAbsenceData): import("../json-safe.ts").JsonSafe<_160.PacketReceiptAbsenceData>;
+                    fromPartial(object: Partial<_160.PacketReceiptAbsenceData>): _160.PacketReceiptAbsenceData;
+                    fromProtoMsg(message: _160.PacketReceiptAbsenceDataProtoMsg): _160.PacketReceiptAbsenceData;
+                    toProto(message: _160.PacketReceiptAbsenceData): Uint8Array;
+                    toProtoMsg(message: _160.PacketReceiptAbsenceData): _160.PacketReceiptAbsenceDataProtoMsg;
+                };
+                NextSequenceRecvData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v2.NextSequenceRecvData";
+                    encode(message: _160.NextSequenceRecvData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.NextSequenceRecvData;
+                    fromJSON(object: any): _160.NextSequenceRecvData;
+                    toJSON(message: _160.NextSequenceRecvData): import("../json-safe.ts").JsonSafe<_160.NextSequenceRecvData>;
+                    fromPartial(object: Partial<_160.NextSequenceRecvData>): _160.NextSequenceRecvData;
+                    fromProtoMsg(message: _160.NextSequenceRecvDataProtoMsg): _160.NextSequenceRecvData;
+                    toProto(message: _160.NextSequenceRecvData): Uint8Array;
+                    toProtoMsg(message: _160.NextSequenceRecvData): _160.NextSequenceRecvDataProtoMsg;
+                };
+            };
+            const v3: {
+                ClientState: {
+                    typeUrl: "/ibc.lightclients.solomachine.v3.ClientState";
+                    encode(message: _161.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.ClientState;
+                    fromJSON(object: any): _161.ClientState;
+                    toJSON(message: _161.ClientState): import("../json-safe.ts").JsonSafe<_161.ClientState>;
+                    fromPartial(object: Partial<_161.ClientState>): _161.ClientState;
+                    fromProtoMsg(message: _161.ClientStateProtoMsg): _161.ClientState;
+                    toProto(message: _161.ClientState): Uint8Array;
+                    toProtoMsg(message: _161.ClientState): _161.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: "/ibc.lightclients.solomachine.v3.ConsensusState";
+                    encode(message: _161.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.ConsensusState;
+                    fromJSON(object: any): _161.ConsensusState;
+                    toJSON(message: _161.ConsensusState): import("../json-safe.ts").JsonSafe<_161.ConsensusState>;
+                    fromPartial(object: Partial<_161.ConsensusState>): _161.ConsensusState;
+                    fromProtoMsg(message: _161.ConsensusStateProtoMsg): _161.ConsensusState;
+                    toProto(message: _161.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _161.ConsensusState): _161.ConsensusStateProtoMsg;
+                };
+                Header: {
+                    typeUrl: "/ibc.lightclients.solomachine.v3.Header";
+                    encode(message: _161.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.Header;
+                    fromJSON(object: any): _161.Header;
+                    toJSON(message: _161.Header): import("../json-safe.ts").JsonSafe<_161.Header>;
+                    fromPartial(object: Partial<_161.Header>): _161.Header;
+                    fromProtoMsg(message: _161.HeaderProtoMsg): _161.Header;
+                    toProto(message: _161.Header): Uint8Array;
+                    toProtoMsg(message: _161.Header): _161.HeaderProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: "/ibc.lightclients.solomachine.v3.Misbehaviour";
+                    encode(message: _161.Misbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.Misbehaviour;
+                    fromJSON(object: any): _161.Misbehaviour;
+                    toJSON(message: _161.Misbehaviour): import("../json-safe.ts").JsonSafe<_161.Misbehaviour>;
+                    fromPartial(object: Partial<_161.Misbehaviour>): _161.Misbehaviour;
+                    fromProtoMsg(message: _161.MisbehaviourProtoMsg): _161.Misbehaviour;
+                    toProto(message: _161.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _161.Misbehaviour): _161.MisbehaviourProtoMsg;
+                };
+                SignatureAndData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v3.SignatureAndData";
+                    encode(message: _161.SignatureAndData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.SignatureAndData;
+                    fromJSON(object: any): _161.SignatureAndData;
+                    toJSON(message: _161.SignatureAndData): import("../json-safe.ts").JsonSafe<_161.SignatureAndData>;
+                    fromPartial(object: Partial<_161.SignatureAndData>): _161.SignatureAndData;
+                    fromProtoMsg(message: _161.SignatureAndDataProtoMsg): _161.SignatureAndData;
+                    toProto(message: _161.SignatureAndData): Uint8Array;
+                    toProtoMsg(message: _161.SignatureAndData): _161.SignatureAndDataProtoMsg;
+                };
+                TimestampedSignatureData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v3.TimestampedSignatureData";
+                    encode(message: _161.TimestampedSignatureData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.TimestampedSignatureData;
+                    fromJSON(object: any): _161.TimestampedSignatureData;
+                    toJSON(message: _161.TimestampedSignatureData): import("../json-safe.ts").JsonSafe<_161.TimestampedSignatureData>;
+                    fromPartial(object: Partial<_161.TimestampedSignatureData>): _161.TimestampedSignatureData;
+                    fromProtoMsg(message: _161.TimestampedSignatureDataProtoMsg): _161.TimestampedSignatureData;
+                    toProto(message: _161.TimestampedSignatureData): Uint8Array;
+                    toProtoMsg(message: _161.TimestampedSignatureData): _161.TimestampedSignatureDataProtoMsg;
+                };
+                SignBytes: {
+                    typeUrl: "/ibc.lightclients.solomachine.v3.SignBytes";
+                    encode(message: _161.SignBytes, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.SignBytes;
+                    fromJSON(object: any): _161.SignBytes;
+                    toJSON(message: _161.SignBytes): import("../json-safe.ts").JsonSafe<_161.SignBytes>;
+                    fromPartial(object: Partial<_161.SignBytes>): _161.SignBytes;
+                    fromProtoMsg(message: _161.SignBytesProtoMsg): _161.SignBytes;
+                    toProto(message: _161.SignBytes): Uint8Array;
+                    toProtoMsg(message: _161.SignBytes): _161.SignBytesProtoMsg;
+                };
+                HeaderData: {
+                    typeUrl: "/ibc.lightclients.solomachine.v3.HeaderData";
+                    encode(message: _161.HeaderData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.HeaderData;
+                    fromJSON(object: any): _161.HeaderData;
+                    toJSON(message: _161.HeaderData): import("../json-safe.ts").JsonSafe<_161.HeaderData>;
+                    fromPartial(object: Partial<_161.HeaderData>): _161.HeaderData;
+                    fromProtoMsg(message: _161.HeaderDataProtoMsg): _161.HeaderData;
+                    toProto(message: _161.HeaderData): Uint8Array;
+                    toProtoMsg(message: _161.HeaderData): _161.HeaderDataProtoMsg;
+                };
+            };
+        }
+        namespace tendermint {
+            const v1: {
+                ClientState: {
+                    typeUrl: "/ibc.lightclients.tendermint.v1.ClientState";
+                    encode(message: _162.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.ClientState;
+                    fromJSON(object: any): _162.ClientState;
+                    toJSON(message: _162.ClientState): import("../json-safe.ts").JsonSafe<_162.ClientState>;
+                    fromPartial(object: Partial<_162.ClientState>): _162.ClientState;
+                    fromProtoMsg(message: _162.ClientStateProtoMsg): _162.ClientState;
+                    toProto(message: _162.ClientState): Uint8Array;
+                    toProtoMsg(message: _162.ClientState): _162.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: "/ibc.lightclients.tendermint.v1.ConsensusState";
+                    encode(message: _162.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.ConsensusState;
+                    fromJSON(object: any): _162.ConsensusState;
+                    toJSON(message: _162.ConsensusState): import("../json-safe.ts").JsonSafe<_162.ConsensusState>;
+                    fromPartial(object: Partial<_162.ConsensusState>): _162.ConsensusState;
+                    fromProtoMsg(message: _162.ConsensusStateProtoMsg): _162.ConsensusState;
+                    toProto(message: _162.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _162.ConsensusState): _162.ConsensusStateProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: "/ibc.lightclients.tendermint.v1.Misbehaviour";
+                    encode(message: _162.Misbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.Misbehaviour;
+                    fromJSON(object: any): _162.Misbehaviour;
+                    toJSON(message: _162.Misbehaviour): import("../json-safe.ts").JsonSafe<_162.Misbehaviour>;
+                    fromPartial(object: Partial<_162.Misbehaviour>): _162.Misbehaviour;
+                    fromProtoMsg(message: _162.MisbehaviourProtoMsg): _162.Misbehaviour;
+                    toProto(message: _162.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _162.Misbehaviour): _162.MisbehaviourProtoMsg;
+                };
+                Header: {
+                    typeUrl: "/ibc.lightclients.tendermint.v1.Header";
+                    encode(message: _162.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.Header;
+                    fromJSON(object: any): _162.Header;
+                    toJSON(message: _162.Header): import("../json-safe.ts").JsonSafe<_162.Header>;
+                    fromPartial(object: Partial<_162.Header>): _162.Header;
+                    fromProtoMsg(message: _162.HeaderProtoMsg): _162.Header;
+                    toProto(message: _162.Header): Uint8Array;
+                    toProtoMsg(message: _162.Header): _162.HeaderProtoMsg;
+                };
+                Fraction: {
+                    typeUrl: "/ibc.lightclients.tendermint.v1.Fraction";
+                    encode(message: _162.Fraction, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.Fraction;
+                    fromJSON(object: any): _162.Fraction;
+                    toJSON(message: _162.Fraction): import("../json-safe.ts").JsonSafe<_162.Fraction>;
+                    fromPartial(object: Partial<_162.Fraction>): _162.Fraction;
+                    fromProtoMsg(message: _162.FractionProtoMsg): _162.Fraction;
+                    toProto(message: _162.Fraction): Uint8Array;
+                    toProtoMsg(message: _162.Fraction): _162.FractionProtoMsg;
                 };
             };
         }
     }
 }
+//# sourceMappingURL=bundle.d.ts.map