@agoric/cosmic-proto 0.5.0-u20.0 → 0.5.0-u21.0

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

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