@agoric/client-utils 0.1.1-dev-763bc10.0.763bc10 → 0.1.1-dev-bcbee89.0.bcbee89

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

@@ -0,0 +1,2862 @@
+import * as _130 from './applications/interchain_accounts/controller/v1/controller.js';
+import * as _131 from './applications/interchain_accounts/controller/v1/query.js';
+import * as _132 from './applications/interchain_accounts/controller/v1/tx.js';
+import * as _133 from './applications/interchain_accounts/genesis/v1/genesis.js';
+import * as _134 from './applications/interchain_accounts/host/v1/host.js';
+import * as _135 from './applications/interchain_accounts/host/v1/query.js';
+import * as _136 from './applications/interchain_accounts/host/v1/tx.js';
+import * as _137 from './applications/interchain_accounts/v1/account.js';
+import * as _138 from './applications/interchain_accounts/v1/metadata.js';
+import * as _139 from './applications/interchain_accounts/v1/packet.js';
+import * as _140 from './applications/transfer/v1/authz.js';
+import * as _141 from './applications/transfer/v1/genesis.js';
+import * as _142 from './applications/transfer/v1/query.js';
+import * as _143 from './applications/transfer/v1/transfer.js';
+import * as _144 from './applications/transfer/v1/tx.js';
+import * as _145 from './applications/transfer/v2/packet.js';
+import * as _146 from './core/channel/v1/channel.js';
+import * as _147 from './core/channel/v1/genesis.js';
+import * as _148 from './core/channel/v1/query.js';
+import * as _149 from './core/channel/v1/tx.js';
+import * as _150 from './core/client/v1/client.js';
+import * as _151 from './core/client/v1/genesis.js';
+import * as _152 from './core/client/v1/query.js';
+import * as _153 from './core/client/v1/tx.js';
+import * as _154 from './core/commitment/v1/commitment.js';
+import * as _155 from './core/connection/v1/connection.js';
+import * as _156 from './core/connection/v1/genesis.js';
+import * as _157 from './core/connection/v1/query.js';
+import * as _158 from './core/connection/v1/tx.js';
+import * as _159 from './lightclients/localhost/v1/localhost.js';
+import * as _160 from './lightclients/localhost/v2/localhost.js';
+import * as _161 from './lightclients/solomachine/v1/solomachine.js';
+import * as _162 from './lightclients/solomachine/v2/solomachine.js';
+import * as _163 from './lightclients/solomachine/v3/solomachine.js';
+import * as _164 from './lightclients/tendermint/v1/tendermint.js';
+import * as _249 from './applications/interchain_accounts/controller/v1/query.rpc.Query.js';
+import * as _250 from './applications/interchain_accounts/host/v1/query.rpc.Query.js';
+import * as _251 from './applications/transfer/v1/query.rpc.Query.js';
+import * as _252 from './core/channel/v1/query.rpc.Query.js';
+import * as _253 from './core/client/v1/query.rpc.Query.js';
+import * as _254 from './core/connection/v1/query.rpc.Query.js';
+import * as _255 from './applications/interchain_accounts/controller/v1/tx.rpc.msg.js';
+import * as _256 from './applications/interchain_accounts/host/v1/tx.rpc.msg.js';
+import * as _257 from './applications/transfer/v1/tx.rpc.msg.js';
+import * as _258 from './core/channel/v1/tx.rpc.msg.js';
+import * as _259 from './core/client/v1/tx.rpc.msg.js';
+import * as _260 from './core/connection/v1/tx.rpc.msg.js';
+export declare namespace ibc {
+    namespace applications {
+        namespace interchain_accounts {
+            namespace controller {
+                const v1: {
+                    MsgClientImpl: typeof _255.MsgClientImpl;
+                    QueryClientImpl: typeof _249.QueryClientImpl;
+                    createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                        interchainAccount(request: _131.QueryInterchainAccountRequest): Promise<_131.QueryInterchainAccountResponse>;
+                        params(request?: _131.QueryParamsRequest): Promise<_131.QueryParamsResponse>;
+                    };
+                    MsgRegisterInterchainAccount: {
+                        typeUrl: string;
+                        encode(message: _132.MsgRegisterInterchainAccount, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.MsgRegisterInterchainAccount;
+                        fromJSON(object: any): _132.MsgRegisterInterchainAccount;
+                        toJSON(message: _132.MsgRegisterInterchainAccount): import("../json-safe.js").JsonSafe<_132.MsgRegisterInterchainAccount>;
+                        fromPartial(object: Partial<_132.MsgRegisterInterchainAccount>): _132.MsgRegisterInterchainAccount;
+                        fromProtoMsg(message: _132.MsgRegisterInterchainAccountProtoMsg): _132.MsgRegisterInterchainAccount;
+                        toProto(message: _132.MsgRegisterInterchainAccount): Uint8Array;
+                        toProtoMsg(message: _132.MsgRegisterInterchainAccount): _132.MsgRegisterInterchainAccountProtoMsg;
+                    };
+                    MsgRegisterInterchainAccountResponse: {
+                        typeUrl: string;
+                        encode(message: _132.MsgRegisterInterchainAccountResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.MsgRegisterInterchainAccountResponse;
+                        fromJSON(object: any): _132.MsgRegisterInterchainAccountResponse;
+                        toJSON(message: _132.MsgRegisterInterchainAccountResponse): import("../json-safe.js").JsonSafe<_132.MsgRegisterInterchainAccountResponse>;
+                        fromPartial(object: Partial<_132.MsgRegisterInterchainAccountResponse>): _132.MsgRegisterInterchainAccountResponse;
+                        fromProtoMsg(message: _132.MsgRegisterInterchainAccountResponseProtoMsg): _132.MsgRegisterInterchainAccountResponse;
+                        toProto(message: _132.MsgRegisterInterchainAccountResponse): Uint8Array;
+                        toProtoMsg(message: _132.MsgRegisterInterchainAccountResponse): _132.MsgRegisterInterchainAccountResponseProtoMsg;
+                    };
+                    MsgSendTx: {
+                        typeUrl: string;
+                        encode(message: _132.MsgSendTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.MsgSendTx;
+                        fromJSON(object: any): _132.MsgSendTx;
+                        toJSON(message: _132.MsgSendTx): import("../json-safe.js").JsonSafe<_132.MsgSendTx>;
+                        fromPartial(object: Partial<_132.MsgSendTx>): _132.MsgSendTx;
+                        fromProtoMsg(message: _132.MsgSendTxProtoMsg): _132.MsgSendTx;
+                        toProto(message: _132.MsgSendTx): Uint8Array;
+                        toProtoMsg(message: _132.MsgSendTx): _132.MsgSendTxProtoMsg;
+                    };
+                    MsgSendTxResponse: {
+                        typeUrl: string;
+                        encode(message: _132.MsgSendTxResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.MsgSendTxResponse;
+                        fromJSON(object: any): _132.MsgSendTxResponse;
+                        toJSON(message: _132.MsgSendTxResponse): import("../json-safe.js").JsonSafe<_132.MsgSendTxResponse>;
+                        fromPartial(object: Partial<_132.MsgSendTxResponse>): _132.MsgSendTxResponse;
+                        fromProtoMsg(message: _132.MsgSendTxResponseProtoMsg): _132.MsgSendTxResponse;
+                        toProto(message: _132.MsgSendTxResponse): Uint8Array;
+                        toProtoMsg(message: _132.MsgSendTxResponse): _132.MsgSendTxResponseProtoMsg;
+                    };
+                    QueryInterchainAccountRequest: {
+                        typeUrl: string;
+                        encode(message: _131.QueryInterchainAccountRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.QueryInterchainAccountRequest;
+                        fromJSON(object: any): _131.QueryInterchainAccountRequest;
+                        toJSON(message: _131.QueryInterchainAccountRequest): import("../json-safe.js").JsonSafe<_131.QueryInterchainAccountRequest>;
+                        fromPartial(object: Partial<_131.QueryInterchainAccountRequest>): _131.QueryInterchainAccountRequest;
+                        fromProtoMsg(message: _131.QueryInterchainAccountRequestProtoMsg): _131.QueryInterchainAccountRequest;
+                        toProto(message: _131.QueryInterchainAccountRequest): Uint8Array;
+                        toProtoMsg(message: _131.QueryInterchainAccountRequest): _131.QueryInterchainAccountRequestProtoMsg;
+                    };
+                    QueryInterchainAccountResponse: {
+                        typeUrl: string;
+                        encode(message: _131.QueryInterchainAccountResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.QueryInterchainAccountResponse;
+                        fromJSON(object: any): _131.QueryInterchainAccountResponse;
+                        toJSON(message: _131.QueryInterchainAccountResponse): import("../json-safe.js").JsonSafe<_131.QueryInterchainAccountResponse>;
+                        fromPartial(object: Partial<_131.QueryInterchainAccountResponse>): _131.QueryInterchainAccountResponse;
+                        fromProtoMsg(message: _131.QueryInterchainAccountResponseProtoMsg): _131.QueryInterchainAccountResponse;
+                        toProto(message: _131.QueryInterchainAccountResponse): Uint8Array;
+                        toProtoMsg(message: _131.QueryInterchainAccountResponse): _131.QueryInterchainAccountResponseProtoMsg;
+                    };
+                    QueryParamsRequest: {
+                        typeUrl: string;
+                        encode(_: _131.QueryParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.QueryParamsRequest;
+                        fromJSON(_: any): _131.QueryParamsRequest;
+                        toJSON(_: _131.QueryParamsRequest): import("../json-safe.js").JsonSafe<_131.QueryParamsRequest>;
+                        fromPartial(_: Partial<_131.QueryParamsRequest>): _131.QueryParamsRequest;
+                        fromProtoMsg(message: _131.QueryParamsRequestProtoMsg): _131.QueryParamsRequest;
+                        toProto(message: _131.QueryParamsRequest): Uint8Array;
+                        toProtoMsg(message: _131.QueryParamsRequest): _131.QueryParamsRequestProtoMsg;
+                    };
+                    QueryParamsResponse: {
+                        typeUrl: string;
+                        encode(message: _131.QueryParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.QueryParamsResponse;
+                        fromJSON(object: any): _131.QueryParamsResponse;
+                        toJSON(message: _131.QueryParamsResponse): import("../json-safe.js").JsonSafe<_131.QueryParamsResponse>;
+                        fromPartial(object: Partial<_131.QueryParamsResponse>): _131.QueryParamsResponse;
+                        fromProtoMsg(message: _131.QueryParamsResponseProtoMsg): _131.QueryParamsResponse;
+                        toProto(message: _131.QueryParamsResponse): Uint8Array;
+                        toProtoMsg(message: _131.QueryParamsResponse): _131.QueryParamsResponseProtoMsg;
+                    };
+                    Params: {
+                        typeUrl: string;
+                        encode(message: _130.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _130.Params;
+                        fromJSON(object: any): _130.Params;
+                        toJSON(message: _130.Params): import("../json-safe.js").JsonSafe<_130.Params>;
+                        fromPartial(object: Partial<_130.Params>): _130.Params;
+                        fromProtoMsg(message: _130.ParamsProtoMsg): _130.Params;
+                        toProto(message: _130.Params): Uint8Array;
+                        toProtoMsg(message: _130.Params): _130.ParamsProtoMsg;
+                    };
+                };
+            }
+            namespace genesis {
+                const v1: {
+                    GenesisState: {
+                        typeUrl: string;
+                        encode(message: _133.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _133.GenesisState;
+                        fromJSON(object: any): _133.GenesisState;
+                        toJSON(message: _133.GenesisState): import("../json-safe.js").JsonSafe<_133.GenesisState>;
+                        fromPartial(object: Partial<_133.GenesisState>): _133.GenesisState;
+                        fromProtoMsg(message: _133.GenesisStateProtoMsg): _133.GenesisState;
+                        toProto(message: _133.GenesisState): Uint8Array;
+                        toProtoMsg(message: _133.GenesisState): _133.GenesisStateProtoMsg;
+                    };
+                    ControllerGenesisState: {
+                        typeUrl: string;
+                        encode(message: _133.ControllerGenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _133.ControllerGenesisState;
+                        fromJSON(object: any): _133.ControllerGenesisState;
+                        toJSON(message: _133.ControllerGenesisState): import("../json-safe.js").JsonSafe<_133.ControllerGenesisState>;
+                        fromPartial(object: Partial<_133.ControllerGenesisState>): _133.ControllerGenesisState;
+                        fromProtoMsg(message: _133.ControllerGenesisStateProtoMsg): _133.ControllerGenesisState;
+                        toProto(message: _133.ControllerGenesisState): Uint8Array;
+                        toProtoMsg(message: _133.ControllerGenesisState): _133.ControllerGenesisStateProtoMsg;
+                    };
+                    HostGenesisState: {
+                        typeUrl: string;
+                        encode(message: _133.HostGenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _133.HostGenesisState;
+                        fromJSON(object: any): _133.HostGenesisState;
+                        toJSON(message: _133.HostGenesisState): import("../json-safe.js").JsonSafe<_133.HostGenesisState>;
+                        fromPartial(object: Partial<_133.HostGenesisState>): _133.HostGenesisState;
+                        fromProtoMsg(message: _133.HostGenesisStateProtoMsg): _133.HostGenesisState;
+                        toProto(message: _133.HostGenesisState): Uint8Array;
+                        toProtoMsg(message: _133.HostGenesisState): _133.HostGenesisStateProtoMsg;
+                    };
+                    ActiveChannel: {
+                        typeUrl: string;
+                        encode(message: _133.ActiveChannel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _133.ActiveChannel;
+                        fromJSON(object: any): _133.ActiveChannel;
+                        toJSON(message: _133.ActiveChannel): import("../json-safe.js").JsonSafe<_133.ActiveChannel>;
+                        fromPartial(object: Partial<_133.ActiveChannel>): _133.ActiveChannel;
+                        fromProtoMsg(message: _133.ActiveChannelProtoMsg): _133.ActiveChannel;
+                        toProto(message: _133.ActiveChannel): Uint8Array;
+                        toProtoMsg(message: _133.ActiveChannel): _133.ActiveChannelProtoMsg;
+                    };
+                    RegisteredInterchainAccount: {
+                        typeUrl: string;
+                        encode(message: _133.RegisteredInterchainAccount, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _133.RegisteredInterchainAccount;
+                        fromJSON(object: any): _133.RegisteredInterchainAccount;
+                        toJSON(message: _133.RegisteredInterchainAccount): import("../json-safe.js").JsonSafe<_133.RegisteredInterchainAccount>;
+                        fromPartial(object: Partial<_133.RegisteredInterchainAccount>): _133.RegisteredInterchainAccount;
+                        fromProtoMsg(message: _133.RegisteredInterchainAccountProtoMsg): _133.RegisteredInterchainAccount;
+                        toProto(message: _133.RegisteredInterchainAccount): Uint8Array;
+                        toProtoMsg(message: _133.RegisteredInterchainAccount): _133.RegisteredInterchainAccountProtoMsg;
+                    };
+                };
+            }
+            namespace host {
+                const v1: {
+                    MsgClientImpl: typeof _256.MsgClientImpl;
+                    QueryClientImpl: typeof _250.QueryClientImpl;
+                    createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                        params(request?: _135.QueryParamsRequest): Promise<_135.QueryParamsResponse>;
+                    };
+                    MsgModuleQuerySafe: {
+                        typeUrl: string;
+                        encode(message: _136.MsgModuleQuerySafe, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _136.MsgModuleQuerySafe;
+                        fromJSON(object: any): _136.MsgModuleQuerySafe;
+                        toJSON(message: _136.MsgModuleQuerySafe): import("../json-safe.js").JsonSafe<_136.MsgModuleQuerySafe>;
+                        fromPartial(object: Partial<_136.MsgModuleQuerySafe>): _136.MsgModuleQuerySafe;
+                        fromProtoMsg(message: _136.MsgModuleQuerySafeProtoMsg): _136.MsgModuleQuerySafe;
+                        toProto(message: _136.MsgModuleQuerySafe): Uint8Array;
+                        toProtoMsg(message: _136.MsgModuleQuerySafe): _136.MsgModuleQuerySafeProtoMsg;
+                    };
+                    MsgModuleQuerySafeResponse: {
+                        typeUrl: string;
+                        encode(message: _136.MsgModuleQuerySafeResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _136.MsgModuleQuerySafeResponse;
+                        fromJSON(object: any): _136.MsgModuleQuerySafeResponse;
+                        toJSON(message: _136.MsgModuleQuerySafeResponse): import("../json-safe.js").JsonSafe<_136.MsgModuleQuerySafeResponse>;
+                        fromPartial(object: Partial<_136.MsgModuleQuerySafeResponse>): _136.MsgModuleQuerySafeResponse;
+                        fromProtoMsg(message: _136.MsgModuleQuerySafeResponseProtoMsg): _136.MsgModuleQuerySafeResponse;
+                        toProto(message: _136.MsgModuleQuerySafeResponse): Uint8Array;
+                        toProtoMsg(message: _136.MsgModuleQuerySafeResponse): _136.MsgModuleQuerySafeResponseProtoMsg;
+                    };
+                    QueryParamsRequest: {
+                        typeUrl: string;
+                        encode(_: _135.QueryParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _135.QueryParamsRequest;
+                        fromJSON(_: any): _135.QueryParamsRequest;
+                        toJSON(_: _135.QueryParamsRequest): import("../json-safe.js").JsonSafe<_135.QueryParamsRequest>;
+                        fromPartial(_: Partial<_135.QueryParamsRequest>): _135.QueryParamsRequest;
+                        fromProtoMsg(message: _135.QueryParamsRequestProtoMsg): _135.QueryParamsRequest;
+                        toProto(message: _135.QueryParamsRequest): Uint8Array;
+                        toProtoMsg(message: _135.QueryParamsRequest): _135.QueryParamsRequestProtoMsg;
+                    };
+                    QueryParamsResponse: {
+                        typeUrl: string;
+                        encode(message: _135.QueryParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _135.QueryParamsResponse;
+                        fromJSON(object: any): _135.QueryParamsResponse;
+                        toJSON(message: _135.QueryParamsResponse): import("../json-safe.js").JsonSafe<_135.QueryParamsResponse>;
+                        fromPartial(object: Partial<_135.QueryParamsResponse>): _135.QueryParamsResponse;
+                        fromProtoMsg(message: _135.QueryParamsResponseProtoMsg): _135.QueryParamsResponse;
+                        toProto(message: _135.QueryParamsResponse): Uint8Array;
+                        toProtoMsg(message: _135.QueryParamsResponse): _135.QueryParamsResponseProtoMsg;
+                    };
+                    Params: {
+                        typeUrl: string;
+                        encode(message: _134.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _134.Params;
+                        fromJSON(object: any): _134.Params;
+                        toJSON(message: _134.Params): import("../json-safe.js").JsonSafe<_134.Params>;
+                        fromPartial(object: Partial<_134.Params>): _134.Params;
+                        fromProtoMsg(message: _134.ParamsProtoMsg): _134.Params;
+                        toProto(message: _134.Params): Uint8Array;
+                        toProtoMsg(message: _134.Params): _134.ParamsProtoMsg;
+                    };
+                    QueryRequest: {
+                        typeUrl: string;
+                        encode(message: _134.QueryRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                        decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _134.QueryRequest;
+                        fromJSON(object: any): _134.QueryRequest;
+                        toJSON(message: _134.QueryRequest): import("../json-safe.js").JsonSafe<_134.QueryRequest>;
+                        fromPartial(object: Partial<_134.QueryRequest>): _134.QueryRequest;
+                        fromProtoMsg(message: _134.QueryRequestProtoMsg): _134.QueryRequest;
+                        toProto(message: _134.QueryRequest): Uint8Array;
+                        toProtoMsg(message: _134.QueryRequest): _134.QueryRequestProtoMsg;
+                    };
+                };
+            }
+            const v1: {
+                typeFromJSON(object: any): _139.Type;
+                typeToJSON(object: _139.Type): string;
+                Type: typeof _139.Type;
+                TypeSDKType: typeof _139.Type;
+                InterchainAccountPacketData: {
+                    typeUrl: string;
+                    encode(message: _139.InterchainAccountPacketData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _139.InterchainAccountPacketData;
+                    fromJSON(object: any): _139.InterchainAccountPacketData;
+                    toJSON(message: _139.InterchainAccountPacketData): import("../json-safe.js").JsonSafe<_139.InterchainAccountPacketData>;
+                    fromPartial(object: Partial<_139.InterchainAccountPacketData>): _139.InterchainAccountPacketData;
+                    fromProtoMsg(message: _139.InterchainAccountPacketDataProtoMsg): _139.InterchainAccountPacketData;
+                    toProto(message: _139.InterchainAccountPacketData): Uint8Array;
+                    toProtoMsg(message: _139.InterchainAccountPacketData): _139.InterchainAccountPacketDataProtoMsg;
+                };
+                CosmosTx: {
+                    typeUrl: string;
+                    encode(message: _139.CosmosTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _139.CosmosTx;
+                    fromJSON(object: any): _139.CosmosTx;
+                    toJSON(message: _139.CosmosTx): import("../json-safe.js").JsonSafe<_139.CosmosTx>;
+                    fromPartial(object: Partial<_139.CosmosTx>): _139.CosmosTx;
+                    fromProtoMsg(message: _139.CosmosTxProtoMsg): _139.CosmosTx;
+                    toProto(message: _139.CosmosTx): Uint8Array;
+                    toProtoMsg(message: _139.CosmosTx): _139.CosmosTxProtoMsg;
+                };
+                Metadata: {
+                    typeUrl: string;
+                    encode(message: _138.Metadata, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _138.Metadata;
+                    fromJSON(object: any): _138.Metadata;
+                    toJSON(message: _138.Metadata): import("../json-safe.js").JsonSafe<_138.Metadata>;
+                    fromPartial(object: Partial<_138.Metadata>): _138.Metadata;
+                    fromProtoMsg(message: _138.MetadataProtoMsg): _138.Metadata;
+                    toProto(message: _138.Metadata): Uint8Array;
+                    toProtoMsg(message: _138.Metadata): _138.MetadataProtoMsg;
+                };
+                InterchainAccount: {
+                    typeUrl: string;
+                    encode(message: _137.InterchainAccount, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _137.InterchainAccount;
+                    fromJSON(object: any): _137.InterchainAccount;
+                    toJSON(message: _137.InterchainAccount): import("../json-safe.js").JsonSafe<_137.InterchainAccount>;
+                    fromPartial(object: Partial<_137.InterchainAccount>): _137.InterchainAccount;
+                    fromProtoMsg(message: _137.InterchainAccountProtoMsg): _137.InterchainAccount;
+                    toProto(message: _137.InterchainAccount): Uint8Array;
+                    toProtoMsg(message: _137.InterchainAccount): _137.InterchainAccountProtoMsg;
+                };
+            };
+        }
+        namespace transfer {
+            const v1: {
+                MsgClientImpl: typeof _257.MsgClientImpl;
+                QueryClientImpl: typeof _251.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    denomTraces(request?: _142.QueryDenomTracesRequest): Promise<_142.QueryDenomTracesResponse>;
+                    denomTrace(request: _142.QueryDenomTraceRequest): Promise<_142.QueryDenomTraceResponse>;
+                    params(request?: _142.QueryParamsRequest): Promise<_142.QueryParamsResponse>;
+                    denomHash(request: _142.QueryDenomHashRequest): Promise<_142.QueryDenomHashResponse>;
+                    escrowAddress(request: _142.QueryEscrowAddressRequest): Promise<_142.QueryEscrowAddressResponse>;
+                    totalEscrowForDenom(request: _142.QueryTotalEscrowForDenomRequest): Promise<_142.QueryTotalEscrowForDenomResponse>;
+                };
+                MsgTransfer: {
+                    typeUrl: string;
+                    encode(message: _144.MsgTransfer, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _144.MsgTransfer;
+                    fromJSON(object: any): _144.MsgTransfer;
+                    toJSON(message: _144.MsgTransfer): import("../json-safe.js").JsonSafe<_144.MsgTransfer>;
+                    fromPartial(object: Partial<_144.MsgTransfer>): _144.MsgTransfer;
+                    fromProtoMsg(message: _144.MsgTransferProtoMsg): _144.MsgTransfer;
+                    toProto(message: _144.MsgTransfer): Uint8Array;
+                    toProtoMsg(message: _144.MsgTransfer): _144.MsgTransferProtoMsg;
+                };
+                MsgTransferResponse: {
+                    typeUrl: string;
+                    encode(message: _144.MsgTransferResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _144.MsgTransferResponse;
+                    fromJSON(object: any): _144.MsgTransferResponse;
+                    toJSON(message: _144.MsgTransferResponse): import("../json-safe.js").JsonSafe<_144.MsgTransferResponse>;
+                    fromPartial(object: Partial<_144.MsgTransferResponse>): _144.MsgTransferResponse;
+                    fromProtoMsg(message: _144.MsgTransferResponseProtoMsg): _144.MsgTransferResponse;
+                    toProto(message: _144.MsgTransferResponse): Uint8Array;
+                    toProtoMsg(message: _144.MsgTransferResponse): _144.MsgTransferResponseProtoMsg;
+                };
+                DenomTrace: {
+                    typeUrl: string;
+                    encode(message: _143.DenomTrace, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _143.DenomTrace;
+                    fromJSON(object: any): _143.DenomTrace;
+                    toJSON(message: _143.DenomTrace): import("../json-safe.js").JsonSafe<_143.DenomTrace>;
+                    fromPartial(object: Partial<_143.DenomTrace>): _143.DenomTrace;
+                    fromProtoMsg(message: _143.DenomTraceProtoMsg): _143.DenomTrace;
+                    toProto(message: _143.DenomTrace): Uint8Array;
+                    toProtoMsg(message: _143.DenomTrace): _143.DenomTraceProtoMsg;
+                };
+                Params: {
+                    typeUrl: string;
+                    encode(message: _143.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _143.Params;
+                    fromJSON(object: any): _143.Params;
+                    toJSON(message: _143.Params): import("../json-safe.js").JsonSafe<_143.Params>;
+                    fromPartial(object: Partial<_143.Params>): _143.Params;
+                    fromProtoMsg(message: _143.ParamsProtoMsg): _143.Params;
+                    toProto(message: _143.Params): Uint8Array;
+                    toProtoMsg(message: _143.Params): _143.ParamsProtoMsg;
+                };
+                QueryDenomTraceRequest: {
+                    typeUrl: string;
+                    encode(message: _142.QueryDenomTraceRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryDenomTraceRequest;
+                    fromJSON(object: any): _142.QueryDenomTraceRequest;
+                    toJSON(message: _142.QueryDenomTraceRequest): import("../json-safe.js").JsonSafe<_142.QueryDenomTraceRequest>;
+                    fromPartial(object: Partial<_142.QueryDenomTraceRequest>): _142.QueryDenomTraceRequest;
+                    fromProtoMsg(message: _142.QueryDenomTraceRequestProtoMsg): _142.QueryDenomTraceRequest;
+                    toProto(message: _142.QueryDenomTraceRequest): Uint8Array;
+                    toProtoMsg(message: _142.QueryDenomTraceRequest): _142.QueryDenomTraceRequestProtoMsg;
+                };
+                QueryDenomTraceResponse: {
+                    typeUrl: string;
+                    encode(message: _142.QueryDenomTraceResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryDenomTraceResponse;
+                    fromJSON(object: any): _142.QueryDenomTraceResponse;
+                    toJSON(message: _142.QueryDenomTraceResponse): import("../json-safe.js").JsonSafe<_142.QueryDenomTraceResponse>;
+                    fromPartial(object: Partial<_142.QueryDenomTraceResponse>): _142.QueryDenomTraceResponse;
+                    fromProtoMsg(message: _142.QueryDenomTraceResponseProtoMsg): _142.QueryDenomTraceResponse;
+                    toProto(message: _142.QueryDenomTraceResponse): Uint8Array;
+                    toProtoMsg(message: _142.QueryDenomTraceResponse): _142.QueryDenomTraceResponseProtoMsg;
+                };
+                QueryDenomTracesRequest: {
+                    typeUrl: string;
+                    encode(message: _142.QueryDenomTracesRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryDenomTracesRequest;
+                    fromJSON(object: any): _142.QueryDenomTracesRequest;
+                    toJSON(message: _142.QueryDenomTracesRequest): import("../json-safe.js").JsonSafe<_142.QueryDenomTracesRequest>;
+                    fromPartial(object: Partial<_142.QueryDenomTracesRequest>): _142.QueryDenomTracesRequest;
+                    fromProtoMsg(message: _142.QueryDenomTracesRequestProtoMsg): _142.QueryDenomTracesRequest;
+                    toProto(message: _142.QueryDenomTracesRequest): Uint8Array;
+                    toProtoMsg(message: _142.QueryDenomTracesRequest): _142.QueryDenomTracesRequestProtoMsg;
+                };
+                QueryDenomTracesResponse: {
+                    typeUrl: string;
+                    encode(message: _142.QueryDenomTracesResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryDenomTracesResponse;
+                    fromJSON(object: any): _142.QueryDenomTracesResponse;
+                    toJSON(message: _142.QueryDenomTracesResponse): import("../json-safe.js").JsonSafe<_142.QueryDenomTracesResponse>;
+                    fromPartial(object: Partial<_142.QueryDenomTracesResponse>): _142.QueryDenomTracesResponse;
+                    fromProtoMsg(message: _142.QueryDenomTracesResponseProtoMsg): _142.QueryDenomTracesResponse;
+                    toProto(message: _142.QueryDenomTracesResponse): Uint8Array;
+                    toProtoMsg(message: _142.QueryDenomTracesResponse): _142.QueryDenomTracesResponseProtoMsg;
+                };
+                QueryParamsRequest: {
+                    typeUrl: string;
+                    encode(_: _142.QueryParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryParamsRequest;
+                    fromJSON(_: any): _142.QueryParamsRequest;
+                    toJSON(_: _142.QueryParamsRequest): import("../json-safe.js").JsonSafe<_142.QueryParamsRequest>;
+                    fromPartial(_: Partial<_142.QueryParamsRequest>): _142.QueryParamsRequest;
+                    fromProtoMsg(message: _142.QueryParamsRequestProtoMsg): _142.QueryParamsRequest;
+                    toProto(message: _142.QueryParamsRequest): Uint8Array;
+                    toProtoMsg(message: _142.QueryParamsRequest): _142.QueryParamsRequestProtoMsg;
+                };
+                QueryParamsResponse: {
+                    typeUrl: string;
+                    encode(message: _142.QueryParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryParamsResponse;
+                    fromJSON(object: any): _142.QueryParamsResponse;
+                    toJSON(message: _142.QueryParamsResponse): import("../json-safe.js").JsonSafe<_142.QueryParamsResponse>;
+                    fromPartial(object: Partial<_142.QueryParamsResponse>): _142.QueryParamsResponse;
+                    fromProtoMsg(message: _142.QueryParamsResponseProtoMsg): _142.QueryParamsResponse;
+                    toProto(message: _142.QueryParamsResponse): Uint8Array;
+                    toProtoMsg(message: _142.QueryParamsResponse): _142.QueryParamsResponseProtoMsg;
+                };
+                QueryDenomHashRequest: {
+                    typeUrl: string;
+                    encode(message: _142.QueryDenomHashRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryDenomHashRequest;
+                    fromJSON(object: any): _142.QueryDenomHashRequest;
+                    toJSON(message: _142.QueryDenomHashRequest): import("../json-safe.js").JsonSafe<_142.QueryDenomHashRequest>;
+                    fromPartial(object: Partial<_142.QueryDenomHashRequest>): _142.QueryDenomHashRequest;
+                    fromProtoMsg(message: _142.QueryDenomHashRequestProtoMsg): _142.QueryDenomHashRequest;
+                    toProto(message: _142.QueryDenomHashRequest): Uint8Array;
+                    toProtoMsg(message: _142.QueryDenomHashRequest): _142.QueryDenomHashRequestProtoMsg;
+                };
+                QueryDenomHashResponse: {
+                    typeUrl: string;
+                    encode(message: _142.QueryDenomHashResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryDenomHashResponse;
+                    fromJSON(object: any): _142.QueryDenomHashResponse;
+                    toJSON(message: _142.QueryDenomHashResponse): import("../json-safe.js").JsonSafe<_142.QueryDenomHashResponse>;
+                    fromPartial(object: Partial<_142.QueryDenomHashResponse>): _142.QueryDenomHashResponse;
+                    fromProtoMsg(message: _142.QueryDenomHashResponseProtoMsg): _142.QueryDenomHashResponse;
+                    toProto(message: _142.QueryDenomHashResponse): Uint8Array;
+                    toProtoMsg(message: _142.QueryDenomHashResponse): _142.QueryDenomHashResponseProtoMsg;
+                };
+                QueryEscrowAddressRequest: {
+                    typeUrl: string;
+                    encode(message: _142.QueryEscrowAddressRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryEscrowAddressRequest;
+                    fromJSON(object: any): _142.QueryEscrowAddressRequest;
+                    toJSON(message: _142.QueryEscrowAddressRequest): import("../json-safe.js").JsonSafe<_142.QueryEscrowAddressRequest>;
+                    fromPartial(object: Partial<_142.QueryEscrowAddressRequest>): _142.QueryEscrowAddressRequest;
+                    fromProtoMsg(message: _142.QueryEscrowAddressRequestProtoMsg): _142.QueryEscrowAddressRequest;
+                    toProto(message: _142.QueryEscrowAddressRequest): Uint8Array;
+                    toProtoMsg(message: _142.QueryEscrowAddressRequest): _142.QueryEscrowAddressRequestProtoMsg;
+                };
+                QueryEscrowAddressResponse: {
+                    typeUrl: string;
+                    encode(message: _142.QueryEscrowAddressResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryEscrowAddressResponse;
+                    fromJSON(object: any): _142.QueryEscrowAddressResponse;
+                    toJSON(message: _142.QueryEscrowAddressResponse): import("../json-safe.js").JsonSafe<_142.QueryEscrowAddressResponse>;
+                    fromPartial(object: Partial<_142.QueryEscrowAddressResponse>): _142.QueryEscrowAddressResponse;
+                    fromProtoMsg(message: _142.QueryEscrowAddressResponseProtoMsg): _142.QueryEscrowAddressResponse;
+                    toProto(message: _142.QueryEscrowAddressResponse): Uint8Array;
+                    toProtoMsg(message: _142.QueryEscrowAddressResponse): _142.QueryEscrowAddressResponseProtoMsg;
+                };
+                QueryTotalEscrowForDenomRequest: {
+                    typeUrl: string;
+                    encode(message: _142.QueryTotalEscrowForDenomRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryTotalEscrowForDenomRequest;
+                    fromJSON(object: any): _142.QueryTotalEscrowForDenomRequest;
+                    toJSON(message: _142.QueryTotalEscrowForDenomRequest): import("../json-safe.js").JsonSafe<_142.QueryTotalEscrowForDenomRequest>;
+                    fromPartial(object: Partial<_142.QueryTotalEscrowForDenomRequest>): _142.QueryTotalEscrowForDenomRequest;
+                    fromProtoMsg(message: _142.QueryTotalEscrowForDenomRequestProtoMsg): _142.QueryTotalEscrowForDenomRequest;
+                    toProto(message: _142.QueryTotalEscrowForDenomRequest): Uint8Array;
+                    toProtoMsg(message: _142.QueryTotalEscrowForDenomRequest): _142.QueryTotalEscrowForDenomRequestProtoMsg;
+                };
+                QueryTotalEscrowForDenomResponse: {
+                    typeUrl: string;
+                    encode(message: _142.QueryTotalEscrowForDenomResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _142.QueryTotalEscrowForDenomResponse;
+                    fromJSON(object: any): _142.QueryTotalEscrowForDenomResponse;
+                    toJSON(message: _142.QueryTotalEscrowForDenomResponse): import("../json-safe.js").JsonSafe<_142.QueryTotalEscrowForDenomResponse>;
+                    fromPartial(object: Partial<_142.QueryTotalEscrowForDenomResponse>): _142.QueryTotalEscrowForDenomResponse;
+                    fromProtoMsg(message: _142.QueryTotalEscrowForDenomResponseProtoMsg): _142.QueryTotalEscrowForDenomResponse;
+                    toProto(message: _142.QueryTotalEscrowForDenomResponse): Uint8Array;
+                    toProtoMsg(message: _142.QueryTotalEscrowForDenomResponse): _142.QueryTotalEscrowForDenomResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: string;
+                    encode(message: _141.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _141.GenesisState;
+                    fromJSON(object: any): _141.GenesisState;
+                    toJSON(message: _141.GenesisState): import("../json-safe.js").JsonSafe<_141.GenesisState>;
+                    fromPartial(object: Partial<_141.GenesisState>): _141.GenesisState;
+                    fromProtoMsg(message: _141.GenesisStateProtoMsg): _141.GenesisState;
+                    toProto(message: _141.GenesisState): Uint8Array;
+                    toProtoMsg(message: _141.GenesisState): _141.GenesisStateProtoMsg;
+                };
+                Allocation: {
+                    typeUrl: string;
+                    encode(message: _140.Allocation, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _140.Allocation;
+                    fromJSON(object: any): _140.Allocation;
+                    toJSON(message: _140.Allocation): import("../json-safe.js").JsonSafe<_140.Allocation>;
+                    fromPartial(object: Partial<_140.Allocation>): _140.Allocation;
+                    fromProtoMsg(message: _140.AllocationProtoMsg): _140.Allocation;
+                    toProto(message: _140.Allocation): Uint8Array;
+                    toProtoMsg(message: _140.Allocation): _140.AllocationProtoMsg;
+                };
+                TransferAuthorization: {
+                    typeUrl: string;
+                    encode(message: _140.TransferAuthorization, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _140.TransferAuthorization;
+                    fromJSON(object: any): _140.TransferAuthorization;
+                    toJSON(message: _140.TransferAuthorization): import("../json-safe.js").JsonSafe<_140.TransferAuthorization>;
+                    fromPartial(object: Partial<_140.TransferAuthorization>): _140.TransferAuthorization;
+                    fromProtoMsg(message: _140.TransferAuthorizationProtoMsg): _140.TransferAuthorization;
+                    toProto(message: _140.TransferAuthorization): Uint8Array;
+                    toProtoMsg(message: _140.TransferAuthorization): _140.TransferAuthorizationProtoMsg;
+                };
+            };
+            const v2: {
+                FungibleTokenPacketData: {
+                    typeUrl: string;
+                    encode(message: _145.FungibleTokenPacketData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _145.FungibleTokenPacketData;
+                    fromJSON(object: any): _145.FungibleTokenPacketData;
+                    toJSON(message: _145.FungibleTokenPacketData): import("../json-safe.js").JsonSafe<_145.FungibleTokenPacketData>;
+                    fromPartial(object: Partial<_145.FungibleTokenPacketData>): _145.FungibleTokenPacketData;
+                    fromProtoMsg(message: _145.FungibleTokenPacketDataProtoMsg): _145.FungibleTokenPacketData;
+                    toProto(message: _145.FungibleTokenPacketData): Uint8Array;
+                    toProtoMsg(message: _145.FungibleTokenPacketData): _145.FungibleTokenPacketDataProtoMsg;
+                };
+            };
+        }
+    }
+    namespace core {
+        namespace channel {
+            const v1: {
+                MsgClientImpl: typeof _258.MsgClientImpl;
+                QueryClientImpl: typeof _252.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    channel(request: _148.QueryChannelRequest): Promise<_148.QueryChannelResponse>;
+                    channels(request?: _148.QueryChannelsRequest): Promise<_148.QueryChannelsResponse>;
+                    connectionChannels(request: _148.QueryConnectionChannelsRequest): Promise<_148.QueryConnectionChannelsResponse>;
+                    channelClientState(request: _148.QueryChannelClientStateRequest): Promise<_148.QueryChannelClientStateResponse>;
+                    channelConsensusState(request: _148.QueryChannelConsensusStateRequest): Promise<_148.QueryChannelConsensusStateResponse>;
+                    packetCommitment(request: _148.QueryPacketCommitmentRequest): Promise<_148.QueryPacketCommitmentResponse>;
+                    packetCommitments(request: _148.QueryPacketCommitmentsRequest): Promise<_148.QueryPacketCommitmentsResponse>;
+                    packetReceipt(request: _148.QueryPacketReceiptRequest): Promise<_148.QueryPacketReceiptResponse>;
+                    packetAcknowledgement(request: _148.QueryPacketAcknowledgementRequest): Promise<_148.QueryPacketAcknowledgementResponse>;
+                    packetAcknowledgements(request: _148.QueryPacketAcknowledgementsRequest): Promise<_148.QueryPacketAcknowledgementsResponse>;
+                    unreceivedPackets(request: _148.QueryUnreceivedPacketsRequest): Promise<_148.QueryUnreceivedPacketsResponse>;
+                    unreceivedAcks(request: _148.QueryUnreceivedAcksRequest): Promise<_148.QueryUnreceivedAcksResponse>;
+                    nextSequenceReceive(request: _148.QueryNextSequenceReceiveRequest): Promise<_148.QueryNextSequenceReceiveResponse>;
+                };
+                responseResultTypeFromJSON(object: any): _149.ResponseResultType;
+                responseResultTypeToJSON(object: _149.ResponseResultType): string;
+                ResponseResultType: typeof _149.ResponseResultType;
+                ResponseResultTypeSDKType: typeof _149.ResponseResultType;
+                MsgChannelOpenInit: {
+                    typeUrl: string;
+                    encode(message: _149.MsgChannelOpenInit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelOpenInit;
+                    fromJSON(object: any): _149.MsgChannelOpenInit;
+                    toJSON(message: _149.MsgChannelOpenInit): import("../json-safe.js").JsonSafe<_149.MsgChannelOpenInit>;
+                    fromPartial(object: Partial<_149.MsgChannelOpenInit>): _149.MsgChannelOpenInit;
+                    fromProtoMsg(message: _149.MsgChannelOpenInitProtoMsg): _149.MsgChannelOpenInit;
+                    toProto(message: _149.MsgChannelOpenInit): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelOpenInit): _149.MsgChannelOpenInitProtoMsg;
+                };
+                MsgChannelOpenInitResponse: {
+                    typeUrl: string;
+                    encode(message: _149.MsgChannelOpenInitResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelOpenInitResponse;
+                    fromJSON(object: any): _149.MsgChannelOpenInitResponse;
+                    toJSON(message: _149.MsgChannelOpenInitResponse): import("../json-safe.js").JsonSafe<_149.MsgChannelOpenInitResponse>;
+                    fromPartial(object: Partial<_149.MsgChannelOpenInitResponse>): _149.MsgChannelOpenInitResponse;
+                    fromProtoMsg(message: _149.MsgChannelOpenInitResponseProtoMsg): _149.MsgChannelOpenInitResponse;
+                    toProto(message: _149.MsgChannelOpenInitResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelOpenInitResponse): _149.MsgChannelOpenInitResponseProtoMsg;
+                };
+                MsgChannelOpenTry: {
+                    typeUrl: string;
+                    encode(message: _149.MsgChannelOpenTry, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelOpenTry;
+                    fromJSON(object: any): _149.MsgChannelOpenTry;
+                    toJSON(message: _149.MsgChannelOpenTry): import("../json-safe.js").JsonSafe<_149.MsgChannelOpenTry>;
+                    fromPartial(object: Partial<_149.MsgChannelOpenTry>): _149.MsgChannelOpenTry;
+                    fromProtoMsg(message: _149.MsgChannelOpenTryProtoMsg): _149.MsgChannelOpenTry;
+                    toProto(message: _149.MsgChannelOpenTry): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelOpenTry): _149.MsgChannelOpenTryProtoMsg;
+                };
+                MsgChannelOpenTryResponse: {
+                    typeUrl: string;
+                    encode(message: _149.MsgChannelOpenTryResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelOpenTryResponse;
+                    fromJSON(object: any): _149.MsgChannelOpenTryResponse;
+                    toJSON(message: _149.MsgChannelOpenTryResponse): import("../json-safe.js").JsonSafe<_149.MsgChannelOpenTryResponse>;
+                    fromPartial(object: Partial<_149.MsgChannelOpenTryResponse>): _149.MsgChannelOpenTryResponse;
+                    fromProtoMsg(message: _149.MsgChannelOpenTryResponseProtoMsg): _149.MsgChannelOpenTryResponse;
+                    toProto(message: _149.MsgChannelOpenTryResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelOpenTryResponse): _149.MsgChannelOpenTryResponseProtoMsg;
+                };
+                MsgChannelOpenAck: {
+                    typeUrl: string;
+                    encode(message: _149.MsgChannelOpenAck, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelOpenAck;
+                    fromJSON(object: any): _149.MsgChannelOpenAck;
+                    toJSON(message: _149.MsgChannelOpenAck): import("../json-safe.js").JsonSafe<_149.MsgChannelOpenAck>;
+                    fromPartial(object: Partial<_149.MsgChannelOpenAck>): _149.MsgChannelOpenAck;
+                    fromProtoMsg(message: _149.MsgChannelOpenAckProtoMsg): _149.MsgChannelOpenAck;
+                    toProto(message: _149.MsgChannelOpenAck): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelOpenAck): _149.MsgChannelOpenAckProtoMsg;
+                };
+                MsgChannelOpenAckResponse: {
+                    typeUrl: string;
+                    encode(_: _149.MsgChannelOpenAckResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelOpenAckResponse;
+                    fromJSON(_: any): _149.MsgChannelOpenAckResponse;
+                    toJSON(_: _149.MsgChannelOpenAckResponse): import("../json-safe.js").JsonSafe<_149.MsgChannelOpenAckResponse>;
+                    fromPartial(_: Partial<_149.MsgChannelOpenAckResponse>): _149.MsgChannelOpenAckResponse;
+                    fromProtoMsg(message: _149.MsgChannelOpenAckResponseProtoMsg): _149.MsgChannelOpenAckResponse;
+                    toProto(message: _149.MsgChannelOpenAckResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelOpenAckResponse): _149.MsgChannelOpenAckResponseProtoMsg;
+                };
+                MsgChannelOpenConfirm: {
+                    typeUrl: string;
+                    encode(message: _149.MsgChannelOpenConfirm, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelOpenConfirm;
+                    fromJSON(object: any): _149.MsgChannelOpenConfirm;
+                    toJSON(message: _149.MsgChannelOpenConfirm): import("../json-safe.js").JsonSafe<_149.MsgChannelOpenConfirm>;
+                    fromPartial(object: Partial<_149.MsgChannelOpenConfirm>): _149.MsgChannelOpenConfirm;
+                    fromProtoMsg(message: _149.MsgChannelOpenConfirmProtoMsg): _149.MsgChannelOpenConfirm;
+                    toProto(message: _149.MsgChannelOpenConfirm): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelOpenConfirm): _149.MsgChannelOpenConfirmProtoMsg;
+                };
+                MsgChannelOpenConfirmResponse: {
+                    typeUrl: string;
+                    encode(_: _149.MsgChannelOpenConfirmResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelOpenConfirmResponse;
+                    fromJSON(_: any): _149.MsgChannelOpenConfirmResponse;
+                    toJSON(_: _149.MsgChannelOpenConfirmResponse): import("../json-safe.js").JsonSafe<_149.MsgChannelOpenConfirmResponse>;
+                    fromPartial(_: Partial<_149.MsgChannelOpenConfirmResponse>): _149.MsgChannelOpenConfirmResponse;
+                    fromProtoMsg(message: _149.MsgChannelOpenConfirmResponseProtoMsg): _149.MsgChannelOpenConfirmResponse;
+                    toProto(message: _149.MsgChannelOpenConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelOpenConfirmResponse): _149.MsgChannelOpenConfirmResponseProtoMsg;
+                };
+                MsgChannelCloseInit: {
+                    typeUrl: string;
+                    encode(message: _149.MsgChannelCloseInit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelCloseInit;
+                    fromJSON(object: any): _149.MsgChannelCloseInit;
+                    toJSON(message: _149.MsgChannelCloseInit): import("../json-safe.js").JsonSafe<_149.MsgChannelCloseInit>;
+                    fromPartial(object: Partial<_149.MsgChannelCloseInit>): _149.MsgChannelCloseInit;
+                    fromProtoMsg(message: _149.MsgChannelCloseInitProtoMsg): _149.MsgChannelCloseInit;
+                    toProto(message: _149.MsgChannelCloseInit): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelCloseInit): _149.MsgChannelCloseInitProtoMsg;
+                };
+                MsgChannelCloseInitResponse: {
+                    typeUrl: string;
+                    encode(_: _149.MsgChannelCloseInitResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelCloseInitResponse;
+                    fromJSON(_: any): _149.MsgChannelCloseInitResponse;
+                    toJSON(_: _149.MsgChannelCloseInitResponse): import("../json-safe.js").JsonSafe<_149.MsgChannelCloseInitResponse>;
+                    fromPartial(_: Partial<_149.MsgChannelCloseInitResponse>): _149.MsgChannelCloseInitResponse;
+                    fromProtoMsg(message: _149.MsgChannelCloseInitResponseProtoMsg): _149.MsgChannelCloseInitResponse;
+                    toProto(message: _149.MsgChannelCloseInitResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelCloseInitResponse): _149.MsgChannelCloseInitResponseProtoMsg;
+                };
+                MsgChannelCloseConfirm: {
+                    typeUrl: string;
+                    encode(message: _149.MsgChannelCloseConfirm, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelCloseConfirm;
+                    fromJSON(object: any): _149.MsgChannelCloseConfirm;
+                    toJSON(message: _149.MsgChannelCloseConfirm): import("../json-safe.js").JsonSafe<_149.MsgChannelCloseConfirm>;
+                    fromPartial(object: Partial<_149.MsgChannelCloseConfirm>): _149.MsgChannelCloseConfirm;
+                    fromProtoMsg(message: _149.MsgChannelCloseConfirmProtoMsg): _149.MsgChannelCloseConfirm;
+                    toProto(message: _149.MsgChannelCloseConfirm): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelCloseConfirm): _149.MsgChannelCloseConfirmProtoMsg;
+                };
+                MsgChannelCloseConfirmResponse: {
+                    typeUrl: string;
+                    encode(_: _149.MsgChannelCloseConfirmResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgChannelCloseConfirmResponse;
+                    fromJSON(_: any): _149.MsgChannelCloseConfirmResponse;
+                    toJSON(_: _149.MsgChannelCloseConfirmResponse): import("../json-safe.js").JsonSafe<_149.MsgChannelCloseConfirmResponse>;
+                    fromPartial(_: Partial<_149.MsgChannelCloseConfirmResponse>): _149.MsgChannelCloseConfirmResponse;
+                    fromProtoMsg(message: _149.MsgChannelCloseConfirmResponseProtoMsg): _149.MsgChannelCloseConfirmResponse;
+                    toProto(message: _149.MsgChannelCloseConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgChannelCloseConfirmResponse): _149.MsgChannelCloseConfirmResponseProtoMsg;
+                };
+                MsgRecvPacket: {
+                    typeUrl: string;
+                    encode(message: _149.MsgRecvPacket, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgRecvPacket;
+                    fromJSON(object: any): _149.MsgRecvPacket;
+                    toJSON(message: _149.MsgRecvPacket): import("../json-safe.js").JsonSafe<_149.MsgRecvPacket>;
+                    fromPartial(object: Partial<_149.MsgRecvPacket>): _149.MsgRecvPacket;
+                    fromProtoMsg(message: _149.MsgRecvPacketProtoMsg): _149.MsgRecvPacket;
+                    toProto(message: _149.MsgRecvPacket): Uint8Array;
+                    toProtoMsg(message: _149.MsgRecvPacket): _149.MsgRecvPacketProtoMsg;
+                };
+                MsgRecvPacketResponse: {
+                    typeUrl: string;
+                    encode(message: _149.MsgRecvPacketResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgRecvPacketResponse;
+                    fromJSON(object: any): _149.MsgRecvPacketResponse;
+                    toJSON(message: _149.MsgRecvPacketResponse): import("../json-safe.js").JsonSafe<_149.MsgRecvPacketResponse>;
+                    fromPartial(object: Partial<_149.MsgRecvPacketResponse>): _149.MsgRecvPacketResponse;
+                    fromProtoMsg(message: _149.MsgRecvPacketResponseProtoMsg): _149.MsgRecvPacketResponse;
+                    toProto(message: _149.MsgRecvPacketResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgRecvPacketResponse): _149.MsgRecvPacketResponseProtoMsg;
+                };
+                MsgTimeout: {
+                    typeUrl: string;
+                    encode(message: _149.MsgTimeout, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgTimeout;
+                    fromJSON(object: any): _149.MsgTimeout;
+                    toJSON(message: _149.MsgTimeout): import("../json-safe.js").JsonSafe<_149.MsgTimeout>;
+                    fromPartial(object: Partial<_149.MsgTimeout>): _149.MsgTimeout;
+                    fromProtoMsg(message: _149.MsgTimeoutProtoMsg): _149.MsgTimeout;
+                    toProto(message: _149.MsgTimeout): Uint8Array;
+                    toProtoMsg(message: _149.MsgTimeout): _149.MsgTimeoutProtoMsg;
+                };
+                MsgTimeoutResponse: {
+                    typeUrl: string;
+                    encode(message: _149.MsgTimeoutResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgTimeoutResponse;
+                    fromJSON(object: any): _149.MsgTimeoutResponse;
+                    toJSON(message: _149.MsgTimeoutResponse): import("../json-safe.js").JsonSafe<_149.MsgTimeoutResponse>;
+                    fromPartial(object: Partial<_149.MsgTimeoutResponse>): _149.MsgTimeoutResponse;
+                    fromProtoMsg(message: _149.MsgTimeoutResponseProtoMsg): _149.MsgTimeoutResponse;
+                    toProto(message: _149.MsgTimeoutResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgTimeoutResponse): _149.MsgTimeoutResponseProtoMsg;
+                };
+                MsgTimeoutOnClose: {
+                    typeUrl: string;
+                    encode(message: _149.MsgTimeoutOnClose, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgTimeoutOnClose;
+                    fromJSON(object: any): _149.MsgTimeoutOnClose;
+                    toJSON(message: _149.MsgTimeoutOnClose): import("../json-safe.js").JsonSafe<_149.MsgTimeoutOnClose>;
+                    fromPartial(object: Partial<_149.MsgTimeoutOnClose>): _149.MsgTimeoutOnClose;
+                    fromProtoMsg(message: _149.MsgTimeoutOnCloseProtoMsg): _149.MsgTimeoutOnClose;
+                    toProto(message: _149.MsgTimeoutOnClose): Uint8Array;
+                    toProtoMsg(message: _149.MsgTimeoutOnClose): _149.MsgTimeoutOnCloseProtoMsg;
+                };
+                MsgTimeoutOnCloseResponse: {
+                    typeUrl: string;
+                    encode(message: _149.MsgTimeoutOnCloseResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgTimeoutOnCloseResponse;
+                    fromJSON(object: any): _149.MsgTimeoutOnCloseResponse;
+                    toJSON(message: _149.MsgTimeoutOnCloseResponse): import("../json-safe.js").JsonSafe<_149.MsgTimeoutOnCloseResponse>;
+                    fromPartial(object: Partial<_149.MsgTimeoutOnCloseResponse>): _149.MsgTimeoutOnCloseResponse;
+                    fromProtoMsg(message: _149.MsgTimeoutOnCloseResponseProtoMsg): _149.MsgTimeoutOnCloseResponse;
+                    toProto(message: _149.MsgTimeoutOnCloseResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgTimeoutOnCloseResponse): _149.MsgTimeoutOnCloseResponseProtoMsg;
+                };
+                MsgAcknowledgement: {
+                    typeUrl: string;
+                    encode(message: _149.MsgAcknowledgement, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgAcknowledgement;
+                    fromJSON(object: any): _149.MsgAcknowledgement;
+                    toJSON(message: _149.MsgAcknowledgement): import("../json-safe.js").JsonSafe<_149.MsgAcknowledgement>;
+                    fromPartial(object: Partial<_149.MsgAcknowledgement>): _149.MsgAcknowledgement;
+                    fromProtoMsg(message: _149.MsgAcknowledgementProtoMsg): _149.MsgAcknowledgement;
+                    toProto(message: _149.MsgAcknowledgement): Uint8Array;
+                    toProtoMsg(message: _149.MsgAcknowledgement): _149.MsgAcknowledgementProtoMsg;
+                };
+                MsgAcknowledgementResponse: {
+                    typeUrl: string;
+                    encode(message: _149.MsgAcknowledgementResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _149.MsgAcknowledgementResponse;
+                    fromJSON(object: any): _149.MsgAcknowledgementResponse;
+                    toJSON(message: _149.MsgAcknowledgementResponse): import("../json-safe.js").JsonSafe<_149.MsgAcknowledgementResponse>;
+                    fromPartial(object: Partial<_149.MsgAcknowledgementResponse>): _149.MsgAcknowledgementResponse;
+                    fromProtoMsg(message: _149.MsgAcknowledgementResponseProtoMsg): _149.MsgAcknowledgementResponse;
+                    toProto(message: _149.MsgAcknowledgementResponse): Uint8Array;
+                    toProtoMsg(message: _149.MsgAcknowledgementResponse): _149.MsgAcknowledgementResponseProtoMsg;
+                };
+                QueryChannelRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryChannelRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryChannelRequest;
+                    fromJSON(object: any): _148.QueryChannelRequest;
+                    toJSON(message: _148.QueryChannelRequest): import("../json-safe.js").JsonSafe<_148.QueryChannelRequest>;
+                    fromPartial(object: Partial<_148.QueryChannelRequest>): _148.QueryChannelRequest;
+                    fromProtoMsg(message: _148.QueryChannelRequestProtoMsg): _148.QueryChannelRequest;
+                    toProto(message: _148.QueryChannelRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryChannelRequest): _148.QueryChannelRequestProtoMsg;
+                };
+                QueryChannelResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryChannelResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryChannelResponse;
+                    fromJSON(object: any): _148.QueryChannelResponse;
+                    toJSON(message: _148.QueryChannelResponse): import("../json-safe.js").JsonSafe<_148.QueryChannelResponse>;
+                    fromPartial(object: Partial<_148.QueryChannelResponse>): _148.QueryChannelResponse;
+                    fromProtoMsg(message: _148.QueryChannelResponseProtoMsg): _148.QueryChannelResponse;
+                    toProto(message: _148.QueryChannelResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryChannelResponse): _148.QueryChannelResponseProtoMsg;
+                };
+                QueryChannelsRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryChannelsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryChannelsRequest;
+                    fromJSON(object: any): _148.QueryChannelsRequest;
+                    toJSON(message: _148.QueryChannelsRequest): import("../json-safe.js").JsonSafe<_148.QueryChannelsRequest>;
+                    fromPartial(object: Partial<_148.QueryChannelsRequest>): _148.QueryChannelsRequest;
+                    fromProtoMsg(message: _148.QueryChannelsRequestProtoMsg): _148.QueryChannelsRequest;
+                    toProto(message: _148.QueryChannelsRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryChannelsRequest): _148.QueryChannelsRequestProtoMsg;
+                };
+                QueryChannelsResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryChannelsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryChannelsResponse;
+                    fromJSON(object: any): _148.QueryChannelsResponse;
+                    toJSON(message: _148.QueryChannelsResponse): import("../json-safe.js").JsonSafe<_148.QueryChannelsResponse>;
+                    fromPartial(object: Partial<_148.QueryChannelsResponse>): _148.QueryChannelsResponse;
+                    fromProtoMsg(message: _148.QueryChannelsResponseProtoMsg): _148.QueryChannelsResponse;
+                    toProto(message: _148.QueryChannelsResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryChannelsResponse): _148.QueryChannelsResponseProtoMsg;
+                };
+                QueryConnectionChannelsRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryConnectionChannelsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryConnectionChannelsRequest;
+                    fromJSON(object: any): _148.QueryConnectionChannelsRequest;
+                    toJSON(message: _148.QueryConnectionChannelsRequest): import("../json-safe.js").JsonSafe<_148.QueryConnectionChannelsRequest>;
+                    fromPartial(object: Partial<_148.QueryConnectionChannelsRequest>): _148.QueryConnectionChannelsRequest;
+                    fromProtoMsg(message: _148.QueryConnectionChannelsRequestProtoMsg): _148.QueryConnectionChannelsRequest;
+                    toProto(message: _148.QueryConnectionChannelsRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryConnectionChannelsRequest): _148.QueryConnectionChannelsRequestProtoMsg;
+                };
+                QueryConnectionChannelsResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryConnectionChannelsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryConnectionChannelsResponse;
+                    fromJSON(object: any): _148.QueryConnectionChannelsResponse;
+                    toJSON(message: _148.QueryConnectionChannelsResponse): import("../json-safe.js").JsonSafe<_148.QueryConnectionChannelsResponse>;
+                    fromPartial(object: Partial<_148.QueryConnectionChannelsResponse>): _148.QueryConnectionChannelsResponse;
+                    fromProtoMsg(message: _148.QueryConnectionChannelsResponseProtoMsg): _148.QueryConnectionChannelsResponse;
+                    toProto(message: _148.QueryConnectionChannelsResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryConnectionChannelsResponse): _148.QueryConnectionChannelsResponseProtoMsg;
+                };
+                QueryChannelClientStateRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryChannelClientStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryChannelClientStateRequest;
+                    fromJSON(object: any): _148.QueryChannelClientStateRequest;
+                    toJSON(message: _148.QueryChannelClientStateRequest): import("../json-safe.js").JsonSafe<_148.QueryChannelClientStateRequest>;
+                    fromPartial(object: Partial<_148.QueryChannelClientStateRequest>): _148.QueryChannelClientStateRequest;
+                    fromProtoMsg(message: _148.QueryChannelClientStateRequestProtoMsg): _148.QueryChannelClientStateRequest;
+                    toProto(message: _148.QueryChannelClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryChannelClientStateRequest): _148.QueryChannelClientStateRequestProtoMsg;
+                };
+                QueryChannelClientStateResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryChannelClientStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryChannelClientStateResponse;
+                    fromJSON(object: any): _148.QueryChannelClientStateResponse;
+                    toJSON(message: _148.QueryChannelClientStateResponse): import("../json-safe.js").JsonSafe<_148.QueryChannelClientStateResponse>;
+                    fromPartial(object: Partial<_148.QueryChannelClientStateResponse>): _148.QueryChannelClientStateResponse;
+                    fromProtoMsg(message: _148.QueryChannelClientStateResponseProtoMsg): _148.QueryChannelClientStateResponse;
+                    toProto(message: _148.QueryChannelClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryChannelClientStateResponse): _148.QueryChannelClientStateResponseProtoMsg;
+                };
+                QueryChannelConsensusStateRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryChannelConsensusStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryChannelConsensusStateRequest;
+                    fromJSON(object: any): _148.QueryChannelConsensusStateRequest;
+                    toJSON(message: _148.QueryChannelConsensusStateRequest): import("../json-safe.js").JsonSafe<_148.QueryChannelConsensusStateRequest>;
+                    fromPartial(object: Partial<_148.QueryChannelConsensusStateRequest>): _148.QueryChannelConsensusStateRequest;
+                    fromProtoMsg(message: _148.QueryChannelConsensusStateRequestProtoMsg): _148.QueryChannelConsensusStateRequest;
+                    toProto(message: _148.QueryChannelConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryChannelConsensusStateRequest): _148.QueryChannelConsensusStateRequestProtoMsg;
+                };
+                QueryChannelConsensusStateResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryChannelConsensusStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryChannelConsensusStateResponse;
+                    fromJSON(object: any): _148.QueryChannelConsensusStateResponse;
+                    toJSON(message: _148.QueryChannelConsensusStateResponse): import("../json-safe.js").JsonSafe<_148.QueryChannelConsensusStateResponse>;
+                    fromPartial(object: Partial<_148.QueryChannelConsensusStateResponse>): _148.QueryChannelConsensusStateResponse;
+                    fromProtoMsg(message: _148.QueryChannelConsensusStateResponseProtoMsg): _148.QueryChannelConsensusStateResponse;
+                    toProto(message: _148.QueryChannelConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryChannelConsensusStateResponse): _148.QueryChannelConsensusStateResponseProtoMsg;
+                };
+                QueryPacketCommitmentRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketCommitmentRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketCommitmentRequest;
+                    fromJSON(object: any): _148.QueryPacketCommitmentRequest;
+                    toJSON(message: _148.QueryPacketCommitmentRequest): import("../json-safe.js").JsonSafe<_148.QueryPacketCommitmentRequest>;
+                    fromPartial(object: Partial<_148.QueryPacketCommitmentRequest>): _148.QueryPacketCommitmentRequest;
+                    fromProtoMsg(message: _148.QueryPacketCommitmentRequestProtoMsg): _148.QueryPacketCommitmentRequest;
+                    toProto(message: _148.QueryPacketCommitmentRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketCommitmentRequest): _148.QueryPacketCommitmentRequestProtoMsg;
+                };
+                QueryPacketCommitmentResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketCommitmentResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketCommitmentResponse;
+                    fromJSON(object: any): _148.QueryPacketCommitmentResponse;
+                    toJSON(message: _148.QueryPacketCommitmentResponse): import("../json-safe.js").JsonSafe<_148.QueryPacketCommitmentResponse>;
+                    fromPartial(object: Partial<_148.QueryPacketCommitmentResponse>): _148.QueryPacketCommitmentResponse;
+                    fromProtoMsg(message: _148.QueryPacketCommitmentResponseProtoMsg): _148.QueryPacketCommitmentResponse;
+                    toProto(message: _148.QueryPacketCommitmentResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketCommitmentResponse): _148.QueryPacketCommitmentResponseProtoMsg;
+                };
+                QueryPacketCommitmentsRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketCommitmentsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketCommitmentsRequest;
+                    fromJSON(object: any): _148.QueryPacketCommitmentsRequest;
+                    toJSON(message: _148.QueryPacketCommitmentsRequest): import("../json-safe.js").JsonSafe<_148.QueryPacketCommitmentsRequest>;
+                    fromPartial(object: Partial<_148.QueryPacketCommitmentsRequest>): _148.QueryPacketCommitmentsRequest;
+                    fromProtoMsg(message: _148.QueryPacketCommitmentsRequestProtoMsg): _148.QueryPacketCommitmentsRequest;
+                    toProto(message: _148.QueryPacketCommitmentsRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketCommitmentsRequest): _148.QueryPacketCommitmentsRequestProtoMsg;
+                };
+                QueryPacketCommitmentsResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketCommitmentsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketCommitmentsResponse;
+                    fromJSON(object: any): _148.QueryPacketCommitmentsResponse;
+                    toJSON(message: _148.QueryPacketCommitmentsResponse): import("../json-safe.js").JsonSafe<_148.QueryPacketCommitmentsResponse>;
+                    fromPartial(object: Partial<_148.QueryPacketCommitmentsResponse>): _148.QueryPacketCommitmentsResponse;
+                    fromProtoMsg(message: _148.QueryPacketCommitmentsResponseProtoMsg): _148.QueryPacketCommitmentsResponse;
+                    toProto(message: _148.QueryPacketCommitmentsResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketCommitmentsResponse): _148.QueryPacketCommitmentsResponseProtoMsg;
+                };
+                QueryPacketReceiptRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketReceiptRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketReceiptRequest;
+                    fromJSON(object: any): _148.QueryPacketReceiptRequest;
+                    toJSON(message: _148.QueryPacketReceiptRequest): import("../json-safe.js").JsonSafe<_148.QueryPacketReceiptRequest>;
+                    fromPartial(object: Partial<_148.QueryPacketReceiptRequest>): _148.QueryPacketReceiptRequest;
+                    fromProtoMsg(message: _148.QueryPacketReceiptRequestProtoMsg): _148.QueryPacketReceiptRequest;
+                    toProto(message: _148.QueryPacketReceiptRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketReceiptRequest): _148.QueryPacketReceiptRequestProtoMsg;
+                };
+                QueryPacketReceiptResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketReceiptResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketReceiptResponse;
+                    fromJSON(object: any): _148.QueryPacketReceiptResponse;
+                    toJSON(message: _148.QueryPacketReceiptResponse): import("../json-safe.js").JsonSafe<_148.QueryPacketReceiptResponse>;
+                    fromPartial(object: Partial<_148.QueryPacketReceiptResponse>): _148.QueryPacketReceiptResponse;
+                    fromProtoMsg(message: _148.QueryPacketReceiptResponseProtoMsg): _148.QueryPacketReceiptResponse;
+                    toProto(message: _148.QueryPacketReceiptResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketReceiptResponse): _148.QueryPacketReceiptResponseProtoMsg;
+                };
+                QueryPacketAcknowledgementRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketAcknowledgementRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketAcknowledgementRequest;
+                    fromJSON(object: any): _148.QueryPacketAcknowledgementRequest;
+                    toJSON(message: _148.QueryPacketAcknowledgementRequest): import("../json-safe.js").JsonSafe<_148.QueryPacketAcknowledgementRequest>;
+                    fromPartial(object: Partial<_148.QueryPacketAcknowledgementRequest>): _148.QueryPacketAcknowledgementRequest;
+                    fromProtoMsg(message: _148.QueryPacketAcknowledgementRequestProtoMsg): _148.QueryPacketAcknowledgementRequest;
+                    toProto(message: _148.QueryPacketAcknowledgementRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketAcknowledgementRequest): _148.QueryPacketAcknowledgementRequestProtoMsg;
+                };
+                QueryPacketAcknowledgementResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketAcknowledgementResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketAcknowledgementResponse;
+                    fromJSON(object: any): _148.QueryPacketAcknowledgementResponse;
+                    toJSON(message: _148.QueryPacketAcknowledgementResponse): import("../json-safe.js").JsonSafe<_148.QueryPacketAcknowledgementResponse>;
+                    fromPartial(object: Partial<_148.QueryPacketAcknowledgementResponse>): _148.QueryPacketAcknowledgementResponse;
+                    fromProtoMsg(message: _148.QueryPacketAcknowledgementResponseProtoMsg): _148.QueryPacketAcknowledgementResponse;
+                    toProto(message: _148.QueryPacketAcknowledgementResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketAcknowledgementResponse): _148.QueryPacketAcknowledgementResponseProtoMsg;
+                };
+                QueryPacketAcknowledgementsRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketAcknowledgementsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketAcknowledgementsRequest;
+                    fromJSON(object: any): _148.QueryPacketAcknowledgementsRequest;
+                    toJSON(message: _148.QueryPacketAcknowledgementsRequest): import("../json-safe.js").JsonSafe<_148.QueryPacketAcknowledgementsRequest>;
+                    fromPartial(object: Partial<_148.QueryPacketAcknowledgementsRequest>): _148.QueryPacketAcknowledgementsRequest;
+                    fromProtoMsg(message: _148.QueryPacketAcknowledgementsRequestProtoMsg): _148.QueryPacketAcknowledgementsRequest;
+                    toProto(message: _148.QueryPacketAcknowledgementsRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketAcknowledgementsRequest): _148.QueryPacketAcknowledgementsRequestProtoMsg;
+                };
+                QueryPacketAcknowledgementsResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryPacketAcknowledgementsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryPacketAcknowledgementsResponse;
+                    fromJSON(object: any): _148.QueryPacketAcknowledgementsResponse;
+                    toJSON(message: _148.QueryPacketAcknowledgementsResponse): import("../json-safe.js").JsonSafe<_148.QueryPacketAcknowledgementsResponse>;
+                    fromPartial(object: Partial<_148.QueryPacketAcknowledgementsResponse>): _148.QueryPacketAcknowledgementsResponse;
+                    fromProtoMsg(message: _148.QueryPacketAcknowledgementsResponseProtoMsg): _148.QueryPacketAcknowledgementsResponse;
+                    toProto(message: _148.QueryPacketAcknowledgementsResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryPacketAcknowledgementsResponse): _148.QueryPacketAcknowledgementsResponseProtoMsg;
+                };
+                QueryUnreceivedPacketsRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryUnreceivedPacketsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryUnreceivedPacketsRequest;
+                    fromJSON(object: any): _148.QueryUnreceivedPacketsRequest;
+                    toJSON(message: _148.QueryUnreceivedPacketsRequest): import("../json-safe.js").JsonSafe<_148.QueryUnreceivedPacketsRequest>;
+                    fromPartial(object: Partial<_148.QueryUnreceivedPacketsRequest>): _148.QueryUnreceivedPacketsRequest;
+                    fromProtoMsg(message: _148.QueryUnreceivedPacketsRequestProtoMsg): _148.QueryUnreceivedPacketsRequest;
+                    toProto(message: _148.QueryUnreceivedPacketsRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryUnreceivedPacketsRequest): _148.QueryUnreceivedPacketsRequestProtoMsg;
+                };
+                QueryUnreceivedPacketsResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryUnreceivedPacketsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryUnreceivedPacketsResponse;
+                    fromJSON(object: any): _148.QueryUnreceivedPacketsResponse;
+                    toJSON(message: _148.QueryUnreceivedPacketsResponse): import("../json-safe.js").JsonSafe<_148.QueryUnreceivedPacketsResponse>;
+                    fromPartial(object: Partial<_148.QueryUnreceivedPacketsResponse>): _148.QueryUnreceivedPacketsResponse;
+                    fromProtoMsg(message: _148.QueryUnreceivedPacketsResponseProtoMsg): _148.QueryUnreceivedPacketsResponse;
+                    toProto(message: _148.QueryUnreceivedPacketsResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryUnreceivedPacketsResponse): _148.QueryUnreceivedPacketsResponseProtoMsg;
+                };
+                QueryUnreceivedAcksRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryUnreceivedAcksRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryUnreceivedAcksRequest;
+                    fromJSON(object: any): _148.QueryUnreceivedAcksRequest;
+                    toJSON(message: _148.QueryUnreceivedAcksRequest): import("../json-safe.js").JsonSafe<_148.QueryUnreceivedAcksRequest>;
+                    fromPartial(object: Partial<_148.QueryUnreceivedAcksRequest>): _148.QueryUnreceivedAcksRequest;
+                    fromProtoMsg(message: _148.QueryUnreceivedAcksRequestProtoMsg): _148.QueryUnreceivedAcksRequest;
+                    toProto(message: _148.QueryUnreceivedAcksRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryUnreceivedAcksRequest): _148.QueryUnreceivedAcksRequestProtoMsg;
+                };
+                QueryUnreceivedAcksResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryUnreceivedAcksResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryUnreceivedAcksResponse;
+                    fromJSON(object: any): _148.QueryUnreceivedAcksResponse;
+                    toJSON(message: _148.QueryUnreceivedAcksResponse): import("../json-safe.js").JsonSafe<_148.QueryUnreceivedAcksResponse>;
+                    fromPartial(object: Partial<_148.QueryUnreceivedAcksResponse>): _148.QueryUnreceivedAcksResponse;
+                    fromProtoMsg(message: _148.QueryUnreceivedAcksResponseProtoMsg): _148.QueryUnreceivedAcksResponse;
+                    toProto(message: _148.QueryUnreceivedAcksResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryUnreceivedAcksResponse): _148.QueryUnreceivedAcksResponseProtoMsg;
+                };
+                QueryNextSequenceReceiveRequest: {
+                    typeUrl: string;
+                    encode(message: _148.QueryNextSequenceReceiveRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryNextSequenceReceiveRequest;
+                    fromJSON(object: any): _148.QueryNextSequenceReceiveRequest;
+                    toJSON(message: _148.QueryNextSequenceReceiveRequest): import("../json-safe.js").JsonSafe<_148.QueryNextSequenceReceiveRequest>;
+                    fromPartial(object: Partial<_148.QueryNextSequenceReceiveRequest>): _148.QueryNextSequenceReceiveRequest;
+                    fromProtoMsg(message: _148.QueryNextSequenceReceiveRequestProtoMsg): _148.QueryNextSequenceReceiveRequest;
+                    toProto(message: _148.QueryNextSequenceReceiveRequest): Uint8Array;
+                    toProtoMsg(message: _148.QueryNextSequenceReceiveRequest): _148.QueryNextSequenceReceiveRequestProtoMsg;
+                };
+                QueryNextSequenceReceiveResponse: {
+                    typeUrl: string;
+                    encode(message: _148.QueryNextSequenceReceiveResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _148.QueryNextSequenceReceiveResponse;
+                    fromJSON(object: any): _148.QueryNextSequenceReceiveResponse;
+                    toJSON(message: _148.QueryNextSequenceReceiveResponse): import("../json-safe.js").JsonSafe<_148.QueryNextSequenceReceiveResponse>;
+                    fromPartial(object: Partial<_148.QueryNextSequenceReceiveResponse>): _148.QueryNextSequenceReceiveResponse;
+                    fromProtoMsg(message: _148.QueryNextSequenceReceiveResponseProtoMsg): _148.QueryNextSequenceReceiveResponse;
+                    toProto(message: _148.QueryNextSequenceReceiveResponse): Uint8Array;
+                    toProtoMsg(message: _148.QueryNextSequenceReceiveResponse): _148.QueryNextSequenceReceiveResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: string;
+                    encode(message: _147.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _147.GenesisState;
+                    fromJSON(object: any): _147.GenesisState;
+                    toJSON(message: _147.GenesisState): import("../json-safe.js").JsonSafe<_147.GenesisState>;
+                    fromPartial(object: Partial<_147.GenesisState>): _147.GenesisState;
+                    fromProtoMsg(message: _147.GenesisStateProtoMsg): _147.GenesisState;
+                    toProto(message: _147.GenesisState): Uint8Array;
+                    toProtoMsg(message: _147.GenesisState): _147.GenesisStateProtoMsg;
+                };
+                PacketSequence: {
+                    typeUrl: string;
+                    encode(message: _147.PacketSequence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _147.PacketSequence;
+                    fromJSON(object: any): _147.PacketSequence;
+                    toJSON(message: _147.PacketSequence): import("../json-safe.js").JsonSafe<_147.PacketSequence>;
+                    fromPartial(object: Partial<_147.PacketSequence>): _147.PacketSequence;
+                    fromProtoMsg(message: _147.PacketSequenceProtoMsg): _147.PacketSequence;
+                    toProto(message: _147.PacketSequence): Uint8Array;
+                    toProtoMsg(message: _147.PacketSequence): _147.PacketSequenceProtoMsg;
+                };
+                stateFromJSON(object: any): _146.State;
+                stateToJSON(object: _146.State): string;
+                orderFromJSON(object: any): _146.Order;
+                orderToJSON(object: _146.Order): string;
+                State: typeof _146.State;
+                StateSDKType: typeof _146.State;
+                Order: typeof _146.Order;
+                OrderSDKType: typeof _146.Order;
+                Channel: {
+                    typeUrl: string;
+                    encode(message: _146.Channel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _146.Channel;
+                    fromJSON(object: any): _146.Channel;
+                    toJSON(message: _146.Channel): import("../json-safe.js").JsonSafe<_146.Channel>;
+                    fromPartial(object: Partial<_146.Channel>): _146.Channel;
+                    fromProtoMsg(message: _146.ChannelProtoMsg): _146.Channel;
+                    toProto(message: _146.Channel): Uint8Array;
+                    toProtoMsg(message: _146.Channel): _146.ChannelProtoMsg;
+                };
+                IdentifiedChannel: {
+                    typeUrl: string;
+                    encode(message: _146.IdentifiedChannel, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _146.IdentifiedChannel;
+                    fromJSON(object: any): _146.IdentifiedChannel;
+                    toJSON(message: _146.IdentifiedChannel): import("../json-safe.js").JsonSafe<_146.IdentifiedChannel>;
+                    fromPartial(object: Partial<_146.IdentifiedChannel>): _146.IdentifiedChannel;
+                    fromProtoMsg(message: _146.IdentifiedChannelProtoMsg): _146.IdentifiedChannel;
+                    toProto(message: _146.IdentifiedChannel): Uint8Array;
+                    toProtoMsg(message: _146.IdentifiedChannel): _146.IdentifiedChannelProtoMsg;
+                };
+                Counterparty: {
+                    typeUrl: string;
+                    encode(message: _146.Counterparty, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _146.Counterparty;
+                    fromJSON(object: any): _146.Counterparty;
+                    toJSON(message: _146.Counterparty): import("../json-safe.js").JsonSafe<_146.Counterparty>;
+                    fromPartial(object: Partial<_146.Counterparty>): _146.Counterparty;
+                    fromProtoMsg(message: _146.CounterpartyProtoMsg): _146.Counterparty;
+                    toProto(message: _146.Counterparty): Uint8Array;
+                    toProtoMsg(message: _146.Counterparty): _146.CounterpartyProtoMsg;
+                };
+                Packet: {
+                    typeUrl: string;
+                    encode(message: _146.Packet, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _146.Packet;
+                    fromJSON(object: any): _146.Packet;
+                    toJSON(message: _146.Packet): import("../json-safe.js").JsonSafe<_146.Packet>;
+                    fromPartial(object: Partial<_146.Packet>): _146.Packet;
+                    fromProtoMsg(message: _146.PacketProtoMsg): _146.Packet;
+                    toProto(message: _146.Packet): Uint8Array;
+                    toProtoMsg(message: _146.Packet): _146.PacketProtoMsg;
+                };
+                PacketState: {
+                    typeUrl: string;
+                    encode(message: _146.PacketState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _146.PacketState;
+                    fromJSON(object: any): _146.PacketState;
+                    toJSON(message: _146.PacketState): import("../json-safe.js").JsonSafe<_146.PacketState>;
+                    fromPartial(object: Partial<_146.PacketState>): _146.PacketState;
+                    fromProtoMsg(message: _146.PacketStateProtoMsg): _146.PacketState;
+                    toProto(message: _146.PacketState): Uint8Array;
+                    toProtoMsg(message: _146.PacketState): _146.PacketStateProtoMsg;
+                };
+                PacketId: {
+                    typeUrl: string;
+                    encode(message: _146.PacketId, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _146.PacketId;
+                    fromJSON(object: any): _146.PacketId;
+                    toJSON(message: _146.PacketId): import("../json-safe.js").JsonSafe<_146.PacketId>;
+                    fromPartial(object: Partial<_146.PacketId>): _146.PacketId;
+                    fromProtoMsg(message: _146.PacketIdProtoMsg): _146.PacketId;
+                    toProto(message: _146.PacketId): Uint8Array;
+                    toProtoMsg(message: _146.PacketId): _146.PacketIdProtoMsg;
+                };
+                Acknowledgement: {
+                    typeUrl: string;
+                    encode(message: _146.Acknowledgement, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _146.Acknowledgement;
+                    fromJSON(object: any): _146.Acknowledgement;
+                    toJSON(message: _146.Acknowledgement): import("../json-safe.js").JsonSafe<_146.Acknowledgement>;
+                    fromPartial(object: Partial<_146.Acknowledgement>): _146.Acknowledgement;
+                    fromProtoMsg(message: _146.AcknowledgementProtoMsg): _146.Acknowledgement;
+                    toProto(message: _146.Acknowledgement): Uint8Array;
+                    toProtoMsg(message: _146.Acknowledgement): _146.AcknowledgementProtoMsg;
+                };
+            };
+        }
+        namespace client {
+            const v1: {
+                MsgClientImpl: typeof _259.MsgClientImpl;
+                QueryClientImpl: typeof _253.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    clientState(request: _152.QueryClientStateRequest): Promise<_152.QueryClientStateResponse>;
+                    clientStates(request?: _152.QueryClientStatesRequest): Promise<_152.QueryClientStatesResponse>;
+                    consensusState(request: _152.QueryConsensusStateRequest): Promise<_152.QueryConsensusStateResponse>;
+                    consensusStates(request: _152.QueryConsensusStatesRequest): Promise<_152.QueryConsensusStatesResponse>;
+                    consensusStateHeights(request: _152.QueryConsensusStateHeightsRequest): Promise<_152.QueryConsensusStateHeightsResponse>;
+                    clientStatus(request: _152.QueryClientStatusRequest): Promise<_152.QueryClientStatusResponse>;
+                    clientParams(request?: _152.QueryClientParamsRequest): Promise<_152.QueryClientParamsResponse>;
+                    upgradedClientState(request?: _152.QueryUpgradedClientStateRequest): Promise<_152.QueryUpgradedClientStateResponse>;
+                    upgradedConsensusState(request?: _152.QueryUpgradedConsensusStateRequest): Promise<_152.QueryUpgradedConsensusStateResponse>;
+                };
+                MsgCreateClient: {
+                    typeUrl: string;
+                    encode(message: _153.MsgCreateClient, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _153.MsgCreateClient;
+                    fromJSON(object: any): _153.MsgCreateClient;
+                    toJSON(message: _153.MsgCreateClient): import("../json-safe.js").JsonSafe<_153.MsgCreateClient>;
+                    fromPartial(object: Partial<_153.MsgCreateClient>): _153.MsgCreateClient;
+                    fromProtoMsg(message: _153.MsgCreateClientProtoMsg): _153.MsgCreateClient;
+                    toProto(message: _153.MsgCreateClient): Uint8Array;
+                    toProtoMsg(message: _153.MsgCreateClient): _153.MsgCreateClientProtoMsg;
+                };
+                MsgCreateClientResponse: {
+                    typeUrl: string;
+                    encode(_: _153.MsgCreateClientResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _153.MsgCreateClientResponse;
+                    fromJSON(_: any): _153.MsgCreateClientResponse;
+                    toJSON(_: _153.MsgCreateClientResponse): import("../json-safe.js").JsonSafe<_153.MsgCreateClientResponse>;
+                    fromPartial(_: Partial<_153.MsgCreateClientResponse>): _153.MsgCreateClientResponse;
+                    fromProtoMsg(message: _153.MsgCreateClientResponseProtoMsg): _153.MsgCreateClientResponse;
+                    toProto(message: _153.MsgCreateClientResponse): Uint8Array;
+                    toProtoMsg(message: _153.MsgCreateClientResponse): _153.MsgCreateClientResponseProtoMsg;
+                };
+                MsgUpdateClient: {
+                    typeUrl: string;
+                    encode(message: _153.MsgUpdateClient, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _153.MsgUpdateClient;
+                    fromJSON(object: any): _153.MsgUpdateClient;
+                    toJSON(message: _153.MsgUpdateClient): import("../json-safe.js").JsonSafe<_153.MsgUpdateClient>;
+                    fromPartial(object: Partial<_153.MsgUpdateClient>): _153.MsgUpdateClient;
+                    fromProtoMsg(message: _153.MsgUpdateClientProtoMsg): _153.MsgUpdateClient;
+                    toProto(message: _153.MsgUpdateClient): Uint8Array;
+                    toProtoMsg(message: _153.MsgUpdateClient): _153.MsgUpdateClientProtoMsg;
+                };
+                MsgUpdateClientResponse: {
+                    typeUrl: string;
+                    encode(_: _153.MsgUpdateClientResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _153.MsgUpdateClientResponse;
+                    fromJSON(_: any): _153.MsgUpdateClientResponse;
+                    toJSON(_: _153.MsgUpdateClientResponse): import("../json-safe.js").JsonSafe<_153.MsgUpdateClientResponse>;
+                    fromPartial(_: Partial<_153.MsgUpdateClientResponse>): _153.MsgUpdateClientResponse;
+                    fromProtoMsg(message: _153.MsgUpdateClientResponseProtoMsg): _153.MsgUpdateClientResponse;
+                    toProto(message: _153.MsgUpdateClientResponse): Uint8Array;
+                    toProtoMsg(message: _153.MsgUpdateClientResponse): _153.MsgUpdateClientResponseProtoMsg;
+                };
+                MsgUpgradeClient: {
+                    typeUrl: string;
+                    encode(message: _153.MsgUpgradeClient, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _153.MsgUpgradeClient;
+                    fromJSON(object: any): _153.MsgUpgradeClient;
+                    toJSON(message: _153.MsgUpgradeClient): import("../json-safe.js").JsonSafe<_153.MsgUpgradeClient>;
+                    fromPartial(object: Partial<_153.MsgUpgradeClient>): _153.MsgUpgradeClient;
+                    fromProtoMsg(message: _153.MsgUpgradeClientProtoMsg): _153.MsgUpgradeClient;
+                    toProto(message: _153.MsgUpgradeClient): Uint8Array;
+                    toProtoMsg(message: _153.MsgUpgradeClient): _153.MsgUpgradeClientProtoMsg;
+                };
+                MsgUpgradeClientResponse: {
+                    typeUrl: string;
+                    encode(_: _153.MsgUpgradeClientResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _153.MsgUpgradeClientResponse;
+                    fromJSON(_: any): _153.MsgUpgradeClientResponse;
+                    toJSON(_: _153.MsgUpgradeClientResponse): import("../json-safe.js").JsonSafe<_153.MsgUpgradeClientResponse>;
+                    fromPartial(_: Partial<_153.MsgUpgradeClientResponse>): _153.MsgUpgradeClientResponse;
+                    fromProtoMsg(message: _153.MsgUpgradeClientResponseProtoMsg): _153.MsgUpgradeClientResponse;
+                    toProto(message: _153.MsgUpgradeClientResponse): Uint8Array;
+                    toProtoMsg(message: _153.MsgUpgradeClientResponse): _153.MsgUpgradeClientResponseProtoMsg;
+                };
+                MsgSubmitMisbehaviour: {
+                    typeUrl: string;
+                    encode(message: _153.MsgSubmitMisbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _153.MsgSubmitMisbehaviour;
+                    fromJSON(object: any): _153.MsgSubmitMisbehaviour;
+                    toJSON(message: _153.MsgSubmitMisbehaviour): import("../json-safe.js").JsonSafe<_153.MsgSubmitMisbehaviour>;
+                    fromPartial(object: Partial<_153.MsgSubmitMisbehaviour>): _153.MsgSubmitMisbehaviour;
+                    fromProtoMsg(message: _153.MsgSubmitMisbehaviourProtoMsg): _153.MsgSubmitMisbehaviour;
+                    toProto(message: _153.MsgSubmitMisbehaviour): Uint8Array;
+                    toProtoMsg(message: _153.MsgSubmitMisbehaviour): _153.MsgSubmitMisbehaviourProtoMsg;
+                };
+                MsgSubmitMisbehaviourResponse: {
+                    typeUrl: string;
+                    encode(_: _153.MsgSubmitMisbehaviourResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _153.MsgSubmitMisbehaviourResponse;
+                    fromJSON(_: any): _153.MsgSubmitMisbehaviourResponse;
+                    toJSON(_: _153.MsgSubmitMisbehaviourResponse): import("../json-safe.js").JsonSafe<_153.MsgSubmitMisbehaviourResponse>;
+                    fromPartial(_: Partial<_153.MsgSubmitMisbehaviourResponse>): _153.MsgSubmitMisbehaviourResponse;
+                    fromProtoMsg(message: _153.MsgSubmitMisbehaviourResponseProtoMsg): _153.MsgSubmitMisbehaviourResponse;
+                    toProto(message: _153.MsgSubmitMisbehaviourResponse): Uint8Array;
+                    toProtoMsg(message: _153.MsgSubmitMisbehaviourResponse): _153.MsgSubmitMisbehaviourResponseProtoMsg;
+                };
+                QueryClientStateRequest: {
+                    typeUrl: string;
+                    encode(message: _152.QueryClientStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryClientStateRequest;
+                    fromJSON(object: any): _152.QueryClientStateRequest;
+                    toJSON(message: _152.QueryClientStateRequest): import("../json-safe.js").JsonSafe<_152.QueryClientStateRequest>;
+                    fromPartial(object: Partial<_152.QueryClientStateRequest>): _152.QueryClientStateRequest;
+                    fromProtoMsg(message: _152.QueryClientStateRequestProtoMsg): _152.QueryClientStateRequest;
+                    toProto(message: _152.QueryClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryClientStateRequest): _152.QueryClientStateRequestProtoMsg;
+                };
+                QueryClientStateResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryClientStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryClientStateResponse;
+                    fromJSON(object: any): _152.QueryClientStateResponse;
+                    toJSON(message: _152.QueryClientStateResponse): import("../json-safe.js").JsonSafe<_152.QueryClientStateResponse>;
+                    fromPartial(object: Partial<_152.QueryClientStateResponse>): _152.QueryClientStateResponse;
+                    fromProtoMsg(message: _152.QueryClientStateResponseProtoMsg): _152.QueryClientStateResponse;
+                    toProto(message: _152.QueryClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryClientStateResponse): _152.QueryClientStateResponseProtoMsg;
+                };
+                QueryClientStatesRequest: {
+                    typeUrl: string;
+                    encode(message: _152.QueryClientStatesRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryClientStatesRequest;
+                    fromJSON(object: any): _152.QueryClientStatesRequest;
+                    toJSON(message: _152.QueryClientStatesRequest): import("../json-safe.js").JsonSafe<_152.QueryClientStatesRequest>;
+                    fromPartial(object: Partial<_152.QueryClientStatesRequest>): _152.QueryClientStatesRequest;
+                    fromProtoMsg(message: _152.QueryClientStatesRequestProtoMsg): _152.QueryClientStatesRequest;
+                    toProto(message: _152.QueryClientStatesRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryClientStatesRequest): _152.QueryClientStatesRequestProtoMsg;
+                };
+                QueryClientStatesResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryClientStatesResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryClientStatesResponse;
+                    fromJSON(object: any): _152.QueryClientStatesResponse;
+                    toJSON(message: _152.QueryClientStatesResponse): import("../json-safe.js").JsonSafe<_152.QueryClientStatesResponse>;
+                    fromPartial(object: Partial<_152.QueryClientStatesResponse>): _152.QueryClientStatesResponse;
+                    fromProtoMsg(message: _152.QueryClientStatesResponseProtoMsg): _152.QueryClientStatesResponse;
+                    toProto(message: _152.QueryClientStatesResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryClientStatesResponse): _152.QueryClientStatesResponseProtoMsg;
+                };
+                QueryConsensusStateRequest: {
+                    typeUrl: string;
+                    encode(message: _152.QueryConsensusStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryConsensusStateRequest;
+                    fromJSON(object: any): _152.QueryConsensusStateRequest;
+                    toJSON(message: _152.QueryConsensusStateRequest): import("../json-safe.js").JsonSafe<_152.QueryConsensusStateRequest>;
+                    fromPartial(object: Partial<_152.QueryConsensusStateRequest>): _152.QueryConsensusStateRequest;
+                    fromProtoMsg(message: _152.QueryConsensusStateRequestProtoMsg): _152.QueryConsensusStateRequest;
+                    toProto(message: _152.QueryConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryConsensusStateRequest): _152.QueryConsensusStateRequestProtoMsg;
+                };
+                QueryConsensusStateResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryConsensusStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryConsensusStateResponse;
+                    fromJSON(object: any): _152.QueryConsensusStateResponse;
+                    toJSON(message: _152.QueryConsensusStateResponse): import("../json-safe.js").JsonSafe<_152.QueryConsensusStateResponse>;
+                    fromPartial(object: Partial<_152.QueryConsensusStateResponse>): _152.QueryConsensusStateResponse;
+                    fromProtoMsg(message: _152.QueryConsensusStateResponseProtoMsg): _152.QueryConsensusStateResponse;
+                    toProto(message: _152.QueryConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryConsensusStateResponse): _152.QueryConsensusStateResponseProtoMsg;
+                };
+                QueryConsensusStatesRequest: {
+                    typeUrl: string;
+                    encode(message: _152.QueryConsensusStatesRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryConsensusStatesRequest;
+                    fromJSON(object: any): _152.QueryConsensusStatesRequest;
+                    toJSON(message: _152.QueryConsensusStatesRequest): import("../json-safe.js").JsonSafe<_152.QueryConsensusStatesRequest>;
+                    fromPartial(object: Partial<_152.QueryConsensusStatesRequest>): _152.QueryConsensusStatesRequest;
+                    fromProtoMsg(message: _152.QueryConsensusStatesRequestProtoMsg): _152.QueryConsensusStatesRequest;
+                    toProto(message: _152.QueryConsensusStatesRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryConsensusStatesRequest): _152.QueryConsensusStatesRequestProtoMsg;
+                };
+                QueryConsensusStatesResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryConsensusStatesResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryConsensusStatesResponse;
+                    fromJSON(object: any): _152.QueryConsensusStatesResponse;
+                    toJSON(message: _152.QueryConsensusStatesResponse): import("../json-safe.js").JsonSafe<_152.QueryConsensusStatesResponse>;
+                    fromPartial(object: Partial<_152.QueryConsensusStatesResponse>): _152.QueryConsensusStatesResponse;
+                    fromProtoMsg(message: _152.QueryConsensusStatesResponseProtoMsg): _152.QueryConsensusStatesResponse;
+                    toProto(message: _152.QueryConsensusStatesResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryConsensusStatesResponse): _152.QueryConsensusStatesResponseProtoMsg;
+                };
+                QueryConsensusStateHeightsRequest: {
+                    typeUrl: string;
+                    encode(message: _152.QueryConsensusStateHeightsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryConsensusStateHeightsRequest;
+                    fromJSON(object: any): _152.QueryConsensusStateHeightsRequest;
+                    toJSON(message: _152.QueryConsensusStateHeightsRequest): import("../json-safe.js").JsonSafe<_152.QueryConsensusStateHeightsRequest>;
+                    fromPartial(object: Partial<_152.QueryConsensusStateHeightsRequest>): _152.QueryConsensusStateHeightsRequest;
+                    fromProtoMsg(message: _152.QueryConsensusStateHeightsRequestProtoMsg): _152.QueryConsensusStateHeightsRequest;
+                    toProto(message: _152.QueryConsensusStateHeightsRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryConsensusStateHeightsRequest): _152.QueryConsensusStateHeightsRequestProtoMsg;
+                };
+                QueryConsensusStateHeightsResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryConsensusStateHeightsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryConsensusStateHeightsResponse;
+                    fromJSON(object: any): _152.QueryConsensusStateHeightsResponse;
+                    toJSON(message: _152.QueryConsensusStateHeightsResponse): import("../json-safe.js").JsonSafe<_152.QueryConsensusStateHeightsResponse>;
+                    fromPartial(object: Partial<_152.QueryConsensusStateHeightsResponse>): _152.QueryConsensusStateHeightsResponse;
+                    fromProtoMsg(message: _152.QueryConsensusStateHeightsResponseProtoMsg): _152.QueryConsensusStateHeightsResponse;
+                    toProto(message: _152.QueryConsensusStateHeightsResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryConsensusStateHeightsResponse): _152.QueryConsensusStateHeightsResponseProtoMsg;
+                };
+                QueryClientStatusRequest: {
+                    typeUrl: string;
+                    encode(message: _152.QueryClientStatusRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryClientStatusRequest;
+                    fromJSON(object: any): _152.QueryClientStatusRequest;
+                    toJSON(message: _152.QueryClientStatusRequest): import("../json-safe.js").JsonSafe<_152.QueryClientStatusRequest>;
+                    fromPartial(object: Partial<_152.QueryClientStatusRequest>): _152.QueryClientStatusRequest;
+                    fromProtoMsg(message: _152.QueryClientStatusRequestProtoMsg): _152.QueryClientStatusRequest;
+                    toProto(message: _152.QueryClientStatusRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryClientStatusRequest): _152.QueryClientStatusRequestProtoMsg;
+                };
+                QueryClientStatusResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryClientStatusResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryClientStatusResponse;
+                    fromJSON(object: any): _152.QueryClientStatusResponse;
+                    toJSON(message: _152.QueryClientStatusResponse): import("../json-safe.js").JsonSafe<_152.QueryClientStatusResponse>;
+                    fromPartial(object: Partial<_152.QueryClientStatusResponse>): _152.QueryClientStatusResponse;
+                    fromProtoMsg(message: _152.QueryClientStatusResponseProtoMsg): _152.QueryClientStatusResponse;
+                    toProto(message: _152.QueryClientStatusResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryClientStatusResponse): _152.QueryClientStatusResponseProtoMsg;
+                };
+                QueryClientParamsRequest: {
+                    typeUrl: string;
+                    encode(_: _152.QueryClientParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryClientParamsRequest;
+                    fromJSON(_: any): _152.QueryClientParamsRequest;
+                    toJSON(_: _152.QueryClientParamsRequest): import("../json-safe.js").JsonSafe<_152.QueryClientParamsRequest>;
+                    fromPartial(_: Partial<_152.QueryClientParamsRequest>): _152.QueryClientParamsRequest;
+                    fromProtoMsg(message: _152.QueryClientParamsRequestProtoMsg): _152.QueryClientParamsRequest;
+                    toProto(message: _152.QueryClientParamsRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryClientParamsRequest): _152.QueryClientParamsRequestProtoMsg;
+                };
+                QueryClientParamsResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryClientParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryClientParamsResponse;
+                    fromJSON(object: any): _152.QueryClientParamsResponse;
+                    toJSON(message: _152.QueryClientParamsResponse): import("../json-safe.js").JsonSafe<_152.QueryClientParamsResponse>;
+                    fromPartial(object: Partial<_152.QueryClientParamsResponse>): _152.QueryClientParamsResponse;
+                    fromProtoMsg(message: _152.QueryClientParamsResponseProtoMsg): _152.QueryClientParamsResponse;
+                    toProto(message: _152.QueryClientParamsResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryClientParamsResponse): _152.QueryClientParamsResponseProtoMsg;
+                };
+                QueryUpgradedClientStateRequest: {
+                    typeUrl: string;
+                    encode(_: _152.QueryUpgradedClientStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryUpgradedClientStateRequest;
+                    fromJSON(_: any): _152.QueryUpgradedClientStateRequest;
+                    toJSON(_: _152.QueryUpgradedClientStateRequest): import("../json-safe.js").JsonSafe<_152.QueryUpgradedClientStateRequest>;
+                    fromPartial(_: Partial<_152.QueryUpgradedClientStateRequest>): _152.QueryUpgradedClientStateRequest;
+                    fromProtoMsg(message: _152.QueryUpgradedClientStateRequestProtoMsg): _152.QueryUpgradedClientStateRequest;
+                    toProto(message: _152.QueryUpgradedClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryUpgradedClientStateRequest): _152.QueryUpgradedClientStateRequestProtoMsg;
+                };
+                QueryUpgradedClientStateResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryUpgradedClientStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryUpgradedClientStateResponse;
+                    fromJSON(object: any): _152.QueryUpgradedClientStateResponse;
+                    toJSON(message: _152.QueryUpgradedClientStateResponse): import("../json-safe.js").JsonSafe<_152.QueryUpgradedClientStateResponse>;
+                    fromPartial(object: Partial<_152.QueryUpgradedClientStateResponse>): _152.QueryUpgradedClientStateResponse;
+                    fromProtoMsg(message: _152.QueryUpgradedClientStateResponseProtoMsg): _152.QueryUpgradedClientStateResponse;
+                    toProto(message: _152.QueryUpgradedClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryUpgradedClientStateResponse): _152.QueryUpgradedClientStateResponseProtoMsg;
+                };
+                QueryUpgradedConsensusStateRequest: {
+                    typeUrl: string;
+                    encode(_: _152.QueryUpgradedConsensusStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryUpgradedConsensusStateRequest;
+                    fromJSON(_: any): _152.QueryUpgradedConsensusStateRequest;
+                    toJSON(_: _152.QueryUpgradedConsensusStateRequest): import("../json-safe.js").JsonSafe<_152.QueryUpgradedConsensusStateRequest>;
+                    fromPartial(_: Partial<_152.QueryUpgradedConsensusStateRequest>): _152.QueryUpgradedConsensusStateRequest;
+                    fromProtoMsg(message: _152.QueryUpgradedConsensusStateRequestProtoMsg): _152.QueryUpgradedConsensusStateRequest;
+                    toProto(message: _152.QueryUpgradedConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _152.QueryUpgradedConsensusStateRequest): _152.QueryUpgradedConsensusStateRequestProtoMsg;
+                };
+                QueryUpgradedConsensusStateResponse: {
+                    typeUrl: string;
+                    encode(message: _152.QueryUpgradedConsensusStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _152.QueryUpgradedConsensusStateResponse;
+                    fromJSON(object: any): _152.QueryUpgradedConsensusStateResponse;
+                    toJSON(message: _152.QueryUpgradedConsensusStateResponse): import("../json-safe.js").JsonSafe<_152.QueryUpgradedConsensusStateResponse>;
+                    fromPartial(object: Partial<_152.QueryUpgradedConsensusStateResponse>): _152.QueryUpgradedConsensusStateResponse;
+                    fromProtoMsg(message: _152.QueryUpgradedConsensusStateResponseProtoMsg): _152.QueryUpgradedConsensusStateResponse;
+                    toProto(message: _152.QueryUpgradedConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _152.QueryUpgradedConsensusStateResponse): _152.QueryUpgradedConsensusStateResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: string;
+                    encode(message: _151.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _151.GenesisState;
+                    fromJSON(object: any): _151.GenesisState;
+                    toJSON(message: _151.GenesisState): import("../json-safe.js").JsonSafe<_151.GenesisState>;
+                    fromPartial(object: Partial<_151.GenesisState>): _151.GenesisState;
+                    fromProtoMsg(message: _151.GenesisStateProtoMsg): _151.GenesisState;
+                    toProto(message: _151.GenesisState): Uint8Array;
+                    toProtoMsg(message: _151.GenesisState): _151.GenesisStateProtoMsg;
+                };
+                GenesisMetadata: {
+                    typeUrl: string;
+                    encode(message: _151.GenesisMetadata, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _151.GenesisMetadata;
+                    fromJSON(object: any): _151.GenesisMetadata;
+                    toJSON(message: _151.GenesisMetadata): import("../json-safe.js").JsonSafe<_151.GenesisMetadata>;
+                    fromPartial(object: Partial<_151.GenesisMetadata>): _151.GenesisMetadata;
+                    fromProtoMsg(message: _151.GenesisMetadataProtoMsg): _151.GenesisMetadata;
+                    toProto(message: _151.GenesisMetadata): Uint8Array;
+                    toProtoMsg(message: _151.GenesisMetadata): _151.GenesisMetadataProtoMsg;
+                };
+                IdentifiedGenesisMetadata: {
+                    typeUrl: string;
+                    encode(message: _151.IdentifiedGenesisMetadata, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _151.IdentifiedGenesisMetadata;
+                    fromJSON(object: any): _151.IdentifiedGenesisMetadata;
+                    toJSON(message: _151.IdentifiedGenesisMetadata): import("../json-safe.js").JsonSafe<_151.IdentifiedGenesisMetadata>;
+                    fromPartial(object: Partial<_151.IdentifiedGenesisMetadata>): _151.IdentifiedGenesisMetadata;
+                    fromProtoMsg(message: _151.IdentifiedGenesisMetadataProtoMsg): _151.IdentifiedGenesisMetadata;
+                    toProto(message: _151.IdentifiedGenesisMetadata): Uint8Array;
+                    toProtoMsg(message: _151.IdentifiedGenesisMetadata): _151.IdentifiedGenesisMetadataProtoMsg;
+                };
+                IdentifiedClientState: {
+                    typeUrl: string;
+                    encode(message: _150.IdentifiedClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _150.IdentifiedClientState;
+                    fromJSON(object: any): _150.IdentifiedClientState;
+                    toJSON(message: _150.IdentifiedClientState): import("../json-safe.js").JsonSafe<_150.IdentifiedClientState>;
+                    fromPartial(object: Partial<_150.IdentifiedClientState>): _150.IdentifiedClientState;
+                    fromProtoMsg(message: _150.IdentifiedClientStateProtoMsg): _150.IdentifiedClientState;
+                    toProto(message: _150.IdentifiedClientState): Uint8Array;
+                    toProtoMsg(message: _150.IdentifiedClientState): _150.IdentifiedClientStateProtoMsg;
+                };
+                ConsensusStateWithHeight: {
+                    typeUrl: string;
+                    encode(message: _150.ConsensusStateWithHeight, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _150.ConsensusStateWithHeight;
+                    fromJSON(object: any): _150.ConsensusStateWithHeight;
+                    toJSON(message: _150.ConsensusStateWithHeight): import("../json-safe.js").JsonSafe<_150.ConsensusStateWithHeight>;
+                    fromPartial(object: Partial<_150.ConsensusStateWithHeight>): _150.ConsensusStateWithHeight;
+                    fromProtoMsg(message: _150.ConsensusStateWithHeightProtoMsg): _150.ConsensusStateWithHeight;
+                    toProto(message: _150.ConsensusStateWithHeight): Uint8Array;
+                    toProtoMsg(message: _150.ConsensusStateWithHeight): _150.ConsensusStateWithHeightProtoMsg;
+                };
+                ClientConsensusStates: {
+                    typeUrl: string;
+                    encode(message: _150.ClientConsensusStates, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _150.ClientConsensusStates;
+                    fromJSON(object: any): _150.ClientConsensusStates;
+                    toJSON(message: _150.ClientConsensusStates): import("../json-safe.js").JsonSafe<_150.ClientConsensusStates>;
+                    fromPartial(object: Partial<_150.ClientConsensusStates>): _150.ClientConsensusStates;
+                    fromProtoMsg(message: _150.ClientConsensusStatesProtoMsg): _150.ClientConsensusStates;
+                    toProto(message: _150.ClientConsensusStates): Uint8Array;
+                    toProtoMsg(message: _150.ClientConsensusStates): _150.ClientConsensusStatesProtoMsg;
+                };
+                ClientUpdateProposal: {
+                    typeUrl: string;
+                    encode(message: _150.ClientUpdateProposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _150.ClientUpdateProposal;
+                    fromJSON(object: any): _150.ClientUpdateProposal;
+                    toJSON(message: _150.ClientUpdateProposal): import("../json-safe.js").JsonSafe<_150.ClientUpdateProposal>;
+                    fromPartial(object: Partial<_150.ClientUpdateProposal>): _150.ClientUpdateProposal;
+                    fromProtoMsg(message: _150.ClientUpdateProposalProtoMsg): _150.ClientUpdateProposal;
+                    toProto(message: _150.ClientUpdateProposal): Uint8Array;
+                    toProtoMsg(message: _150.ClientUpdateProposal): _150.ClientUpdateProposalProtoMsg;
+                };
+                UpgradeProposal: {
+                    typeUrl: string;
+                    encode(message: _150.UpgradeProposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _150.UpgradeProposal;
+                    fromJSON(object: any): _150.UpgradeProposal;
+                    toJSON(message: _150.UpgradeProposal): import("../json-safe.js").JsonSafe<_150.UpgradeProposal>;
+                    fromPartial(object: Partial<_150.UpgradeProposal>): _150.UpgradeProposal;
+                    fromProtoMsg(message: _150.UpgradeProposalProtoMsg): _150.UpgradeProposal;
+                    toProto(message: _150.UpgradeProposal): Uint8Array;
+                    toProtoMsg(message: _150.UpgradeProposal): _150.UpgradeProposalProtoMsg;
+                };
+                Height: {
+                    typeUrl: string;
+                    encode(message: _150.Height, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _150.Height;
+                    fromJSON(object: any): _150.Height;
+                    toJSON(message: _150.Height): import("../json-safe.js").JsonSafe<_150.Height>;
+                    fromPartial(object: Partial<_150.Height>): _150.Height;
+                    fromProtoMsg(message: _150.HeightProtoMsg): _150.Height;
+                    toProto(message: _150.Height): Uint8Array;
+                    toProtoMsg(message: _150.Height): _150.HeightProtoMsg;
+                };
+                Params: {
+                    typeUrl: string;
+                    encode(message: _150.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _150.Params;
+                    fromJSON(object: any): _150.Params;
+                    toJSON(message: _150.Params): import("../json-safe.js").JsonSafe<_150.Params>;
+                    fromPartial(object: Partial<_150.Params>): _150.Params;
+                    fromProtoMsg(message: _150.ParamsProtoMsg): _150.Params;
+                    toProto(message: _150.Params): Uint8Array;
+                    toProtoMsg(message: _150.Params): _150.ParamsProtoMsg;
+                };
+            };
+        }
+        namespace commitment {
+            const v1: {
+                MerkleRoot: {
+                    typeUrl: string;
+                    encode(message: _154.MerkleRoot, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _154.MerkleRoot;
+                    fromJSON(object: any): _154.MerkleRoot;
+                    toJSON(message: _154.MerkleRoot): import("../json-safe.js").JsonSafe<_154.MerkleRoot>;
+                    fromPartial(object: Partial<_154.MerkleRoot>): _154.MerkleRoot;
+                    fromProtoMsg(message: _154.MerkleRootProtoMsg): _154.MerkleRoot;
+                    toProto(message: _154.MerkleRoot): Uint8Array;
+                    toProtoMsg(message: _154.MerkleRoot): _154.MerkleRootProtoMsg;
+                };
+                MerklePrefix: {
+                    typeUrl: string;
+                    encode(message: _154.MerklePrefix, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _154.MerklePrefix;
+                    fromJSON(object: any): _154.MerklePrefix;
+                    toJSON(message: _154.MerklePrefix): import("../json-safe.js").JsonSafe<_154.MerklePrefix>;
+                    fromPartial(object: Partial<_154.MerklePrefix>): _154.MerklePrefix;
+                    fromProtoMsg(message: _154.MerklePrefixProtoMsg): _154.MerklePrefix;
+                    toProto(message: _154.MerklePrefix): Uint8Array;
+                    toProtoMsg(message: _154.MerklePrefix): _154.MerklePrefixProtoMsg;
+                };
+                MerklePath: {
+                    typeUrl: string;
+                    encode(message: _154.MerklePath, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _154.MerklePath;
+                    fromJSON(object: any): _154.MerklePath;
+                    toJSON(message: _154.MerklePath): import("../json-safe.js").JsonSafe<_154.MerklePath>;
+                    fromPartial(object: Partial<_154.MerklePath>): _154.MerklePath;
+                    fromProtoMsg(message: _154.MerklePathProtoMsg): _154.MerklePath;
+                    toProto(message: _154.MerklePath): Uint8Array;
+                    toProtoMsg(message: _154.MerklePath): _154.MerklePathProtoMsg;
+                };
+                MerkleProof: {
+                    typeUrl: string;
+                    encode(message: _154.MerkleProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _154.MerkleProof;
+                    fromJSON(object: any): _154.MerkleProof;
+                    toJSON(message: _154.MerkleProof): import("../json-safe.js").JsonSafe<_154.MerkleProof>;
+                    fromPartial(object: Partial<_154.MerkleProof>): _154.MerkleProof;
+                    fromProtoMsg(message: _154.MerkleProofProtoMsg): _154.MerkleProof;
+                    toProto(message: _154.MerkleProof): Uint8Array;
+                    toProtoMsg(message: _154.MerkleProof): _154.MerkleProofProtoMsg;
+                };
+            };
+        }
+        namespace connection {
+            const v1: {
+                MsgClientImpl: typeof _260.MsgClientImpl;
+                QueryClientImpl: typeof _254.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    connection(request: _157.QueryConnectionRequest): Promise<_157.QueryConnectionResponse>;
+                    connections(request?: _157.QueryConnectionsRequest): Promise<_157.QueryConnectionsResponse>;
+                    clientConnections(request: _157.QueryClientConnectionsRequest): Promise<_157.QueryClientConnectionsResponse>;
+                    connectionClientState(request: _157.QueryConnectionClientStateRequest): Promise<_157.QueryConnectionClientStateResponse>;
+                    connectionConsensusState(request: _157.QueryConnectionConsensusStateRequest): Promise<_157.QueryConnectionConsensusStateResponse>;
+                    connectionParams(request?: _157.QueryConnectionParamsRequest): Promise<_157.QueryConnectionParamsResponse>;
+                };
+                MsgConnectionOpenInit: {
+                    typeUrl: string;
+                    encode(message: _158.MsgConnectionOpenInit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _158.MsgConnectionOpenInit;
+                    fromJSON(object: any): _158.MsgConnectionOpenInit;
+                    toJSON(message: _158.MsgConnectionOpenInit): import("../json-safe.js").JsonSafe<_158.MsgConnectionOpenInit>;
+                    fromPartial(object: Partial<_158.MsgConnectionOpenInit>): _158.MsgConnectionOpenInit;
+                    fromProtoMsg(message: _158.MsgConnectionOpenInitProtoMsg): _158.MsgConnectionOpenInit;
+                    toProto(message: _158.MsgConnectionOpenInit): Uint8Array;
+                    toProtoMsg(message: _158.MsgConnectionOpenInit): _158.MsgConnectionOpenInitProtoMsg;
+                };
+                MsgConnectionOpenInitResponse: {
+                    typeUrl: string;
+                    encode(_: _158.MsgConnectionOpenInitResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _158.MsgConnectionOpenInitResponse;
+                    fromJSON(_: any): _158.MsgConnectionOpenInitResponse;
+                    toJSON(_: _158.MsgConnectionOpenInitResponse): import("../json-safe.js").JsonSafe<_158.MsgConnectionOpenInitResponse>;
+                    fromPartial(_: Partial<_158.MsgConnectionOpenInitResponse>): _158.MsgConnectionOpenInitResponse;
+                    fromProtoMsg(message: _158.MsgConnectionOpenInitResponseProtoMsg): _158.MsgConnectionOpenInitResponse;
+                    toProto(message: _158.MsgConnectionOpenInitResponse): Uint8Array;
+                    toProtoMsg(message: _158.MsgConnectionOpenInitResponse): _158.MsgConnectionOpenInitResponseProtoMsg;
+                };
+                MsgConnectionOpenTry: {
+                    typeUrl: string;
+                    encode(message: _158.MsgConnectionOpenTry, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _158.MsgConnectionOpenTry;
+                    fromJSON(object: any): _158.MsgConnectionOpenTry;
+                    toJSON(message: _158.MsgConnectionOpenTry): import("../json-safe.js").JsonSafe<_158.MsgConnectionOpenTry>;
+                    fromPartial(object: Partial<_158.MsgConnectionOpenTry>): _158.MsgConnectionOpenTry;
+                    fromProtoMsg(message: _158.MsgConnectionOpenTryProtoMsg): _158.MsgConnectionOpenTry;
+                    toProto(message: _158.MsgConnectionOpenTry): Uint8Array;
+                    toProtoMsg(message: _158.MsgConnectionOpenTry): _158.MsgConnectionOpenTryProtoMsg;
+                };
+                MsgConnectionOpenTryResponse: {
+                    typeUrl: string;
+                    encode(_: _158.MsgConnectionOpenTryResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _158.MsgConnectionOpenTryResponse;
+                    fromJSON(_: any): _158.MsgConnectionOpenTryResponse;
+                    toJSON(_: _158.MsgConnectionOpenTryResponse): import("../json-safe.js").JsonSafe<_158.MsgConnectionOpenTryResponse>;
+                    fromPartial(_: Partial<_158.MsgConnectionOpenTryResponse>): _158.MsgConnectionOpenTryResponse;
+                    fromProtoMsg(message: _158.MsgConnectionOpenTryResponseProtoMsg): _158.MsgConnectionOpenTryResponse;
+                    toProto(message: _158.MsgConnectionOpenTryResponse): Uint8Array;
+                    toProtoMsg(message: _158.MsgConnectionOpenTryResponse): _158.MsgConnectionOpenTryResponseProtoMsg;
+                };
+                MsgConnectionOpenAck: {
+                    typeUrl: string;
+                    encode(message: _158.MsgConnectionOpenAck, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _158.MsgConnectionOpenAck;
+                    fromJSON(object: any): _158.MsgConnectionOpenAck;
+                    toJSON(message: _158.MsgConnectionOpenAck): import("../json-safe.js").JsonSafe<_158.MsgConnectionOpenAck>;
+                    fromPartial(object: Partial<_158.MsgConnectionOpenAck>): _158.MsgConnectionOpenAck;
+                    fromProtoMsg(message: _158.MsgConnectionOpenAckProtoMsg): _158.MsgConnectionOpenAck;
+                    toProto(message: _158.MsgConnectionOpenAck): Uint8Array;
+                    toProtoMsg(message: _158.MsgConnectionOpenAck): _158.MsgConnectionOpenAckProtoMsg;
+                };
+                MsgConnectionOpenAckResponse: {
+                    typeUrl: string;
+                    encode(_: _158.MsgConnectionOpenAckResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _158.MsgConnectionOpenAckResponse;
+                    fromJSON(_: any): _158.MsgConnectionOpenAckResponse;
+                    toJSON(_: _158.MsgConnectionOpenAckResponse): import("../json-safe.js").JsonSafe<_158.MsgConnectionOpenAckResponse>;
+                    fromPartial(_: Partial<_158.MsgConnectionOpenAckResponse>): _158.MsgConnectionOpenAckResponse;
+                    fromProtoMsg(message: _158.MsgConnectionOpenAckResponseProtoMsg): _158.MsgConnectionOpenAckResponse;
+                    toProto(message: _158.MsgConnectionOpenAckResponse): Uint8Array;
+                    toProtoMsg(message: _158.MsgConnectionOpenAckResponse): _158.MsgConnectionOpenAckResponseProtoMsg;
+                };
+                MsgConnectionOpenConfirm: {
+                    typeUrl: string;
+                    encode(message: _158.MsgConnectionOpenConfirm, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _158.MsgConnectionOpenConfirm;
+                    fromJSON(object: any): _158.MsgConnectionOpenConfirm;
+                    toJSON(message: _158.MsgConnectionOpenConfirm): import("../json-safe.js").JsonSafe<_158.MsgConnectionOpenConfirm>;
+                    fromPartial(object: Partial<_158.MsgConnectionOpenConfirm>): _158.MsgConnectionOpenConfirm;
+                    fromProtoMsg(message: _158.MsgConnectionOpenConfirmProtoMsg): _158.MsgConnectionOpenConfirm;
+                    toProto(message: _158.MsgConnectionOpenConfirm): Uint8Array;
+                    toProtoMsg(message: _158.MsgConnectionOpenConfirm): _158.MsgConnectionOpenConfirmProtoMsg;
+                };
+                MsgConnectionOpenConfirmResponse: {
+                    typeUrl: string;
+                    encode(_: _158.MsgConnectionOpenConfirmResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _158.MsgConnectionOpenConfirmResponse;
+                    fromJSON(_: any): _158.MsgConnectionOpenConfirmResponse;
+                    toJSON(_: _158.MsgConnectionOpenConfirmResponse): import("../json-safe.js").JsonSafe<_158.MsgConnectionOpenConfirmResponse>;
+                    fromPartial(_: Partial<_158.MsgConnectionOpenConfirmResponse>): _158.MsgConnectionOpenConfirmResponse;
+                    fromProtoMsg(message: _158.MsgConnectionOpenConfirmResponseProtoMsg): _158.MsgConnectionOpenConfirmResponse;
+                    toProto(message: _158.MsgConnectionOpenConfirmResponse): Uint8Array;
+                    toProtoMsg(message: _158.MsgConnectionOpenConfirmResponse): _158.MsgConnectionOpenConfirmResponseProtoMsg;
+                };
+                QueryConnectionRequest: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionRequest;
+                    fromJSON(object: any): _157.QueryConnectionRequest;
+                    toJSON(message: _157.QueryConnectionRequest): import("../json-safe.js").JsonSafe<_157.QueryConnectionRequest>;
+                    fromPartial(object: Partial<_157.QueryConnectionRequest>): _157.QueryConnectionRequest;
+                    fromProtoMsg(message: _157.QueryConnectionRequestProtoMsg): _157.QueryConnectionRequest;
+                    toProto(message: _157.QueryConnectionRequest): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionRequest): _157.QueryConnectionRequestProtoMsg;
+                };
+                QueryConnectionResponse: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionResponse;
+                    fromJSON(object: any): _157.QueryConnectionResponse;
+                    toJSON(message: _157.QueryConnectionResponse): import("../json-safe.js").JsonSafe<_157.QueryConnectionResponse>;
+                    fromPartial(object: Partial<_157.QueryConnectionResponse>): _157.QueryConnectionResponse;
+                    fromProtoMsg(message: _157.QueryConnectionResponseProtoMsg): _157.QueryConnectionResponse;
+                    toProto(message: _157.QueryConnectionResponse): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionResponse): _157.QueryConnectionResponseProtoMsg;
+                };
+                QueryConnectionsRequest: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionsRequest;
+                    fromJSON(object: any): _157.QueryConnectionsRequest;
+                    toJSON(message: _157.QueryConnectionsRequest): import("../json-safe.js").JsonSafe<_157.QueryConnectionsRequest>;
+                    fromPartial(object: Partial<_157.QueryConnectionsRequest>): _157.QueryConnectionsRequest;
+                    fromProtoMsg(message: _157.QueryConnectionsRequestProtoMsg): _157.QueryConnectionsRequest;
+                    toProto(message: _157.QueryConnectionsRequest): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionsRequest): _157.QueryConnectionsRequestProtoMsg;
+                };
+                QueryConnectionsResponse: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionsResponse;
+                    fromJSON(object: any): _157.QueryConnectionsResponse;
+                    toJSON(message: _157.QueryConnectionsResponse): import("../json-safe.js").JsonSafe<_157.QueryConnectionsResponse>;
+                    fromPartial(object: Partial<_157.QueryConnectionsResponse>): _157.QueryConnectionsResponse;
+                    fromProtoMsg(message: _157.QueryConnectionsResponseProtoMsg): _157.QueryConnectionsResponse;
+                    toProto(message: _157.QueryConnectionsResponse): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionsResponse): _157.QueryConnectionsResponseProtoMsg;
+                };
+                QueryClientConnectionsRequest: {
+                    typeUrl: string;
+                    encode(message: _157.QueryClientConnectionsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryClientConnectionsRequest;
+                    fromJSON(object: any): _157.QueryClientConnectionsRequest;
+                    toJSON(message: _157.QueryClientConnectionsRequest): import("../json-safe.js").JsonSafe<_157.QueryClientConnectionsRequest>;
+                    fromPartial(object: Partial<_157.QueryClientConnectionsRequest>): _157.QueryClientConnectionsRequest;
+                    fromProtoMsg(message: _157.QueryClientConnectionsRequestProtoMsg): _157.QueryClientConnectionsRequest;
+                    toProto(message: _157.QueryClientConnectionsRequest): Uint8Array;
+                    toProtoMsg(message: _157.QueryClientConnectionsRequest): _157.QueryClientConnectionsRequestProtoMsg;
+                };
+                QueryClientConnectionsResponse: {
+                    typeUrl: string;
+                    encode(message: _157.QueryClientConnectionsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryClientConnectionsResponse;
+                    fromJSON(object: any): _157.QueryClientConnectionsResponse;
+                    toJSON(message: _157.QueryClientConnectionsResponse): import("../json-safe.js").JsonSafe<_157.QueryClientConnectionsResponse>;
+                    fromPartial(object: Partial<_157.QueryClientConnectionsResponse>): _157.QueryClientConnectionsResponse;
+                    fromProtoMsg(message: _157.QueryClientConnectionsResponseProtoMsg): _157.QueryClientConnectionsResponse;
+                    toProto(message: _157.QueryClientConnectionsResponse): Uint8Array;
+                    toProtoMsg(message: _157.QueryClientConnectionsResponse): _157.QueryClientConnectionsResponseProtoMsg;
+                };
+                QueryConnectionClientStateRequest: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionClientStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionClientStateRequest;
+                    fromJSON(object: any): _157.QueryConnectionClientStateRequest;
+                    toJSON(message: _157.QueryConnectionClientStateRequest): import("../json-safe.js").JsonSafe<_157.QueryConnectionClientStateRequest>;
+                    fromPartial(object: Partial<_157.QueryConnectionClientStateRequest>): _157.QueryConnectionClientStateRequest;
+                    fromProtoMsg(message: _157.QueryConnectionClientStateRequestProtoMsg): _157.QueryConnectionClientStateRequest;
+                    toProto(message: _157.QueryConnectionClientStateRequest): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionClientStateRequest): _157.QueryConnectionClientStateRequestProtoMsg;
+                };
+                QueryConnectionClientStateResponse: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionClientStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionClientStateResponse;
+                    fromJSON(object: any): _157.QueryConnectionClientStateResponse;
+                    toJSON(message: _157.QueryConnectionClientStateResponse): import("../json-safe.js").JsonSafe<_157.QueryConnectionClientStateResponse>;
+                    fromPartial(object: Partial<_157.QueryConnectionClientStateResponse>): _157.QueryConnectionClientStateResponse;
+                    fromProtoMsg(message: _157.QueryConnectionClientStateResponseProtoMsg): _157.QueryConnectionClientStateResponse;
+                    toProto(message: _157.QueryConnectionClientStateResponse): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionClientStateResponse): _157.QueryConnectionClientStateResponseProtoMsg;
+                };
+                QueryConnectionConsensusStateRequest: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionConsensusStateRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionConsensusStateRequest;
+                    fromJSON(object: any): _157.QueryConnectionConsensusStateRequest;
+                    toJSON(message: _157.QueryConnectionConsensusStateRequest): import("../json-safe.js").JsonSafe<_157.QueryConnectionConsensusStateRequest>;
+                    fromPartial(object: Partial<_157.QueryConnectionConsensusStateRequest>): _157.QueryConnectionConsensusStateRequest;
+                    fromProtoMsg(message: _157.QueryConnectionConsensusStateRequestProtoMsg): _157.QueryConnectionConsensusStateRequest;
+                    toProto(message: _157.QueryConnectionConsensusStateRequest): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionConsensusStateRequest): _157.QueryConnectionConsensusStateRequestProtoMsg;
+                };
+                QueryConnectionConsensusStateResponse: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionConsensusStateResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionConsensusStateResponse;
+                    fromJSON(object: any): _157.QueryConnectionConsensusStateResponse;
+                    toJSON(message: _157.QueryConnectionConsensusStateResponse): import("../json-safe.js").JsonSafe<_157.QueryConnectionConsensusStateResponse>;
+                    fromPartial(object: Partial<_157.QueryConnectionConsensusStateResponse>): _157.QueryConnectionConsensusStateResponse;
+                    fromProtoMsg(message: _157.QueryConnectionConsensusStateResponseProtoMsg): _157.QueryConnectionConsensusStateResponse;
+                    toProto(message: _157.QueryConnectionConsensusStateResponse): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionConsensusStateResponse): _157.QueryConnectionConsensusStateResponseProtoMsg;
+                };
+                QueryConnectionParamsRequest: {
+                    typeUrl: string;
+                    encode(_: _157.QueryConnectionParamsRequest, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionParamsRequest;
+                    fromJSON(_: any): _157.QueryConnectionParamsRequest;
+                    toJSON(_: _157.QueryConnectionParamsRequest): import("../json-safe.js").JsonSafe<_157.QueryConnectionParamsRequest>;
+                    fromPartial(_: Partial<_157.QueryConnectionParamsRequest>): _157.QueryConnectionParamsRequest;
+                    fromProtoMsg(message: _157.QueryConnectionParamsRequestProtoMsg): _157.QueryConnectionParamsRequest;
+                    toProto(message: _157.QueryConnectionParamsRequest): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionParamsRequest): _157.QueryConnectionParamsRequestProtoMsg;
+                };
+                QueryConnectionParamsResponse: {
+                    typeUrl: string;
+                    encode(message: _157.QueryConnectionParamsResponse, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _157.QueryConnectionParamsResponse;
+                    fromJSON(object: any): _157.QueryConnectionParamsResponse;
+                    toJSON(message: _157.QueryConnectionParamsResponse): import("../json-safe.js").JsonSafe<_157.QueryConnectionParamsResponse>;
+                    fromPartial(object: Partial<_157.QueryConnectionParamsResponse>): _157.QueryConnectionParamsResponse;
+                    fromProtoMsg(message: _157.QueryConnectionParamsResponseProtoMsg): _157.QueryConnectionParamsResponse;
+                    toProto(message: _157.QueryConnectionParamsResponse): Uint8Array;
+                    toProtoMsg(message: _157.QueryConnectionParamsResponse): _157.QueryConnectionParamsResponseProtoMsg;
+                };
+                GenesisState: {
+                    typeUrl: string;
+                    encode(message: _156.GenesisState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _156.GenesisState;
+                    fromJSON(object: any): _156.GenesisState;
+                    toJSON(message: _156.GenesisState): import("../json-safe.js").JsonSafe<_156.GenesisState>;
+                    fromPartial(object: Partial<_156.GenesisState>): _156.GenesisState;
+                    fromProtoMsg(message: _156.GenesisStateProtoMsg): _156.GenesisState;
+                    toProto(message: _156.GenesisState): Uint8Array;
+                    toProtoMsg(message: _156.GenesisState): _156.GenesisStateProtoMsg;
+                };
+                stateFromJSON(object: any): _155.State;
+                stateToJSON(object: _155.State): string;
+                State: typeof _155.State;
+                StateSDKType: typeof _155.State;
+                ConnectionEnd: {
+                    typeUrl: string;
+                    encode(message: _155.ConnectionEnd, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _155.ConnectionEnd;
+                    fromJSON(object: any): _155.ConnectionEnd;
+                    toJSON(message: _155.ConnectionEnd): import("../json-safe.js").JsonSafe<_155.ConnectionEnd>;
+                    fromPartial(object: Partial<_155.ConnectionEnd>): _155.ConnectionEnd;
+                    fromProtoMsg(message: _155.ConnectionEndProtoMsg): _155.ConnectionEnd;
+                    toProto(message: _155.ConnectionEnd): Uint8Array;
+                    toProtoMsg(message: _155.ConnectionEnd): _155.ConnectionEndProtoMsg;
+                };
+                IdentifiedConnection: {
+                    typeUrl: string;
+                    encode(message: _155.IdentifiedConnection, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _155.IdentifiedConnection;
+                    fromJSON(object: any): _155.IdentifiedConnection;
+                    toJSON(message: _155.IdentifiedConnection): import("../json-safe.js").JsonSafe<_155.IdentifiedConnection>;
+                    fromPartial(object: Partial<_155.IdentifiedConnection>): _155.IdentifiedConnection;
+                    fromProtoMsg(message: _155.IdentifiedConnectionProtoMsg): _155.IdentifiedConnection;
+                    toProto(message: _155.IdentifiedConnection): Uint8Array;
+                    toProtoMsg(message: _155.IdentifiedConnection): _155.IdentifiedConnectionProtoMsg;
+                };
+                Counterparty: {
+                    typeUrl: string;
+                    encode(message: _155.Counterparty, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _155.Counterparty;
+                    fromJSON(object: any): _155.Counterparty;
+                    toJSON(message: _155.Counterparty): import("../json-safe.js").JsonSafe<_155.Counterparty>;
+                    fromPartial(object: Partial<_155.Counterparty>): _155.Counterparty;
+                    fromProtoMsg(message: _155.CounterpartyProtoMsg): _155.Counterparty;
+                    toProto(message: _155.Counterparty): Uint8Array;
+                    toProtoMsg(message: _155.Counterparty): _155.CounterpartyProtoMsg;
+                };
+                ClientPaths: {
+                    typeUrl: string;
+                    encode(message: _155.ClientPaths, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _155.ClientPaths;
+                    fromJSON(object: any): _155.ClientPaths;
+                    toJSON(message: _155.ClientPaths): import("../json-safe.js").JsonSafe<_155.ClientPaths>;
+                    fromPartial(object: Partial<_155.ClientPaths>): _155.ClientPaths;
+                    fromProtoMsg(message: _155.ClientPathsProtoMsg): _155.ClientPaths;
+                    toProto(message: _155.ClientPaths): Uint8Array;
+                    toProtoMsg(message: _155.ClientPaths): _155.ClientPathsProtoMsg;
+                };
+                ConnectionPaths: {
+                    typeUrl: string;
+                    encode(message: _155.ConnectionPaths, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _155.ConnectionPaths;
+                    fromJSON(object: any): _155.ConnectionPaths;
+                    toJSON(message: _155.ConnectionPaths): import("../json-safe.js").JsonSafe<_155.ConnectionPaths>;
+                    fromPartial(object: Partial<_155.ConnectionPaths>): _155.ConnectionPaths;
+                    fromProtoMsg(message: _155.ConnectionPathsProtoMsg): _155.ConnectionPaths;
+                    toProto(message: _155.ConnectionPaths): Uint8Array;
+                    toProtoMsg(message: _155.ConnectionPaths): _155.ConnectionPathsProtoMsg;
+                };
+                Version: {
+                    typeUrl: string;
+                    encode(message: _155.Version, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _155.Version;
+                    fromJSON(object: any): _155.Version;
+                    toJSON(message: _155.Version): import("../json-safe.js").JsonSafe<_155.Version>;
+                    fromPartial(object: Partial<_155.Version>): _155.Version;
+                    fromProtoMsg(message: _155.VersionProtoMsg): _155.Version;
+                    toProto(message: _155.Version): Uint8Array;
+                    toProtoMsg(message: _155.Version): _155.VersionProtoMsg;
+                };
+                Params: {
+                    typeUrl: string;
+                    encode(message: _155.Params, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _155.Params;
+                    fromJSON(object: any): _155.Params;
+                    toJSON(message: _155.Params): import("../json-safe.js").JsonSafe<_155.Params>;
+                    fromPartial(object: Partial<_155.Params>): _155.Params;
+                    fromProtoMsg(message: _155.ParamsProtoMsg): _155.Params;
+                    toProto(message: _155.Params): Uint8Array;
+                    toProtoMsg(message: _155.Params): _155.ParamsProtoMsg;
+                };
+            };
+        }
+    }
+    namespace lightclients {
+        namespace localhost {
+            const v1: {
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _159.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _159.ClientState;
+                    fromJSON(object: any): _159.ClientState;
+                    toJSON(message: _159.ClientState): import("../json-safe.js").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;
+                };
+            };
+            const v2: {
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _160.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _160.ClientState;
+                    fromJSON(object: any): _160.ClientState;
+                    toJSON(message: _160.ClientState): import("../json-safe.js").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;
+                };
+            };
+        }
+        namespace solomachine {
+            const v1: {
+                dataTypeFromJSON(object: any): _161.DataType;
+                dataTypeToJSON(object: _161.DataType): string;
+                DataType: typeof _161.DataType;
+                DataTypeSDKType: typeof _161.DataType;
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _161.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.ClientState;
+                    fromJSON(object: any): _161.ClientState;
+                    toJSON(message: _161.ClientState): import("../json-safe.js").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: string;
+                    encode(message: _161.ConsensusState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.ConsensusState;
+                    fromJSON(object: any): _161.ConsensusState;
+                    toJSON(message: _161.ConsensusState): import("../json-safe.js").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: string;
+                    encode(message: _161.Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.Header;
+                    fromJSON(object: any): _161.Header;
+                    toJSON(message: _161.Header): import("../json-safe.js").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: string;
+                    encode(message: _161.Misbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.Misbehaviour;
+                    fromJSON(object: any): _161.Misbehaviour;
+                    toJSON(message: _161.Misbehaviour): import("../json-safe.js").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: string;
+                    encode(message: _161.SignatureAndData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.SignatureAndData;
+                    fromJSON(object: any): _161.SignatureAndData;
+                    toJSON(message: _161.SignatureAndData): import("../json-safe.js").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: string;
+                    encode(message: _161.TimestampedSignatureData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.TimestampedSignatureData;
+                    fromJSON(object: any): _161.TimestampedSignatureData;
+                    toJSON(message: _161.TimestampedSignatureData): import("../json-safe.js").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: string;
+                    encode(message: _161.SignBytes, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.SignBytes;
+                    fromJSON(object: any): _161.SignBytes;
+                    toJSON(message: _161.SignBytes): import("../json-safe.js").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: string;
+                    encode(message: _161.HeaderData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.HeaderData;
+                    fromJSON(object: any): _161.HeaderData;
+                    toJSON(message: _161.HeaderData): import("../json-safe.js").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;
+                };
+                ClientStateData: {
+                    typeUrl: string;
+                    encode(message: _161.ClientStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.ClientStateData;
+                    fromJSON(object: any): _161.ClientStateData;
+                    toJSON(message: _161.ClientStateData): import("../json-safe.js").JsonSafe<_161.ClientStateData>;
+                    fromPartial(object: Partial<_161.ClientStateData>): _161.ClientStateData;
+                    fromProtoMsg(message: _161.ClientStateDataProtoMsg): _161.ClientStateData;
+                    toProto(message: _161.ClientStateData): Uint8Array;
+                    toProtoMsg(message: _161.ClientStateData): _161.ClientStateDataProtoMsg;
+                };
+                ConsensusStateData: {
+                    typeUrl: string;
+                    encode(message: _161.ConsensusStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.ConsensusStateData;
+                    fromJSON(object: any): _161.ConsensusStateData;
+                    toJSON(message: _161.ConsensusStateData): import("../json-safe.js").JsonSafe<_161.ConsensusStateData>;
+                    fromPartial(object: Partial<_161.ConsensusStateData>): _161.ConsensusStateData;
+                    fromProtoMsg(message: _161.ConsensusStateDataProtoMsg): _161.ConsensusStateData;
+                    toProto(message: _161.ConsensusStateData): Uint8Array;
+                    toProtoMsg(message: _161.ConsensusStateData): _161.ConsensusStateDataProtoMsg;
+                };
+                ConnectionStateData: {
+                    typeUrl: string;
+                    encode(message: _161.ConnectionStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.ConnectionStateData;
+                    fromJSON(object: any): _161.ConnectionStateData;
+                    toJSON(message: _161.ConnectionStateData): import("../json-safe.js").JsonSafe<_161.ConnectionStateData>;
+                    fromPartial(object: Partial<_161.ConnectionStateData>): _161.ConnectionStateData;
+                    fromProtoMsg(message: _161.ConnectionStateDataProtoMsg): _161.ConnectionStateData;
+                    toProto(message: _161.ConnectionStateData): Uint8Array;
+                    toProtoMsg(message: _161.ConnectionStateData): _161.ConnectionStateDataProtoMsg;
+                };
+                ChannelStateData: {
+                    typeUrl: string;
+                    encode(message: _161.ChannelStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.ChannelStateData;
+                    fromJSON(object: any): _161.ChannelStateData;
+                    toJSON(message: _161.ChannelStateData): import("../json-safe.js").JsonSafe<_161.ChannelStateData>;
+                    fromPartial(object: Partial<_161.ChannelStateData>): _161.ChannelStateData;
+                    fromProtoMsg(message: _161.ChannelStateDataProtoMsg): _161.ChannelStateData;
+                    toProto(message: _161.ChannelStateData): Uint8Array;
+                    toProtoMsg(message: _161.ChannelStateData): _161.ChannelStateDataProtoMsg;
+                };
+                PacketCommitmentData: {
+                    typeUrl: string;
+                    encode(message: _161.PacketCommitmentData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.PacketCommitmentData;
+                    fromJSON(object: any): _161.PacketCommitmentData;
+                    toJSON(message: _161.PacketCommitmentData): import("../json-safe.js").JsonSafe<_161.PacketCommitmentData>;
+                    fromPartial(object: Partial<_161.PacketCommitmentData>): _161.PacketCommitmentData;
+                    fromProtoMsg(message: _161.PacketCommitmentDataProtoMsg): _161.PacketCommitmentData;
+                    toProto(message: _161.PacketCommitmentData): Uint8Array;
+                    toProtoMsg(message: _161.PacketCommitmentData): _161.PacketCommitmentDataProtoMsg;
+                };
+                PacketAcknowledgementData: {
+                    typeUrl: string;
+                    encode(message: _161.PacketAcknowledgementData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.PacketAcknowledgementData;
+                    fromJSON(object: any): _161.PacketAcknowledgementData;
+                    toJSON(message: _161.PacketAcknowledgementData): import("../json-safe.js").JsonSafe<_161.PacketAcknowledgementData>;
+                    fromPartial(object: Partial<_161.PacketAcknowledgementData>): _161.PacketAcknowledgementData;
+                    fromProtoMsg(message: _161.PacketAcknowledgementDataProtoMsg): _161.PacketAcknowledgementData;
+                    toProto(message: _161.PacketAcknowledgementData): Uint8Array;
+                    toProtoMsg(message: _161.PacketAcknowledgementData): _161.PacketAcknowledgementDataProtoMsg;
+                };
+                PacketReceiptAbsenceData: {
+                    typeUrl: string;
+                    encode(message: _161.PacketReceiptAbsenceData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.PacketReceiptAbsenceData;
+                    fromJSON(object: any): _161.PacketReceiptAbsenceData;
+                    toJSON(message: _161.PacketReceiptAbsenceData): import("../json-safe.js").JsonSafe<_161.PacketReceiptAbsenceData>;
+                    fromPartial(object: Partial<_161.PacketReceiptAbsenceData>): _161.PacketReceiptAbsenceData;
+                    fromProtoMsg(message: _161.PacketReceiptAbsenceDataProtoMsg): _161.PacketReceiptAbsenceData;
+                    toProto(message: _161.PacketReceiptAbsenceData): Uint8Array;
+                    toProtoMsg(message: _161.PacketReceiptAbsenceData): _161.PacketReceiptAbsenceDataProtoMsg;
+                };
+                NextSequenceRecvData: {
+                    typeUrl: string;
+                    encode(message: _161.NextSequenceRecvData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _161.NextSequenceRecvData;
+                    fromJSON(object: any): _161.NextSequenceRecvData;
+                    toJSON(message: _161.NextSequenceRecvData): import("../json-safe.js").JsonSafe<_161.NextSequenceRecvData>;
+                    fromPartial(object: Partial<_161.NextSequenceRecvData>): _161.NextSequenceRecvData;
+                    fromProtoMsg(message: _161.NextSequenceRecvDataProtoMsg): _161.NextSequenceRecvData;
+                    toProto(message: _161.NextSequenceRecvData): Uint8Array;
+                    toProtoMsg(message: _161.NextSequenceRecvData): _161.NextSequenceRecvDataProtoMsg;
+                };
+            };
+            const v2: {
+                dataTypeFromJSON(object: any): _162.DataType;
+                dataTypeToJSON(object: _162.DataType): string;
+                DataType: typeof _162.DataType;
+                DataTypeSDKType: typeof _162.DataType;
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _162.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.ClientState;
+                    fromJSON(object: any): _162.ClientState;
+                    toJSON(message: _162.ClientState): import("../json-safe.js").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: string;
+                    encode(message: _162.ConsensusState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.ConsensusState;
+                    fromJSON(object: any): _162.ConsensusState;
+                    toJSON(message: _162.ConsensusState): import("../json-safe.js").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;
+                };
+                Header: {
+                    typeUrl: string;
+                    encode(message: _162.Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.Header;
+                    fromJSON(object: any): _162.Header;
+                    toJSON(message: _162.Header): import("../json-safe.js").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;
+                };
+                Misbehaviour: {
+                    typeUrl: string;
+                    encode(message: _162.Misbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.Misbehaviour;
+                    fromJSON(object: any): _162.Misbehaviour;
+                    toJSON(message: _162.Misbehaviour): import("../json-safe.js").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;
+                };
+                SignatureAndData: {
+                    typeUrl: string;
+                    encode(message: _162.SignatureAndData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.SignatureAndData;
+                    fromJSON(object: any): _162.SignatureAndData;
+                    toJSON(message: _162.SignatureAndData): import("../json-safe.js").JsonSafe<_162.SignatureAndData>;
+                    fromPartial(object: Partial<_162.SignatureAndData>): _162.SignatureAndData;
+                    fromProtoMsg(message: _162.SignatureAndDataProtoMsg): _162.SignatureAndData;
+                    toProto(message: _162.SignatureAndData): Uint8Array;
+                    toProtoMsg(message: _162.SignatureAndData): _162.SignatureAndDataProtoMsg;
+                };
+                TimestampedSignatureData: {
+                    typeUrl: string;
+                    encode(message: _162.TimestampedSignatureData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.TimestampedSignatureData;
+                    fromJSON(object: any): _162.TimestampedSignatureData;
+                    toJSON(message: _162.TimestampedSignatureData): import("../json-safe.js").JsonSafe<_162.TimestampedSignatureData>;
+                    fromPartial(object: Partial<_162.TimestampedSignatureData>): _162.TimestampedSignatureData;
+                    fromProtoMsg(message: _162.TimestampedSignatureDataProtoMsg): _162.TimestampedSignatureData;
+                    toProto(message: _162.TimestampedSignatureData): Uint8Array;
+                    toProtoMsg(message: _162.TimestampedSignatureData): _162.TimestampedSignatureDataProtoMsg;
+                };
+                SignBytes: {
+                    typeUrl: string;
+                    encode(message: _162.SignBytes, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.SignBytes;
+                    fromJSON(object: any): _162.SignBytes;
+                    toJSON(message: _162.SignBytes): import("../json-safe.js").JsonSafe<_162.SignBytes>;
+                    fromPartial(object: Partial<_162.SignBytes>): _162.SignBytes;
+                    fromProtoMsg(message: _162.SignBytesProtoMsg): _162.SignBytes;
+                    toProto(message: _162.SignBytes): Uint8Array;
+                    toProtoMsg(message: _162.SignBytes): _162.SignBytesProtoMsg;
+                };
+                HeaderData: {
+                    typeUrl: string;
+                    encode(message: _162.HeaderData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.HeaderData;
+                    fromJSON(object: any): _162.HeaderData;
+                    toJSON(message: _162.HeaderData): import("../json-safe.js").JsonSafe<_162.HeaderData>;
+                    fromPartial(object: Partial<_162.HeaderData>): _162.HeaderData;
+                    fromProtoMsg(message: _162.HeaderDataProtoMsg): _162.HeaderData;
+                    toProto(message: _162.HeaderData): Uint8Array;
+                    toProtoMsg(message: _162.HeaderData): _162.HeaderDataProtoMsg;
+                };
+                ClientStateData: {
+                    typeUrl: string;
+                    encode(message: _162.ClientStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.ClientStateData;
+                    fromJSON(object: any): _162.ClientStateData;
+                    toJSON(message: _162.ClientStateData): import("../json-safe.js").JsonSafe<_162.ClientStateData>;
+                    fromPartial(object: Partial<_162.ClientStateData>): _162.ClientStateData;
+                    fromProtoMsg(message: _162.ClientStateDataProtoMsg): _162.ClientStateData;
+                    toProto(message: _162.ClientStateData): Uint8Array;
+                    toProtoMsg(message: _162.ClientStateData): _162.ClientStateDataProtoMsg;
+                };
+                ConsensusStateData: {
+                    typeUrl: string;
+                    encode(message: _162.ConsensusStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.ConsensusStateData;
+                    fromJSON(object: any): _162.ConsensusStateData;
+                    toJSON(message: _162.ConsensusStateData): import("../json-safe.js").JsonSafe<_162.ConsensusStateData>;
+                    fromPartial(object: Partial<_162.ConsensusStateData>): _162.ConsensusStateData;
+                    fromProtoMsg(message: _162.ConsensusStateDataProtoMsg): _162.ConsensusStateData;
+                    toProto(message: _162.ConsensusStateData): Uint8Array;
+                    toProtoMsg(message: _162.ConsensusStateData): _162.ConsensusStateDataProtoMsg;
+                };
+                ConnectionStateData: {
+                    typeUrl: string;
+                    encode(message: _162.ConnectionStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.ConnectionStateData;
+                    fromJSON(object: any): _162.ConnectionStateData;
+                    toJSON(message: _162.ConnectionStateData): import("../json-safe.js").JsonSafe<_162.ConnectionStateData>;
+                    fromPartial(object: Partial<_162.ConnectionStateData>): _162.ConnectionStateData;
+                    fromProtoMsg(message: _162.ConnectionStateDataProtoMsg): _162.ConnectionStateData;
+                    toProto(message: _162.ConnectionStateData): Uint8Array;
+                    toProtoMsg(message: _162.ConnectionStateData): _162.ConnectionStateDataProtoMsg;
+                };
+                ChannelStateData: {
+                    typeUrl: string;
+                    encode(message: _162.ChannelStateData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.ChannelStateData;
+                    fromJSON(object: any): _162.ChannelStateData;
+                    toJSON(message: _162.ChannelStateData): import("../json-safe.js").JsonSafe<_162.ChannelStateData>;
+                    fromPartial(object: Partial<_162.ChannelStateData>): _162.ChannelStateData;
+                    fromProtoMsg(message: _162.ChannelStateDataProtoMsg): _162.ChannelStateData;
+                    toProto(message: _162.ChannelStateData): Uint8Array;
+                    toProtoMsg(message: _162.ChannelStateData): _162.ChannelStateDataProtoMsg;
+                };
+                PacketCommitmentData: {
+                    typeUrl: string;
+                    encode(message: _162.PacketCommitmentData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.PacketCommitmentData;
+                    fromJSON(object: any): _162.PacketCommitmentData;
+                    toJSON(message: _162.PacketCommitmentData): import("../json-safe.js").JsonSafe<_162.PacketCommitmentData>;
+                    fromPartial(object: Partial<_162.PacketCommitmentData>): _162.PacketCommitmentData;
+                    fromProtoMsg(message: _162.PacketCommitmentDataProtoMsg): _162.PacketCommitmentData;
+                    toProto(message: _162.PacketCommitmentData): Uint8Array;
+                    toProtoMsg(message: _162.PacketCommitmentData): _162.PacketCommitmentDataProtoMsg;
+                };
+                PacketAcknowledgementData: {
+                    typeUrl: string;
+                    encode(message: _162.PacketAcknowledgementData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.PacketAcknowledgementData;
+                    fromJSON(object: any): _162.PacketAcknowledgementData;
+                    toJSON(message: _162.PacketAcknowledgementData): import("../json-safe.js").JsonSafe<_162.PacketAcknowledgementData>;
+                    fromPartial(object: Partial<_162.PacketAcknowledgementData>): _162.PacketAcknowledgementData;
+                    fromProtoMsg(message: _162.PacketAcknowledgementDataProtoMsg): _162.PacketAcknowledgementData;
+                    toProto(message: _162.PacketAcknowledgementData): Uint8Array;
+                    toProtoMsg(message: _162.PacketAcknowledgementData): _162.PacketAcknowledgementDataProtoMsg;
+                };
+                PacketReceiptAbsenceData: {
+                    typeUrl: string;
+                    encode(message: _162.PacketReceiptAbsenceData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.PacketReceiptAbsenceData;
+                    fromJSON(object: any): _162.PacketReceiptAbsenceData;
+                    toJSON(message: _162.PacketReceiptAbsenceData): import("../json-safe.js").JsonSafe<_162.PacketReceiptAbsenceData>;
+                    fromPartial(object: Partial<_162.PacketReceiptAbsenceData>): _162.PacketReceiptAbsenceData;
+                    fromProtoMsg(message: _162.PacketReceiptAbsenceDataProtoMsg): _162.PacketReceiptAbsenceData;
+                    toProto(message: _162.PacketReceiptAbsenceData): Uint8Array;
+                    toProtoMsg(message: _162.PacketReceiptAbsenceData): _162.PacketReceiptAbsenceDataProtoMsg;
+                };
+                NextSequenceRecvData: {
+                    typeUrl: string;
+                    encode(message: _162.NextSequenceRecvData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _162.NextSequenceRecvData;
+                    fromJSON(object: any): _162.NextSequenceRecvData;
+                    toJSON(message: _162.NextSequenceRecvData): import("../json-safe.js").JsonSafe<_162.NextSequenceRecvData>;
+                    fromPartial(object: Partial<_162.NextSequenceRecvData>): _162.NextSequenceRecvData;
+                    fromProtoMsg(message: _162.NextSequenceRecvDataProtoMsg): _162.NextSequenceRecvData;
+                    toProto(message: _162.NextSequenceRecvData): Uint8Array;
+                    toProtoMsg(message: _162.NextSequenceRecvData): _162.NextSequenceRecvDataProtoMsg;
+                };
+            };
+            const v3: {
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _163.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _163.ClientState;
+                    fromJSON(object: any): _163.ClientState;
+                    toJSON(message: _163.ClientState): import("../json-safe.js").JsonSafe<_163.ClientState>;
+                    fromPartial(object: Partial<_163.ClientState>): _163.ClientState;
+                    fromProtoMsg(message: _163.ClientStateProtoMsg): _163.ClientState;
+                    toProto(message: _163.ClientState): Uint8Array;
+                    toProtoMsg(message: _163.ClientState): _163.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: string;
+                    encode(message: _163.ConsensusState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _163.ConsensusState;
+                    fromJSON(object: any): _163.ConsensusState;
+                    toJSON(message: _163.ConsensusState): import("../json-safe.js").JsonSafe<_163.ConsensusState>;
+                    fromPartial(object: Partial<_163.ConsensusState>): _163.ConsensusState;
+                    fromProtoMsg(message: _163.ConsensusStateProtoMsg): _163.ConsensusState;
+                    toProto(message: _163.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _163.ConsensusState): _163.ConsensusStateProtoMsg;
+                };
+                Header: {
+                    typeUrl: string;
+                    encode(message: _163.Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _163.Header;
+                    fromJSON(object: any): _163.Header;
+                    toJSON(message: _163.Header): import("../json-safe.js").JsonSafe<_163.Header>;
+                    fromPartial(object: Partial<_163.Header>): _163.Header;
+                    fromProtoMsg(message: _163.HeaderProtoMsg): _163.Header;
+                    toProto(message: _163.Header): Uint8Array;
+                    toProtoMsg(message: _163.Header): _163.HeaderProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: string;
+                    encode(message: _163.Misbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _163.Misbehaviour;
+                    fromJSON(object: any): _163.Misbehaviour;
+                    toJSON(message: _163.Misbehaviour): import("../json-safe.js").JsonSafe<_163.Misbehaviour>;
+                    fromPartial(object: Partial<_163.Misbehaviour>): _163.Misbehaviour;
+                    fromProtoMsg(message: _163.MisbehaviourProtoMsg): _163.Misbehaviour;
+                    toProto(message: _163.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _163.Misbehaviour): _163.MisbehaviourProtoMsg;
+                };
+                SignatureAndData: {
+                    typeUrl: string;
+                    encode(message: _163.SignatureAndData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _163.SignatureAndData;
+                    fromJSON(object: any): _163.SignatureAndData;
+                    toJSON(message: _163.SignatureAndData): import("../json-safe.js").JsonSafe<_163.SignatureAndData>;
+                    fromPartial(object: Partial<_163.SignatureAndData>): _163.SignatureAndData;
+                    fromProtoMsg(message: _163.SignatureAndDataProtoMsg): _163.SignatureAndData;
+                    toProto(message: _163.SignatureAndData): Uint8Array;
+                    toProtoMsg(message: _163.SignatureAndData): _163.SignatureAndDataProtoMsg;
+                };
+                TimestampedSignatureData: {
+                    typeUrl: string;
+                    encode(message: _163.TimestampedSignatureData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _163.TimestampedSignatureData;
+                    fromJSON(object: any): _163.TimestampedSignatureData;
+                    toJSON(message: _163.TimestampedSignatureData): import("../json-safe.js").JsonSafe<_163.TimestampedSignatureData>;
+                    fromPartial(object: Partial<_163.TimestampedSignatureData>): _163.TimestampedSignatureData;
+                    fromProtoMsg(message: _163.TimestampedSignatureDataProtoMsg): _163.TimestampedSignatureData;
+                    toProto(message: _163.TimestampedSignatureData): Uint8Array;
+                    toProtoMsg(message: _163.TimestampedSignatureData): _163.TimestampedSignatureDataProtoMsg;
+                };
+                SignBytes: {
+                    typeUrl: string;
+                    encode(message: _163.SignBytes, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _163.SignBytes;
+                    fromJSON(object: any): _163.SignBytes;
+                    toJSON(message: _163.SignBytes): import("../json-safe.js").JsonSafe<_163.SignBytes>;
+                    fromPartial(object: Partial<_163.SignBytes>): _163.SignBytes;
+                    fromProtoMsg(message: _163.SignBytesProtoMsg): _163.SignBytes;
+                    toProto(message: _163.SignBytes): Uint8Array;
+                    toProtoMsg(message: _163.SignBytes): _163.SignBytesProtoMsg;
+                };
+                HeaderData: {
+                    typeUrl: string;
+                    encode(message: _163.HeaderData, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _163.HeaderData;
+                    fromJSON(object: any): _163.HeaderData;
+                    toJSON(message: _163.HeaderData): import("../json-safe.js").JsonSafe<_163.HeaderData>;
+                    fromPartial(object: Partial<_163.HeaderData>): _163.HeaderData;
+                    fromProtoMsg(message: _163.HeaderDataProtoMsg): _163.HeaderData;
+                    toProto(message: _163.HeaderData): Uint8Array;
+                    toProtoMsg(message: _163.HeaderData): _163.HeaderDataProtoMsg;
+                };
+            };
+        }
+        namespace tendermint {
+            const v1: {
+                ClientState: {
+                    typeUrl: string;
+                    encode(message: _164.ClientState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _164.ClientState;
+                    fromJSON(object: any): _164.ClientState;
+                    toJSON(message: _164.ClientState): import("../json-safe.js").JsonSafe<_164.ClientState>;
+                    fromPartial(object: Partial<_164.ClientState>): _164.ClientState;
+                    fromProtoMsg(message: _164.ClientStateProtoMsg): _164.ClientState;
+                    toProto(message: _164.ClientState): Uint8Array;
+                    toProtoMsg(message: _164.ClientState): _164.ClientStateProtoMsg;
+                };
+                ConsensusState: {
+                    typeUrl: string;
+                    encode(message: _164.ConsensusState, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _164.ConsensusState;
+                    fromJSON(object: any): _164.ConsensusState;
+                    toJSON(message: _164.ConsensusState): import("../json-safe.js").JsonSafe<_164.ConsensusState>;
+                    fromPartial(object: Partial<_164.ConsensusState>): _164.ConsensusState;
+                    fromProtoMsg(message: _164.ConsensusStateProtoMsg): _164.ConsensusState;
+                    toProto(message: _164.ConsensusState): Uint8Array;
+                    toProtoMsg(message: _164.ConsensusState): _164.ConsensusStateProtoMsg;
+                };
+                Misbehaviour: {
+                    typeUrl: string;
+                    encode(message: _164.Misbehaviour, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _164.Misbehaviour;
+                    fromJSON(object: any): _164.Misbehaviour;
+                    toJSON(message: _164.Misbehaviour): import("../json-safe.js").JsonSafe<_164.Misbehaviour>;
+                    fromPartial(object: Partial<_164.Misbehaviour>): _164.Misbehaviour;
+                    fromProtoMsg(message: _164.MisbehaviourProtoMsg): _164.Misbehaviour;
+                    toProto(message: _164.Misbehaviour): Uint8Array;
+                    toProtoMsg(message: _164.Misbehaviour): _164.MisbehaviourProtoMsg;
+                };
+                Header: {
+                    typeUrl: string;
+                    encode(message: _164.Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _164.Header;
+                    fromJSON(object: any): _164.Header;
+                    toJSON(message: _164.Header): import("../json-safe.js").JsonSafe<_164.Header>;
+                    fromPartial(object: Partial<_164.Header>): _164.Header;
+                    fromProtoMsg(message: _164.HeaderProtoMsg): _164.Header;
+                    toProto(message: _164.Header): Uint8Array;
+                    toProtoMsg(message: _164.Header): _164.HeaderProtoMsg;
+                };
+                Fraction: {
+                    typeUrl: string;
+                    encode(message: _164.Fraction, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                    decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _164.Fraction;
+                    fromJSON(object: any): _164.Fraction;
+                    toJSON(message: _164.Fraction): import("../json-safe.js").JsonSafe<_164.Fraction>;
+                    fromPartial(object: Partial<_164.Fraction>): _164.Fraction;
+                    fromProtoMsg(message: _164.FractionProtoMsg): _164.Fraction;
+                    toProto(message: _164.Fraction): Uint8Array;
+                    toProtoMsg(message: _164.Fraction): _164.FractionProtoMsg;
+                };
+            };
+        }
+    }
+    const ClientFactory: {
+        createRPCMsgClient: ({ rpc }: {
+            rpc: import("../helpers.js").Rpc;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                consensus: {
+                    v1: import("../cosmos/consensus/v1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/tx.rpc.msg.js").MsgClientImpl;
+                    v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+                vesting: {
+                    v1beta1: import("../cosmos/vesting/v1beta1/tx.rpc.msg.js").MsgClientImpl;
+                };
+            };
+            ibc: {
+                applications: {
+                    interchain_accounts: {
+                        controller: {
+                            v1: _255.MsgClientImpl;
+                        };
+                        host: {
+                            v1: _256.MsgClientImpl;
+                        };
+                    };
+                    transfer: {
+                        v1: _257.MsgClientImpl;
+                    };
+                };
+                core: {
+                    channel: {
+                        v1: _258.MsgClientImpl;
+                    };
+                    client: {
+                        v1: _259.MsgClientImpl;
+                    };
+                    connection: {
+                        v1: _260.MsgClientImpl;
+                    };
+                };
+            };
+        }>;
+        createRPCQueryClient: ({ rpcEndpoint, }: {
+            rpcEndpoint: string | import("@cosmjs/tendermint-rpc").HttpEndpoint;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: {
+                        accounts(request?: import("../cosmos/auth/v1beta1/query.js").QueryAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query.js").QueryAccountsResponse>;
+                        account(request: import("../cosmos/auth/v1beta1/query.js").QueryAccountRequest): Promise<import("../cosmos/auth/v1beta1/query.js").QueryAccountResponse>;
+                        accountAddressByID(request: import("../cosmos/auth/v1beta1/query.js").QueryAccountAddressByIDRequest): Promise<import("../cosmos/auth/v1beta1/query.js").QueryAccountAddressByIDResponse>;
+                        params(request?: import("../cosmos/auth/v1beta1/query.js").QueryParamsRequest): Promise<import("../cosmos/auth/v1beta1/query.js").QueryParamsResponse>;
+                        moduleAccounts(request?: import("../cosmos/auth/v1beta1/query.js").QueryModuleAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query.js").QueryModuleAccountsResponse>;
+                        moduleAccountByName(request: import("../cosmos/auth/v1beta1/query.js").QueryModuleAccountByNameRequest): Promise<import("../cosmos/auth/v1beta1/query.js").QueryModuleAccountByNameResponse>;
+                        bech32Prefix(request?: import("../cosmos/auth/v1beta1/query.js").Bech32PrefixRequest): Promise<import("../cosmos/auth/v1beta1/query.js").Bech32PrefixResponse>;
+                        addressBytesToString(request: import("../cosmos/auth/v1beta1/query.js").AddressBytesToStringRequest): Promise<import("../cosmos/auth/v1beta1/query.js").AddressBytesToStringResponse>;
+                        addressStringToBytes(request: import("../cosmos/auth/v1beta1/query.js").AddressStringToBytesRequest): Promise<import("../cosmos/auth/v1beta1/query.js").AddressStringToBytesResponse>;
+                        accountInfo(request: import("../cosmos/auth/v1beta1/query.js").QueryAccountInfoRequest): Promise<import("../cosmos/auth/v1beta1/query.js").QueryAccountInfoResponse>;
+                    };
+                };
+                authz: {
+                    v1beta1: {
+                        grants(request: import("../cosmos/authz/v1beta1/query.js").QueryGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query.js").QueryGrantsResponse>;
+                        granterGrants(request: import("../cosmos/authz/v1beta1/query.js").QueryGranterGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query.js").QueryGranterGrantsResponse>;
+                        granteeGrants(request: import("../cosmos/authz/v1beta1/query.js").QueryGranteeGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query.js").QueryGranteeGrantsResponse>;
+                    };
+                };
+                bank: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/bank/v1beta1/query.js").QueryBalanceRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QueryBalanceResponse>;
+                        allBalances(request: import("../cosmos/bank/v1beta1/query.js").QueryAllBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QueryAllBalancesResponse>;
+                        spendableBalances(request: import("../cosmos/bank/v1beta1/query.js").QuerySpendableBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QuerySpendableBalancesResponse>;
+                        spendableBalanceByDenom(request: import("../cosmos/bank/v1beta1/query.js").QuerySpendableBalanceByDenomRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QuerySpendableBalanceByDenomResponse>;
+                        totalSupply(request?: import("../cosmos/bank/v1beta1/query.js").QueryTotalSupplyRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QueryTotalSupplyResponse>;
+                        supplyOf(request: import("../cosmos/bank/v1beta1/query.js").QuerySupplyOfRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QuerySupplyOfResponse>;
+                        params(request?: import("../cosmos/bank/v1beta1/query.js").QueryParamsRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QueryParamsResponse>;
+                        denomMetadata(request: import("../cosmos/bank/v1beta1/query.js").QueryDenomMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QueryDenomMetadataResponse>;
+                        denomsMetadata(request?: import("../cosmos/bank/v1beta1/query.js").QueryDenomsMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QueryDenomsMetadataResponse>;
+                        denomOwners(request: import("../cosmos/bank/v1beta1/query.js").QueryDenomOwnersRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QueryDenomOwnersResponse>;
+                        sendEnabled(request: import("../cosmos/bank/v1beta1/query.js").QuerySendEnabledRequest): Promise<import("../cosmos/bank/v1beta1/query.js").QuerySendEnabledResponse>;
+                    };
+                };
+                base: {
+                    node: {
+                        v1beta1: {
+                            config(request?: import("../cosmos/base/node/v1beta1/query.js").ConfigRequest): Promise<import("../cosmos/base/node/v1beta1/query.js").ConfigResponse>;
+                        };
+                    };
+                };
+                consensus: {
+                    v1: {
+                        params(request?: import("../cosmos/consensus/v1/query.js").QueryParamsRequest): Promise<import("../cosmos/consensus/v1/query.js").QueryParamsResponse>;
+                    };
+                };
+                distribution: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/distribution/v1beta1/query.js").QueryParamsRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryParamsResponse>;
+                        validatorDistributionInfo(request: import("../cosmos/distribution/v1beta1/query.js").QueryValidatorDistributionInfoRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryValidatorDistributionInfoResponse>;
+                        validatorOutstandingRewards(request: import("../cosmos/distribution/v1beta1/query.js").QueryValidatorOutstandingRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryValidatorOutstandingRewardsResponse>;
+                        validatorCommission(request: import("../cosmos/distribution/v1beta1/query.js").QueryValidatorCommissionRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryValidatorCommissionResponse>;
+                        validatorSlashes(request: import("../cosmos/distribution/v1beta1/query.js").QueryValidatorSlashesRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryValidatorSlashesResponse>;
+                        delegationRewards(request: import("../cosmos/distribution/v1beta1/query.js").QueryDelegationRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryDelegationRewardsResponse>;
+                        delegationTotalRewards(request: import("../cosmos/distribution/v1beta1/query.js").QueryDelegationTotalRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryDelegationTotalRewardsResponse>;
+                        delegatorValidators(request: import("../cosmos/distribution/v1beta1/query.js").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryDelegatorValidatorsResponse>;
+                        delegatorWithdrawAddress(request: import("../cosmos/distribution/v1beta1/query.js").QueryDelegatorWithdrawAddressRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryDelegatorWithdrawAddressResponse>;
+                        communityPool(request?: import("../cosmos/distribution/v1beta1/query.js").QueryCommunityPoolRequest): Promise<import("../cosmos/distribution/v1beta1/query.js").QueryCommunityPoolResponse>;
+                    };
+                };
+                feegrant: {
+                    v1beta1: {
+                        allowance(request: import("../cosmos/feegrant/v1beta1/query.js").QueryAllowanceRequest): Promise<import("../cosmos/feegrant/v1beta1/query.js").QueryAllowanceResponse>;
+                        allowances(request: import("../cosmos/feegrant/v1beta1/query.js").QueryAllowancesRequest): Promise<import("../cosmos/feegrant/v1beta1/query.js").QueryAllowancesResponse>;
+                        allowancesByGranter(request: import("../cosmos/feegrant/v1beta1/query.js").QueryAllowancesByGranterRequest): Promise<import("../cosmos/feegrant/v1beta1/query.js").QueryAllowancesByGranterResponse>;
+                    };
+                };
+                gov: {
+                    v1: {
+                        proposal(request: import("../cosmos/gov/v1/query.js").QueryProposalRequest): Promise<import("../cosmos/gov/v1/query.js").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1/query.js").QueryProposalsRequest): Promise<import("../cosmos/gov/v1/query.js").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1/query.js").QueryVoteRequest): Promise<import("../cosmos/gov/v1/query.js").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1/query.js").QueryVotesRequest): Promise<import("../cosmos/gov/v1/query.js").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1/query.js").QueryParamsRequest): Promise<import("../cosmos/gov/v1/query.js").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1/query.js").QueryDepositRequest): Promise<import("../cosmos/gov/v1/query.js").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1/query.js").QueryDepositsRequest): Promise<import("../cosmos/gov/v1/query.js").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1/query.js").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1/query.js").QueryTallyResultResponse>;
+                    };
+                    v1beta1: {
+                        proposal(request: import("../cosmos/gov/v1beta1/query.js").QueryProposalRequest): Promise<import("../cosmos/gov/v1beta1/query.js").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1beta1/query.js").QueryProposalsRequest): Promise<import("../cosmos/gov/v1beta1/query.js").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1beta1/query.js").QueryVoteRequest): Promise<import("../cosmos/gov/v1beta1/query.js").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1beta1/query.js").QueryVotesRequest): Promise<import("../cosmos/gov/v1beta1/query.js").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1beta1/query.js").QueryParamsRequest): Promise<import("../cosmos/gov/v1beta1/query.js").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1beta1/query.js").QueryDepositRequest): Promise<import("../cosmos/gov/v1beta1/query.js").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1beta1/query.js").QueryDepositsRequest): Promise<import("../cosmos/gov/v1beta1/query.js").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1beta1/query.js").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1beta1/query.js").QueryTallyResultResponse>;
+                    };
+                };
+                group: {
+                    v1: {
+                        groupInfo(request: import("../cosmos/group/v1/query.js").QueryGroupInfoRequest): Promise<import("../cosmos/group/v1/query.js").QueryGroupInfoResponse>;
+                        groupPolicyInfo(request: import("../cosmos/group/v1/query.js").QueryGroupPolicyInfoRequest): Promise<import("../cosmos/group/v1/query.js").QueryGroupPolicyInfoResponse>;
+                        groupMembers(request: import("../cosmos/group/v1/query.js").QueryGroupMembersRequest): Promise<import("../cosmos/group/v1/query.js").QueryGroupMembersResponse>;
+                        groupsByAdmin(request: import("../cosmos/group/v1/query.js").QueryGroupsByAdminRequest): Promise<import("../cosmos/group/v1/query.js").QueryGroupsByAdminResponse>;
+                        groupPoliciesByGroup(request: import("../cosmos/group/v1/query.js").QueryGroupPoliciesByGroupRequest): Promise<import("../cosmos/group/v1/query.js").QueryGroupPoliciesByGroupResponse>;
+                        groupPoliciesByAdmin(request: import("../cosmos/group/v1/query.js").QueryGroupPoliciesByAdminRequest): Promise<import("../cosmos/group/v1/query.js").QueryGroupPoliciesByAdminResponse>;
+                        proposal(request: import("../cosmos/group/v1/query.js").QueryProposalRequest): Promise<import("../cosmos/group/v1/query.js").QueryProposalResponse>;
+                        proposalsByGroupPolicy(request: import("../cosmos/group/v1/query.js").QueryProposalsByGroupPolicyRequest): Promise<import("../cosmos/group/v1/query.js").QueryProposalsByGroupPolicyResponse>;
+                        voteByProposalVoter(request: import("../cosmos/group/v1/query.js").QueryVoteByProposalVoterRequest): Promise<import("../cosmos/group/v1/query.js").QueryVoteByProposalVoterResponse>;
+                        votesByProposal(request: import("../cosmos/group/v1/query.js").QueryVotesByProposalRequest): Promise<import("../cosmos/group/v1/query.js").QueryVotesByProposalResponse>;
+                        votesByVoter(request: import("../cosmos/group/v1/query.js").QueryVotesByVoterRequest): Promise<import("../cosmos/group/v1/query.js").QueryVotesByVoterResponse>;
+                        groupsByMember(request: import("../cosmos/group/v1/query.js").QueryGroupsByMemberRequest): Promise<import("../cosmos/group/v1/query.js").QueryGroupsByMemberResponse>;
+                        tallyResult(request: import("../cosmos/group/v1/query.js").QueryTallyResultRequest): Promise<import("../cosmos/group/v1/query.js").QueryTallyResultResponse>;
+                        groups(request?: import("../cosmos/group/v1/query.js").QueryGroupsRequest): Promise<import("../cosmos/group/v1/query.js").QueryGroupsResponse>;
+                    };
+                };
+                mint: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/mint/v1beta1/query.js").QueryParamsRequest): Promise<import("../cosmos/mint/v1beta1/query.js").QueryParamsResponse>;
+                        inflation(request?: import("../cosmos/mint/v1beta1/query.js").QueryInflationRequest): Promise<import("../cosmos/mint/v1beta1/query.js").QueryInflationResponse>;
+                        annualProvisions(request?: import("../cosmos/mint/v1beta1/query.js").QueryAnnualProvisionsRequest): Promise<import("../cosmos/mint/v1beta1/query.js").QueryAnnualProvisionsResponse>;
+                    };
+                };
+                params: {
+                    v1beta1: {
+                        params(request: import("../cosmos/params/v1beta1/query.js").QueryParamsRequest): Promise<import("../cosmos/params/v1beta1/query.js").QueryParamsResponse>;
+                        subspaces(request?: import("../cosmos/params/v1beta1/query.js").QuerySubspacesRequest): Promise<import("../cosmos/params/v1beta1/query.js").QuerySubspacesResponse>;
+                    };
+                };
+                staking: {
+                    v1beta1: {
+                        validators(request: import("../cosmos/staking/v1beta1/query.js").QueryValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryValidatorsResponse>;
+                        validator(request: import("../cosmos/staking/v1beta1/query.js").QueryValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryValidatorResponse>;
+                        validatorDelegations(request: import("../cosmos/staking/v1beta1/query.js").QueryValidatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryValidatorDelegationsResponse>;
+                        validatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query.js").QueryValidatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryValidatorUnbondingDelegationsResponse>;
+                        delegation(request: import("../cosmos/staking/v1beta1/query.js").QueryDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryDelegationResponse>;
+                        unbondingDelegation(request: import("../cosmos/staking/v1beta1/query.js").QueryUnbondingDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryUnbondingDelegationResponse>;
+                        delegatorDelegations(request: import("../cosmos/staking/v1beta1/query.js").QueryDelegatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryDelegatorDelegationsResponse>;
+                        delegatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query.js").QueryDelegatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryDelegatorUnbondingDelegationsResponse>;
+                        redelegations(request: import("../cosmos/staking/v1beta1/query.js").QueryRedelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryRedelegationsResponse>;
+                        delegatorValidators(request: import("../cosmos/staking/v1beta1/query.js").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryDelegatorValidatorsResponse>;
+                        delegatorValidator(request: import("../cosmos/staking/v1beta1/query.js").QueryDelegatorValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryDelegatorValidatorResponse>;
+                        historicalInfo(request: import("../cosmos/staking/v1beta1/query.js").QueryHistoricalInfoRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryHistoricalInfoResponse>;
+                        pool(request?: import("../cosmos/staking/v1beta1/query.js").QueryPoolRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryPoolResponse>;
+                        params(request?: import("../cosmos/staking/v1beta1/query.js").QueryParamsRequest): Promise<import("../cosmos/staking/v1beta1/query.js").QueryParamsResponse>;
+                    };
+                };
+                tx: {
+                    v1beta1: {
+                        simulate(request: import("../cosmos/tx/v1beta1/service.js").SimulateRequest): Promise<import("../cosmos/tx/v1beta1/service.js").SimulateResponse>;
+                        getTx(request: import("../cosmos/tx/v1beta1/service.js").GetTxRequest): Promise<import("../cosmos/tx/v1beta1/service.js").GetTxResponse>;
+                        broadcastTx(request: import("../cosmos/tx/v1beta1/service.js").BroadcastTxRequest): Promise<import("../cosmos/tx/v1beta1/service.js").BroadcastTxResponse>;
+                        getTxsEvent(request: import("../cosmos/tx/v1beta1/service.js").GetTxsEventRequest): Promise<import("../cosmos/tx/v1beta1/service.js").GetTxsEventResponse>;
+                        getBlockWithTxs(request: import("../cosmos/tx/v1beta1/service.js").GetBlockWithTxsRequest): Promise<import("../cosmos/tx/v1beta1/service.js").GetBlockWithTxsResponse>;
+                        txDecode(request: import("../cosmos/tx/v1beta1/service.js").TxDecodeRequest): Promise<import("../cosmos/tx/v1beta1/service.js").TxDecodeResponse>;
+                        txEncode(request: import("../cosmos/tx/v1beta1/service.js").TxEncodeRequest): Promise<import("../cosmos/tx/v1beta1/service.js").TxEncodeResponse>;
+                        txEncodeAmino(request: import("../cosmos/tx/v1beta1/service.js").TxEncodeAminoRequest): Promise<import("../cosmos/tx/v1beta1/service.js").TxEncodeAminoResponse>;
+                        txDecodeAmino(request: import("../cosmos/tx/v1beta1/service.js").TxDecodeAminoRequest): Promise<import("../cosmos/tx/v1beta1/service.js").TxDecodeAminoResponse>;
+                    };
+                };
+                upgrade: {
+                    v1beta1: {
+                        currentPlan(request?: import("../cosmos/upgrade/v1beta1/query.js").QueryCurrentPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query.js").QueryCurrentPlanResponse>;
+                        appliedPlan(request: import("../cosmos/upgrade/v1beta1/query.js").QueryAppliedPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query.js").QueryAppliedPlanResponse>;
+                        upgradedConsensusState(request: import("../cosmos/upgrade/v1beta1/query.js").QueryUpgradedConsensusStateRequest): Promise<import("../cosmos/upgrade/v1beta1/query.js").QueryUpgradedConsensusStateResponse>;
+                        moduleVersions(request: import("../cosmos/upgrade/v1beta1/query.js").QueryModuleVersionsRequest): Promise<import("../cosmos/upgrade/v1beta1/query.js").QueryModuleVersionsResponse>;
+                        authority(request?: import("../cosmos/upgrade/v1beta1/query.js").QueryAuthorityRequest): Promise<import("../cosmos/upgrade/v1beta1/query.js").QueryAuthorityResponse>;
+                    };
+                };
+            };
+            ibc: {
+                applications: {
+                    interchain_accounts: {
+                        controller: {
+                            v1: {
+                                interchainAccount(request: _131.QueryInterchainAccountRequest): Promise<_131.QueryInterchainAccountResponse>;
+                                params(request?: _131.QueryParamsRequest): Promise<_131.QueryParamsResponse>;
+                            };
+                        };
+                        host: {
+                            v1: {
+                                params(request?: _135.QueryParamsRequest): Promise<_135.QueryParamsResponse>;
+                            };
+                        };
+                    };
+                    transfer: {
+                        v1: {
+                            denomTraces(request?: _142.QueryDenomTracesRequest): Promise<_142.QueryDenomTracesResponse>;
+                            denomTrace(request: _142.QueryDenomTraceRequest): Promise<_142.QueryDenomTraceResponse>;
+                            params(request?: _142.QueryParamsRequest): Promise<_142.QueryParamsResponse>;
+                            denomHash(request: _142.QueryDenomHashRequest): Promise<_142.QueryDenomHashResponse>;
+                            escrowAddress(request: _142.QueryEscrowAddressRequest): Promise<_142.QueryEscrowAddressResponse>;
+                            totalEscrowForDenom(request: _142.QueryTotalEscrowForDenomRequest): Promise<_142.QueryTotalEscrowForDenomResponse>;
+                        };
+                    };
+                };
+                core: {
+                    channel: {
+                        v1: {
+                            channel(request: _148.QueryChannelRequest): Promise<_148.QueryChannelResponse>;
+                            channels(request?: _148.QueryChannelsRequest): Promise<_148.QueryChannelsResponse>;
+                            connectionChannels(request: _148.QueryConnectionChannelsRequest): Promise<_148.QueryConnectionChannelsResponse>;
+                            channelClientState(request: _148.QueryChannelClientStateRequest): Promise<_148.QueryChannelClientStateResponse>;
+                            channelConsensusState(request: _148.QueryChannelConsensusStateRequest): Promise<_148.QueryChannelConsensusStateResponse>;
+                            packetCommitment(request: _148.QueryPacketCommitmentRequest): Promise<_148.QueryPacketCommitmentResponse>;
+                            packetCommitments(request: _148.QueryPacketCommitmentsRequest): Promise<_148.QueryPacketCommitmentsResponse>;
+                            packetReceipt(request: _148.QueryPacketReceiptRequest): Promise<_148.QueryPacketReceiptResponse>;
+                            packetAcknowledgement(request: _148.QueryPacketAcknowledgementRequest): Promise<_148.QueryPacketAcknowledgementResponse>;
+                            packetAcknowledgements(request: _148.QueryPacketAcknowledgementsRequest): Promise<_148.QueryPacketAcknowledgementsResponse>;
+                            unreceivedPackets(request: _148.QueryUnreceivedPacketsRequest): Promise<_148.QueryUnreceivedPacketsResponse>;
+                            unreceivedAcks(request: _148.QueryUnreceivedAcksRequest): Promise<_148.QueryUnreceivedAcksResponse>;
+                            nextSequenceReceive(request: _148.QueryNextSequenceReceiveRequest): Promise<_148.QueryNextSequenceReceiveResponse>;
+                        };
+                    };
+                    client: {
+                        v1: {
+                            clientState(request: _152.QueryClientStateRequest): Promise<_152.QueryClientStateResponse>;
+                            clientStates(request?: _152.QueryClientStatesRequest): Promise<_152.QueryClientStatesResponse>;
+                            consensusState(request: _152.QueryConsensusStateRequest): Promise<_152.QueryConsensusStateResponse>;
+                            consensusStates(request: _152.QueryConsensusStatesRequest): Promise<_152.QueryConsensusStatesResponse>;
+                            consensusStateHeights(request: _152.QueryConsensusStateHeightsRequest): Promise<_152.QueryConsensusStateHeightsResponse>;
+                            clientStatus(request: _152.QueryClientStatusRequest): Promise<_152.QueryClientStatusResponse>;
+                            clientParams(request?: _152.QueryClientParamsRequest): Promise<_152.QueryClientParamsResponse>;
+                            upgradedClientState(request?: _152.QueryUpgradedClientStateRequest): Promise<_152.QueryUpgradedClientStateResponse>;
+                            upgradedConsensusState(request?: _152.QueryUpgradedConsensusStateRequest): Promise<_152.QueryUpgradedConsensusStateResponse>;
+                        };
+                    };
+                    connection: {
+                        v1: {
+                            connection(request: _157.QueryConnectionRequest): Promise<_157.QueryConnectionResponse>;
+                            connections(request?: _157.QueryConnectionsRequest): Promise<_157.QueryConnectionsResponse>;
+                            clientConnections(request: _157.QueryClientConnectionsRequest): Promise<_157.QueryClientConnectionsResponse>;
+                            connectionClientState(request: _157.QueryConnectionClientStateRequest): Promise<_157.QueryConnectionClientStateResponse>;
+                            connectionConsensusState(request: _157.QueryConnectionConsensusStateRequest): Promise<_157.QueryConnectionConsensusStateResponse>;
+                            connectionParams(request?: _157.QueryConnectionParamsRequest): Promise<_157.QueryConnectionParamsResponse>;
+                        };
+                    };
+                };
+            };
+        }>;
+    };
+}