import * as _137 from './applications/interchain_accounts/controller/v1/controller.js';
import * as _138 from './applications/interchain_accounts/controller/v1/query.js';
import * as _139 from './applications/interchain_accounts/controller/v1/tx.js';
import * as _140 from './applications/interchain_accounts/genesis/v1/genesis.js';
import * as _141 from './applications/interchain_accounts/host/v1/host.js';
import * as _142 from './applications/interchain_accounts/host/v1/query.js';
import * as _143 from './applications/interchain_accounts/host/v1/tx.js';
import * as _144 from './applications/interchain_accounts/v1/account.js';
import * as _145 from './applications/interchain_accounts/v1/metadata.js';
import * as _146 from './applications/interchain_accounts/v1/packet.js';
import * as _147 from './applications/transfer/v1/authz.js';
import * as _148 from './applications/transfer/v1/genesis.js';
import * as _149 from './applications/transfer/v1/query.js';
import * as _150 from './applications/transfer/v1/transfer.js';
import * as _151 from './applications/transfer/v1/tx.js';
import * as _152 from './applications/transfer/v2/packet.js';
import * as _153 from './core/channel/v1/channel.js';
import * as _154 from './core/channel/v1/genesis.js';
import * as _155 from './core/channel/v1/query.js';
import * as _156 from './core/channel/v1/tx.js';
import * as _157 from './core/channel/v1/upgrade.js';
import * as _158 from './core/client/v1/client.js';
import * as _159 from './core/client/v1/genesis.js';
import * as _160 from './core/client/v1/query.js';
import * as _161 from './core/client/v1/tx.js';
import * as _162 from './core/commitment/v1/commitment.js';
import * as _163 from './core/connection/v1/connection.js';
import * as _164 from './core/connection/v1/genesis.js';
import * as _165 from './core/connection/v1/query.js';
import * as _166 from './core/connection/v1/tx.js';
import * as _167 from './lightclients/localhost/v1/localhost.js';
import * as _168 from './lightclients/localhost/v2/localhost.js';
import * as _169 from './lightclients/solomachine/v1/solomachine.js';
import * as _170 from './lightclients/solomachine/v2/solomachine.js';
import * as _171 from './lightclients/solomachine/v3/solomachine.js';
import * as _172 from './lightclients/tendermint/v1/tendermint.js';
import * as _173 from './lightclients/wasm/v1/genesis.js';
import * as _174 from './lightclients/wasm/v1/query.js';
import * as _175 from './lightclients/wasm/v1/tx.js';
import * as _176 from './lightclients/wasm/v1/wasm.js';
export declare namespace ibc {
    namespace applications {
        namespace interchain_accounts {
            namespace controller {
                const v1: {
                    MsgRegisterInterchainAccount: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount";
                        encode(message: _139.MsgRegisterInterchainAccount, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _139.MsgRegisterInterchainAccount;
                        fromJSON(object: any): _139.MsgRegisterInterchainAccount;
                        toJSON(message: _139.MsgRegisterInterchainAccount): import("../json-safe.ts").JsonSafe<_139.MsgRegisterInterchainAccount>;
                        fromPartial(object: Partial<_139.MsgRegisterInterchainAccount>): _139.MsgRegisterInterchainAccount;
                        fromProtoMsg(message: _139.MsgRegisterInterchainAccountProtoMsg): _139.MsgRegisterInterchainAccount;
                        toProto(message: _139.MsgRegisterInterchainAccount): Uint8Array;
                        toProtoMsg(message: _139.MsgRegisterInterchainAccount): _139.MsgRegisterInterchainAccountProtoMsg;
                    };
                    MsgRegisterInterchainAccountResponse: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse";
                        encode(message: _139.MsgRegisterInterchainAccountResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _139.MsgRegisterInterchainAccountResponse;
                        fromJSON(object: any): _139.MsgRegisterInterchainAccountResponse;
                        toJSON(message: _139.MsgRegisterInterchainAccountResponse): import("../json-safe.ts").JsonSafe<_139.MsgRegisterInterchainAccountResponse>;
                        fromPartial(object: Partial<_139.MsgRegisterInterchainAccountResponse>): _139.MsgRegisterInterchainAccountResponse;
                        fromProtoMsg(message: _139.MsgRegisterInterchainAccountResponseProtoMsg): _139.MsgRegisterInterchainAccountResponse;
                        toProto(message: _139.MsgRegisterInterchainAccountResponse): Uint8Array;
                        toProtoMsg(message: _139.MsgRegisterInterchainAccountResponse): _139.MsgRegisterInterchainAccountResponseProtoMsg;
                    };
                    MsgSendTx: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgSendTx";
                        encode(message: _139.MsgSendTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _139.MsgSendTx;
                        fromJSON(object: any): _139.MsgSendTx;
                        toJSON(message: _139.MsgSendTx): import("../json-safe.ts").JsonSafe<_139.MsgSendTx>;
                        fromPartial(object: Partial<_139.MsgSendTx>): _139.MsgSendTx;
                        fromProtoMsg(message: _139.MsgSendTxProtoMsg): _139.MsgSendTx;
                        toProto(message: _139.MsgSendTx): Uint8Array;
                        toProtoMsg(message: _139.MsgSendTx): _139.MsgSendTxProtoMsg;
                    };
                    MsgSendTxResponse: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse";
                        encode(message: _139.MsgSendTxResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _139.MsgSendTxResponse;
                        fromJSON(object: any): _139.MsgSendTxResponse;
                        toJSON(message: _139.MsgSendTxResponse): import("../json-safe.ts").JsonSafe<_139.MsgSendTxResponse>;
                        fromPartial(object: Partial<_139.MsgSendTxResponse>): _139.MsgSendTxResponse;
                        fromProtoMsg(message: _139.MsgSendTxResponseProtoMsg): _139.MsgSendTxResponse;
                        toProto(message: _139.MsgSendTxResponse): Uint8Array;
                        toProtoMsg(message: _139.MsgSendTxResponse): _139.MsgSendTxResponseProtoMsg;
                    };
                    MsgUpdateParams: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams";
                        encode(message: _139.MsgUpdateParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _139.MsgUpdateParams;
                        fromJSON(object: any): _139.MsgUpdateParams;
                        toJSON(message: _139.MsgUpdateParams): import("../json-safe.ts").JsonSafe<_139.MsgUpdateParams>;
                        fromPartial(object: Partial<_139.MsgUpdateParams>): _139.MsgUpdateParams;
                        fromProtoMsg(message: _139.MsgUpdateParamsProtoMsg): _139.MsgUpdateParams;
                        toProto(message: _139.MsgUpdateParams): Uint8Array;
                        toProtoMsg(message: _139.MsgUpdateParams): _139.MsgUpdateParamsProtoMsg;
                    };
                    MsgUpdateParamsResponse: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse";
                        encode(_: _139.MsgUpdateParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _139.MsgUpdateParamsResponse;
                        fromJSON(_: any): _139.MsgUpdateParamsResponse;
                        toJSON(_: _139.MsgUpdateParamsResponse): import("../json-safe.ts").JsonSafe<_139.MsgUpdateParamsResponse>;
                        fromPartial(_: Partial<_139.MsgUpdateParamsResponse>): _139.MsgUpdateParamsResponse;
                        fromProtoMsg(message: _139.MsgUpdateParamsResponseProtoMsg): _139.MsgUpdateParamsResponse;
                        toProto(message: _139.MsgUpdateParamsResponse): Uint8Array;
                        toProtoMsg(message: _139.MsgUpdateParamsResponse): _139.MsgUpdateParamsResponseProtoMsg;
                    };
                    QueryInterchainAccountRequest: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest";
                        encode(message: _138.QueryInterchainAccountRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _138.QueryInterchainAccountRequest;
                        fromJSON(object: any): _138.QueryInterchainAccountRequest;
                        toJSON(message: _138.QueryInterchainAccountRequest): import("../json-safe.ts").JsonSafe<_138.QueryInterchainAccountRequest>;
                        fromPartial(object: Partial<_138.QueryInterchainAccountRequest>): _138.QueryInterchainAccountRequest;
                        fromProtoMsg(message: _138.QueryInterchainAccountRequestProtoMsg): _138.QueryInterchainAccountRequest;
                        toProto(message: _138.QueryInterchainAccountRequest): Uint8Array;
                        toProtoMsg(message: _138.QueryInterchainAccountRequest): _138.QueryInterchainAccountRequestProtoMsg;
                    };
                    QueryInterchainAccountResponse: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse";
                        encode(message: _138.QueryInterchainAccountResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _138.QueryInterchainAccountResponse;
                        fromJSON(object: any): _138.QueryInterchainAccountResponse;
                        toJSON(message: _138.QueryInterchainAccountResponse): import("../json-safe.ts").JsonSafe<_138.QueryInterchainAccountResponse>;
                        fromPartial(object: Partial<_138.QueryInterchainAccountResponse>): _138.QueryInterchainAccountResponse;
                        fromProtoMsg(message: _138.QueryInterchainAccountResponseProtoMsg): _138.QueryInterchainAccountResponse;
                        toProto(message: _138.QueryInterchainAccountResponse): Uint8Array;
                        toProtoMsg(message: _138.QueryInterchainAccountResponse): _138.QueryInterchainAccountResponseProtoMsg;
                    };
                    QueryParamsRequest: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest";
                        encode(_: _138.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _138.QueryParamsRequest;
                        fromJSON(_: any): _138.QueryParamsRequest;
                        toJSON(_: _138.QueryParamsRequest): import("../json-safe.ts").JsonSafe<_138.QueryParamsRequest>;
                        fromPartial(_: Partial<_138.QueryParamsRequest>): _138.QueryParamsRequest;
                        fromProtoMsg(message: _138.QueryParamsRequestProtoMsg): _138.QueryParamsRequest;
                        toProto(message: _138.QueryParamsRequest): Uint8Array;
                        toProtoMsg(message: _138.QueryParamsRequest): _138.QueryParamsRequestProtoMsg;
                    };
                    QueryParamsResponse: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse";
                        encode(message: _138.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _138.QueryParamsResponse;
                        fromJSON(object: any): _138.QueryParamsResponse;
                        toJSON(message: _138.QueryParamsResponse): import("../json-safe.ts").JsonSafe<_138.QueryParamsResponse>;
                        fromPartial(object: Partial<_138.QueryParamsResponse>): _138.QueryParamsResponse;
                        fromProtoMsg(message: _138.QueryParamsResponseProtoMsg): _138.QueryParamsResponse;
                        toProto(message: _138.QueryParamsResponse): Uint8Array;
                        toProtoMsg(message: _138.QueryParamsResponse): _138.QueryParamsResponseProtoMsg;
                    };
                    Params: {
                        typeUrl: "/ibc.applications.interchain_accounts.controller.v1.Params";
                        encode(message: _137.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _137.Params;
                        fromJSON(object: any): _137.Params;
                        toJSON(message: _137.Params): import("../json-safe.ts").JsonSafe<_137.Params>;
                        fromPartial(object: Partial<_137.Params>): _137.Params;
                        fromProtoMsg(message: _137.ParamsProtoMsg): _137.Params;
                        toProto(message: _137.Params): Uint8Array;
                        toProtoMsg(message: _137.Params): _137.ParamsProtoMsg;
                    };
                };
            }
            namespace genesis {
                const v1: {
                    GenesisState: {
                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.GenesisState";
                        encode(message: _140.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.GenesisState;
                        fromJSON(object: any): _140.GenesisState;
                        toJSON(message: _140.GenesisState): import("../json-safe.ts").JsonSafe<_140.GenesisState>;
                        fromPartial(object: Partial<_140.GenesisState>): _140.GenesisState;
                        fromProtoMsg(message: _140.GenesisStateProtoMsg): _140.GenesisState;
                        toProto(message: _140.GenesisState): Uint8Array;
                        toProtoMsg(message: _140.GenesisState): _140.GenesisStateProtoMsg;
                    };
                    ControllerGenesisState: {
                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState";
                        encode(message: _140.ControllerGenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.ControllerGenesisState;
                        fromJSON(object: any): _140.ControllerGenesisState;
                        toJSON(message: _140.ControllerGenesisState): import("../json-safe.ts").JsonSafe<_140.ControllerGenesisState>;
                        fromPartial(object: Partial<_140.ControllerGenesisState>): _140.ControllerGenesisState;
                        fromProtoMsg(message: _140.ControllerGenesisStateProtoMsg): _140.ControllerGenesisState;
                        toProto(message: _140.ControllerGenesisState): Uint8Array;
                        toProtoMsg(message: _140.ControllerGenesisState): _140.ControllerGenesisStateProtoMsg;
                    };
                    HostGenesisState: {
                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.HostGenesisState";
                        encode(message: _140.HostGenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.HostGenesisState;
                        fromJSON(object: any): _140.HostGenesisState;
                        toJSON(message: _140.HostGenesisState): import("../json-safe.ts").JsonSafe<_140.HostGenesisState>;
                        fromPartial(object: Partial<_140.HostGenesisState>): _140.HostGenesisState;
                        fromProtoMsg(message: _140.HostGenesisStateProtoMsg): _140.HostGenesisState;
                        toProto(message: _140.HostGenesisState): Uint8Array;
                        toProtoMsg(message: _140.HostGenesisState): _140.HostGenesisStateProtoMsg;
                    };
                    ActiveChannel: {
                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.ActiveChannel";
                        encode(message: _140.ActiveChannel, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.ActiveChannel;
                        fromJSON(object: any): _140.ActiveChannel;
                        toJSON(message: _140.ActiveChannel): import("../json-safe.ts").JsonSafe<_140.ActiveChannel>;
                        fromPartial(object: Partial<_140.ActiveChannel>): _140.ActiveChannel;
                        fromProtoMsg(message: _140.ActiveChannelProtoMsg): _140.ActiveChannel;
                        toProto(message: _140.ActiveChannel): Uint8Array;
                        toProtoMsg(message: _140.ActiveChannel): _140.ActiveChannelProtoMsg;
                    };
                    RegisteredInterchainAccount: {
                        typeUrl: "/ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount";
                        encode(message: _140.RegisteredInterchainAccount, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _140.RegisteredInterchainAccount;
                        fromJSON(object: any): _140.RegisteredInterchainAccount;
                        toJSON(message: _140.RegisteredInterchainAccount): import("../json-safe.ts").JsonSafe<_140.RegisteredInterchainAccount>;
                        fromPartial(object: Partial<_140.RegisteredInterchainAccount>): _140.RegisteredInterchainAccount;
                        fromProtoMsg(message: _140.RegisteredInterchainAccountProtoMsg): _140.RegisteredInterchainAccount;
                        toProto(message: _140.RegisteredInterchainAccount): Uint8Array;
                        toProtoMsg(message: _140.RegisteredInterchainAccount): _140.RegisteredInterchainAccountProtoMsg;
                    };
                };
            }
            namespace host {
                const v1: {
                    MsgUpdateParams: {
                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParams";
                        encode(message: _143.MsgUpdateParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _143.MsgUpdateParams;
                        fromJSON(object: any): _143.MsgUpdateParams;
                        toJSON(message: _143.MsgUpdateParams): import("../json-safe.ts").JsonSafe<_143.MsgUpdateParams>;
                        fromPartial(object: Partial<_143.MsgUpdateParams>): _143.MsgUpdateParams;
                        fromProtoMsg(message: _143.MsgUpdateParamsProtoMsg): _143.MsgUpdateParams;
                        toProto(message: _143.MsgUpdateParams): Uint8Array;
                        toProtoMsg(message: _143.MsgUpdateParams): _143.MsgUpdateParamsProtoMsg;
                    };
                    MsgUpdateParamsResponse: {
                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse";
                        encode(_: _143.MsgUpdateParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _143.MsgUpdateParamsResponse;
                        fromJSON(_: any): _143.MsgUpdateParamsResponse;
                        toJSON(_: _143.MsgUpdateParamsResponse): import("../json-safe.ts").JsonSafe<_143.MsgUpdateParamsResponse>;
                        fromPartial(_: Partial<_143.MsgUpdateParamsResponse>): _143.MsgUpdateParamsResponse;
                        fromProtoMsg(message: _143.MsgUpdateParamsResponseProtoMsg): _143.MsgUpdateParamsResponse;
                        toProto(message: _143.MsgUpdateParamsResponse): Uint8Array;
                        toProtoMsg(message: _143.MsgUpdateParamsResponse): _143.MsgUpdateParamsResponseProtoMsg;
                    };
                    MsgModuleQuerySafe: {
                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe";
                        encode(message: _143.MsgModuleQuerySafe, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _143.MsgModuleQuerySafe;
                        fromJSON(object: any): _143.MsgModuleQuerySafe;
                        toJSON(message: _143.MsgModuleQuerySafe): import("../json-safe.ts").JsonSafe<_143.MsgModuleQuerySafe>;
                        fromPartial(object: Partial<_143.MsgModuleQuerySafe>): _143.MsgModuleQuerySafe;
                        fromProtoMsg(message: _143.MsgModuleQuerySafeProtoMsg): _143.MsgModuleQuerySafe;
                        toProto(message: _143.MsgModuleQuerySafe): Uint8Array;
                        toProtoMsg(message: _143.MsgModuleQuerySafe): _143.MsgModuleQuerySafeProtoMsg;
                    };
                    MsgModuleQuerySafeResponse: {
                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse";
                        encode(message: _143.MsgModuleQuerySafeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _143.MsgModuleQuerySafeResponse;
                        fromJSON(object: any): _143.MsgModuleQuerySafeResponse;
                        toJSON(message: _143.MsgModuleQuerySafeResponse): import("../json-safe.ts").JsonSafe<_143.MsgModuleQuerySafeResponse>;
                        fromPartial(object: Partial<_143.MsgModuleQuerySafeResponse>): _143.MsgModuleQuerySafeResponse;
                        fromProtoMsg(message: _143.MsgModuleQuerySafeResponseProtoMsg): _143.MsgModuleQuerySafeResponse;
                        toProto(message: _143.MsgModuleQuerySafeResponse): Uint8Array;
                        toProtoMsg(message: _143.MsgModuleQuerySafeResponse): _143.MsgModuleQuerySafeResponseProtoMsg;
                    };
                    QueryParamsRequest: {
                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsRequest";
                        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: "/ibc.applications.interchain_accounts.host.v1.QueryParamsResponse";
                        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;
                    };
                    Params: {
                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.Params";
                        encode(message: _141.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _141.Params;
                        fromJSON(object: any): _141.Params;
                        toJSON(message: _141.Params): import("../json-safe.ts").JsonSafe<_141.Params>;
                        fromPartial(object: Partial<_141.Params>): _141.Params;
                        fromProtoMsg(message: _141.ParamsProtoMsg): _141.Params;
                        toProto(message: _141.Params): Uint8Array;
                        toProtoMsg(message: _141.Params): _141.ParamsProtoMsg;
                    };
                    QueryRequest: {
                        typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryRequest";
                        encode(message: _141.QueryRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                        decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _141.QueryRequest;
                        fromJSON(object: any): _141.QueryRequest;
                        toJSON(message: _141.QueryRequest): import("../json-safe.ts").JsonSafe<_141.QueryRequest>;
                        fromPartial(object: Partial<_141.QueryRequest>): _141.QueryRequest;
                        fromProtoMsg(message: _141.QueryRequestProtoMsg): _141.QueryRequest;
                        toProto(message: _141.QueryRequest): Uint8Array;
                        toProtoMsg(message: _141.QueryRequest): _141.QueryRequestProtoMsg;
                    };
                };
            }
            const v1: {
                typeFromJSON(object: any): _146.Type;
                typeToJSON(object: _146.Type): string;
                Type: typeof _146.Type;
                TypeSDKType: typeof _146.Type;
                InterchainAccountPacketData: {
                    typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccountPacketData";
                    encode(message: _146.InterchainAccountPacketData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.InterchainAccountPacketData;
                    fromJSON(object: any): _146.InterchainAccountPacketData;
                    toJSON(message: _146.InterchainAccountPacketData): import("../json-safe.ts").JsonSafe<_146.InterchainAccountPacketData>;
                    fromPartial(object: Partial<_146.InterchainAccountPacketData>): _146.InterchainAccountPacketData;
                    fromProtoMsg(message: _146.InterchainAccountPacketDataProtoMsg): _146.InterchainAccountPacketData;
                    toProto(message: _146.InterchainAccountPacketData): Uint8Array;
                    toProtoMsg(message: _146.InterchainAccountPacketData): _146.InterchainAccountPacketDataProtoMsg;
                };
                CosmosTx: {
                    typeUrl: "/ibc.applications.interchain_accounts.v1.CosmosTx";
                    encode(message: _146.CosmosTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _146.CosmosTx;
                    fromJSON(object: any): _146.CosmosTx;
                    toJSON(message: _146.CosmosTx): import("../json-safe.ts").JsonSafe<_146.CosmosTx>;
                    fromPartial(object: Partial<_146.CosmosTx>): _146.CosmosTx;
                    fromProtoMsg(message: _146.CosmosTxProtoMsg): _146.CosmosTx;
                    toProto(message: _146.CosmosTx): Uint8Array;
                    toProtoMsg(message: _146.CosmosTx): _146.CosmosTxProtoMsg;
                };
                Metadata: {
                    typeUrl: "/ibc.applications.interchain_accounts.v1.Metadata";
                    encode(message: _145.Metadata, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _145.Metadata;
                    fromJSON(object: any): _145.Metadata;
                    toJSON(message: _145.Metadata): import("../json-safe.ts").JsonSafe<_145.Metadata>;
                    fromPartial(object: Partial<_145.Metadata>): _145.Metadata;
                    fromProtoMsg(message: _145.MetadataProtoMsg): _145.Metadata;
                    toProto(message: _145.Metadata): Uint8Array;
                    toProtoMsg(message: _145.Metadata): _145.MetadataProtoMsg;
                };
                InterchainAccount: {
                    typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccount";
                    encode(message: _144.InterchainAccount, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _144.InterchainAccount;
                    fromJSON(object: any): _144.InterchainAccount;
                    toJSON(message: _144.InterchainAccount): import("../json-safe.ts").JsonSafe<_144.InterchainAccount>;
                    fromPartial(object: Partial<_144.InterchainAccount>): _144.InterchainAccount;
                    fromProtoMsg(message: _144.InterchainAccountProtoMsg): _144.InterchainAccount;
                    toProto(message: _144.InterchainAccount): Uint8Array;
                    toProtoMsg(message: _144.InterchainAccount): _144.InterchainAccountProtoMsg;
                };
            };
        }
        namespace transfer {
            const v1: {
                MsgTransfer: {
                    typeUrl: "/ibc.applications.transfer.v1.MsgTransfer";
                    encode(message: _151.MsgTransfer, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgTransfer;
                    fromJSON(object: any): _151.MsgTransfer;
                    toJSON(message: _151.MsgTransfer): import("../json-safe.ts").JsonSafe<_151.MsgTransfer>;
                    fromPartial(object: Partial<_151.MsgTransfer>): _151.MsgTransfer;
                    fromProtoMsg(message: _151.MsgTransferProtoMsg): _151.MsgTransfer;
                    toProto(message: _151.MsgTransfer): Uint8Array;
                    toProtoMsg(message: _151.MsgTransfer): _151.MsgTransferProtoMsg;
                };
                MsgTransferResponse: {
                    typeUrl: "/ibc.applications.transfer.v1.MsgTransferResponse";
                    encode(message: _151.MsgTransferResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgTransferResponse;
                    fromJSON(object: any): _151.MsgTransferResponse;
                    toJSON(message: _151.MsgTransferResponse): import("../json-safe.ts").JsonSafe<_151.MsgTransferResponse>;
                    fromPartial(object: Partial<_151.MsgTransferResponse>): _151.MsgTransferResponse;
                    fromProtoMsg(message: _151.MsgTransferResponseProtoMsg): _151.MsgTransferResponse;
                    toProto(message: _151.MsgTransferResponse): Uint8Array;
                    toProtoMsg(message: _151.MsgTransferResponse): _151.MsgTransferResponseProtoMsg;
                };
                MsgUpdateParams: {
                    typeUrl: "/ibc.applications.transfer.v1.MsgUpdateParams";
                    encode(message: _151.MsgUpdateParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgUpdateParams;
                    fromJSON(object: any): _151.MsgUpdateParams;
                    toJSON(message: _151.MsgUpdateParams): import("../json-safe.ts").JsonSafe<_151.MsgUpdateParams>;
                    fromPartial(object: Partial<_151.MsgUpdateParams>): _151.MsgUpdateParams;
                    fromProtoMsg(message: _151.MsgUpdateParamsProtoMsg): _151.MsgUpdateParams;
                    toProto(message: _151.MsgUpdateParams): Uint8Array;
                    toProtoMsg(message: _151.MsgUpdateParams): _151.MsgUpdateParamsProtoMsg;
                };
                MsgUpdateParamsResponse: {
                    typeUrl: "/ibc.applications.transfer.v1.MsgUpdateParamsResponse";
                    encode(_: _151.MsgUpdateParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _151.MsgUpdateParamsResponse;
                    fromJSON(_: any): _151.MsgUpdateParamsResponse;
                    toJSON(_: _151.MsgUpdateParamsResponse): import("../json-safe.ts").JsonSafe<_151.MsgUpdateParamsResponse>;
                    fromPartial(_: Partial<_151.MsgUpdateParamsResponse>): _151.MsgUpdateParamsResponse;
                    fromProtoMsg(message: _151.MsgUpdateParamsResponseProtoMsg): _151.MsgUpdateParamsResponse;
                    toProto(message: _151.MsgUpdateParamsResponse): Uint8Array;
                    toProtoMsg(message: _151.MsgUpdateParamsResponse): _151.MsgUpdateParamsResponseProtoMsg;
                };
                DenomTrace: {
                    typeUrl: "/ibc.applications.transfer.v1.DenomTrace";
                    encode(message: _150.DenomTrace, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _150.DenomTrace;
                    fromJSON(object: any): _150.DenomTrace;
                    toJSON(message: _150.DenomTrace): import("../json-safe.ts").JsonSafe<_150.DenomTrace>;
                    fromPartial(object: Partial<_150.DenomTrace>): _150.DenomTrace;
                    fromProtoMsg(message: _150.DenomTraceProtoMsg): _150.DenomTrace;
                    toProto(message: _150.DenomTrace): Uint8Array;
                    toProtoMsg(message: _150.DenomTrace): _150.DenomTraceProtoMsg;
                };
                Params: {
                    typeUrl: "/ibc.applications.transfer.v1.Params";
                    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;
                };
                QueryDenomTraceRequest: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTraceRequest";
                    encode(message: _149.QueryDenomTraceRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryDenomTraceRequest;
                    fromJSON(object: any): _149.QueryDenomTraceRequest;
                    toJSON(message: _149.QueryDenomTraceRequest): import("../json-safe.ts").JsonSafe<_149.QueryDenomTraceRequest>;
                    fromPartial(object: Partial<_149.QueryDenomTraceRequest>): _149.QueryDenomTraceRequest;
                    fromProtoMsg(message: _149.QueryDenomTraceRequestProtoMsg): _149.QueryDenomTraceRequest;
                    toProto(message: _149.QueryDenomTraceRequest): Uint8Array;
                    toProtoMsg(message: _149.QueryDenomTraceRequest): _149.QueryDenomTraceRequestProtoMsg;
                };
                QueryDenomTraceResponse: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTraceResponse";
                    encode(message: _149.QueryDenomTraceResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryDenomTraceResponse;
                    fromJSON(object: any): _149.QueryDenomTraceResponse;
                    toJSON(message: _149.QueryDenomTraceResponse): import("../json-safe.ts").JsonSafe<_149.QueryDenomTraceResponse>;
                    fromPartial(object: Partial<_149.QueryDenomTraceResponse>): _149.QueryDenomTraceResponse;
                    fromProtoMsg(message: _149.QueryDenomTraceResponseProtoMsg): _149.QueryDenomTraceResponse;
                    toProto(message: _149.QueryDenomTraceResponse): Uint8Array;
                    toProtoMsg(message: _149.QueryDenomTraceResponse): _149.QueryDenomTraceResponseProtoMsg;
                };
                QueryDenomTracesRequest: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTracesRequest";
                    encode(message: _149.QueryDenomTracesRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryDenomTracesRequest;
                    fromJSON(object: any): _149.QueryDenomTracesRequest;
                    toJSON(message: _149.QueryDenomTracesRequest): import("../json-safe.ts").JsonSafe<_149.QueryDenomTracesRequest>;
                    fromPartial(object: Partial<_149.QueryDenomTracesRequest>): _149.QueryDenomTracesRequest;
                    fromProtoMsg(message: _149.QueryDenomTracesRequestProtoMsg): _149.QueryDenomTracesRequest;
                    toProto(message: _149.QueryDenomTracesRequest): Uint8Array;
                    toProtoMsg(message: _149.QueryDenomTracesRequest): _149.QueryDenomTracesRequestProtoMsg;
                };
                QueryDenomTracesResponse: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomTracesResponse";
                    encode(message: _149.QueryDenomTracesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryDenomTracesResponse;
                    fromJSON(object: any): _149.QueryDenomTracesResponse;
                    toJSON(message: _149.QueryDenomTracesResponse): import("../json-safe.ts").JsonSafe<_149.QueryDenomTracesResponse>;
                    fromPartial(object: Partial<_149.QueryDenomTracesResponse>): _149.QueryDenomTracesResponse;
                    fromProtoMsg(message: _149.QueryDenomTracesResponseProtoMsg): _149.QueryDenomTracesResponse;
                    toProto(message: _149.QueryDenomTracesResponse): Uint8Array;
                    toProtoMsg(message: _149.QueryDenomTracesResponse): _149.QueryDenomTracesResponseProtoMsg;
                };
                QueryParamsRequest: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryParamsRequest";
                    encode(_: _149.QueryParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryParamsRequest;
                    fromJSON(_: any): _149.QueryParamsRequest;
                    toJSON(_: _149.QueryParamsRequest): import("../json-safe.ts").JsonSafe<_149.QueryParamsRequest>;
                    fromPartial(_: Partial<_149.QueryParamsRequest>): _149.QueryParamsRequest;
                    fromProtoMsg(message: _149.QueryParamsRequestProtoMsg): _149.QueryParamsRequest;
                    toProto(message: _149.QueryParamsRequest): Uint8Array;
                    toProtoMsg(message: _149.QueryParamsRequest): _149.QueryParamsRequestProtoMsg;
                };
                QueryParamsResponse: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryParamsResponse";
                    encode(message: _149.QueryParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryParamsResponse;
                    fromJSON(object: any): _149.QueryParamsResponse;
                    toJSON(message: _149.QueryParamsResponse): import("../json-safe.ts").JsonSafe<_149.QueryParamsResponse>;
                    fromPartial(object: Partial<_149.QueryParamsResponse>): _149.QueryParamsResponse;
                    fromProtoMsg(message: _149.QueryParamsResponseProtoMsg): _149.QueryParamsResponse;
                    toProto(message: _149.QueryParamsResponse): Uint8Array;
                    toProtoMsg(message: _149.QueryParamsResponse): _149.QueryParamsResponseProtoMsg;
                };
                QueryDenomHashRequest: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashRequest";
                    encode(message: _149.QueryDenomHashRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryDenomHashRequest;
                    fromJSON(object: any): _149.QueryDenomHashRequest;
                    toJSON(message: _149.QueryDenomHashRequest): import("../json-safe.ts").JsonSafe<_149.QueryDenomHashRequest>;
                    fromPartial(object: Partial<_149.QueryDenomHashRequest>): _149.QueryDenomHashRequest;
                    fromProtoMsg(message: _149.QueryDenomHashRequestProtoMsg): _149.QueryDenomHashRequest;
                    toProto(message: _149.QueryDenomHashRequest): Uint8Array;
                    toProtoMsg(message: _149.QueryDenomHashRequest): _149.QueryDenomHashRequestProtoMsg;
                };
                QueryDenomHashResponse: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryDenomHashResponse";
                    encode(message: _149.QueryDenomHashResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryDenomHashResponse;
                    fromJSON(object: any): _149.QueryDenomHashResponse;
                    toJSON(message: _149.QueryDenomHashResponse): import("../json-safe.ts").JsonSafe<_149.QueryDenomHashResponse>;
                    fromPartial(object: Partial<_149.QueryDenomHashResponse>): _149.QueryDenomHashResponse;
                    fromProtoMsg(message: _149.QueryDenomHashResponseProtoMsg): _149.QueryDenomHashResponse;
                    toProto(message: _149.QueryDenomHashResponse): Uint8Array;
                    toProtoMsg(message: _149.QueryDenomHashResponse): _149.QueryDenomHashResponseProtoMsg;
                };
                QueryEscrowAddressRequest: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryEscrowAddressRequest";
                    encode(message: _149.QueryEscrowAddressRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryEscrowAddressRequest;
                    fromJSON(object: any): _149.QueryEscrowAddressRequest;
                    toJSON(message: _149.QueryEscrowAddressRequest): import("../json-safe.ts").JsonSafe<_149.QueryEscrowAddressRequest>;
                    fromPartial(object: Partial<_149.QueryEscrowAddressRequest>): _149.QueryEscrowAddressRequest;
                    fromProtoMsg(message: _149.QueryEscrowAddressRequestProtoMsg): _149.QueryEscrowAddressRequest;
                    toProto(message: _149.QueryEscrowAddressRequest): Uint8Array;
                    toProtoMsg(message: _149.QueryEscrowAddressRequest): _149.QueryEscrowAddressRequestProtoMsg;
                };
                QueryEscrowAddressResponse: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryEscrowAddressResponse";
                    encode(message: _149.QueryEscrowAddressResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryEscrowAddressResponse;
                    fromJSON(object: any): _149.QueryEscrowAddressResponse;
                    toJSON(message: _149.QueryEscrowAddressResponse): import("../json-safe.ts").JsonSafe<_149.QueryEscrowAddressResponse>;
                    fromPartial(object: Partial<_149.QueryEscrowAddressResponse>): _149.QueryEscrowAddressResponse;
                    fromProtoMsg(message: _149.QueryEscrowAddressResponseProtoMsg): _149.QueryEscrowAddressResponse;
                    toProto(message: _149.QueryEscrowAddressResponse): Uint8Array;
                    toProtoMsg(message: _149.QueryEscrowAddressResponse): _149.QueryEscrowAddressResponseProtoMsg;
                };
                QueryTotalEscrowForDenomRequest: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest";
                    encode(message: _149.QueryTotalEscrowForDenomRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryTotalEscrowForDenomRequest;
                    fromJSON(object: any): _149.QueryTotalEscrowForDenomRequest;
                    toJSON(message: _149.QueryTotalEscrowForDenomRequest): import("../json-safe.ts").JsonSafe<_149.QueryTotalEscrowForDenomRequest>;
                    fromPartial(object: Partial<_149.QueryTotalEscrowForDenomRequest>): _149.QueryTotalEscrowForDenomRequest;
                    fromProtoMsg(message: _149.QueryTotalEscrowForDenomRequestProtoMsg): _149.QueryTotalEscrowForDenomRequest;
                    toProto(message: _149.QueryTotalEscrowForDenomRequest): Uint8Array;
                    toProtoMsg(message: _149.QueryTotalEscrowForDenomRequest): _149.QueryTotalEscrowForDenomRequestProtoMsg;
                };
                QueryTotalEscrowForDenomResponse: {
                    typeUrl: "/ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse";
                    encode(message: _149.QueryTotalEscrowForDenomResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _149.QueryTotalEscrowForDenomResponse;
                    fromJSON(object: any): _149.QueryTotalEscrowForDenomResponse;
                    toJSON(message: _149.QueryTotalEscrowForDenomResponse): import("../json-safe.ts").JsonSafe<_149.QueryTotalEscrowForDenomResponse>;
                    fromPartial(object: Partial<_149.QueryTotalEscrowForDenomResponse>): _149.QueryTotalEscrowForDenomResponse;
                    fromProtoMsg(message: _149.QueryTotalEscrowForDenomResponseProtoMsg): _149.QueryTotalEscrowForDenomResponse;
                    toProto(message: _149.QueryTotalEscrowForDenomResponse): Uint8Array;
                    toProtoMsg(message: _149.QueryTotalEscrowForDenomResponse): _149.QueryTotalEscrowForDenomResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: "/ibc.applications.transfer.v1.GenesisState";
                    encode(message: _148.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _148.GenesisState;
                    fromJSON(object: any): _148.GenesisState;
                    toJSON(message: _148.GenesisState): import("../json-safe.ts").JsonSafe<_148.GenesisState>;
                    fromPartial(object: Partial<_148.GenesisState>): _148.GenesisState;
                    fromProtoMsg(message: _148.GenesisStateProtoMsg): _148.GenesisState;
                    toProto(message: _148.GenesisState): Uint8Array;
                    toProtoMsg(message: _148.GenesisState): _148.GenesisStateProtoMsg;
                };
                Allocation: {
                    typeUrl: "/ibc.applications.transfer.v1.Allocation";
                    encode(message: _147.Allocation, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.Allocation;
                    fromJSON(object: any): _147.Allocation;
                    toJSON(message: _147.Allocation): import("../json-safe.ts").JsonSafe<_147.Allocation>;
                    fromPartial(object: Partial<_147.Allocation>): _147.Allocation;
                    fromProtoMsg(message: _147.AllocationProtoMsg): _147.Allocation;
                    toProto(message: _147.Allocation): Uint8Array;
                    toProtoMsg(message: _147.Allocation): _147.AllocationProtoMsg;
                };
                TransferAuthorization: {
                    typeUrl: "/ibc.applications.transfer.v1.TransferAuthorization";
                    encode(message: _147.TransferAuthorization, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _147.TransferAuthorization;
                    fromJSON(object: any): _147.TransferAuthorization;
                    toJSON(message: _147.TransferAuthorization): import("../json-safe.ts").JsonSafe<_147.TransferAuthorization>;
                    fromPartial(object: Partial<_147.TransferAuthorization>): _147.TransferAuthorization;
                    fromProtoMsg(message: _147.TransferAuthorizationProtoMsg): _147.TransferAuthorization;
                    toProto(message: _147.TransferAuthorization): Uint8Array;
                    toProtoMsg(message: _147.TransferAuthorization): _147.TransferAuthorizationProtoMsg;
                };
            };
            const v2: {
                FungibleTokenPacketData: {
                    typeUrl: "/ibc.applications.transfer.v2.FungibleTokenPacketData";
                    encode(message: _152.FungibleTokenPacketData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _152.FungibleTokenPacketData;
                    fromJSON(object: any): _152.FungibleTokenPacketData;
                    toJSON(message: _152.FungibleTokenPacketData): import("../json-safe.ts").JsonSafe<_152.FungibleTokenPacketData>;
                    fromPartial(object: Partial<_152.FungibleTokenPacketData>): _152.FungibleTokenPacketData;
                    fromProtoMsg(message: _152.FungibleTokenPacketDataProtoMsg): _152.FungibleTokenPacketData;
                    toProto(message: _152.FungibleTokenPacketData): Uint8Array;
                    toProtoMsg(message: _152.FungibleTokenPacketData): _152.FungibleTokenPacketDataProtoMsg;
                };
            };
        }
    }
    namespace core {
        namespace channel {
            const v1: {
                Upgrade: {
                    typeUrl: "/ibc.core.channel.v1.Upgrade";
                    encode(message: _157.Upgrade, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _157.Upgrade;
                    fromJSON(object: any): _157.Upgrade;
                    toJSON(message: _157.Upgrade): import("../json-safe.ts").JsonSafe<_157.Upgrade>;
                    fromPartial(object: Partial<_157.Upgrade>): _157.Upgrade;
                    fromProtoMsg(message: _157.UpgradeProtoMsg): _157.Upgrade;
                    toProto(message: _157.Upgrade): Uint8Array;
                    toProtoMsg(message: _157.Upgrade): _157.UpgradeProtoMsg;
                };
                UpgradeFields: {
                    typeUrl: "/ibc.core.channel.v1.UpgradeFields";
                    encode(message: _157.UpgradeFields, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _157.UpgradeFields;
                    fromJSON(object: any): _157.UpgradeFields;
                    toJSON(message: _157.UpgradeFields): import("../json-safe.ts").JsonSafe<_157.UpgradeFields>;
                    fromPartial(object: Partial<_157.UpgradeFields>): _157.UpgradeFields;
                    fromProtoMsg(message: _157.UpgradeFieldsProtoMsg): _157.UpgradeFields;
                    toProto(message: _157.UpgradeFields): Uint8Array;
                    toProtoMsg(message: _157.UpgradeFields): _157.UpgradeFieldsProtoMsg;
                };
                ErrorReceipt: {
                    typeUrl: "/ibc.core.channel.v1.ErrorReceipt";
                    encode(message: _157.ErrorReceipt, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _157.ErrorReceipt;
                    fromJSON(object: any): _157.ErrorReceipt;
                    toJSON(message: _157.ErrorReceipt): import("../json-safe.ts").JsonSafe<_157.ErrorReceipt>;
                    fromPartial(object: Partial<_157.ErrorReceipt>): _157.ErrorReceipt;
                    fromProtoMsg(message: _157.ErrorReceiptProtoMsg): _157.ErrorReceipt;
                    toProto(message: _157.ErrorReceipt): Uint8Array;
                    toProtoMsg(message: _157.ErrorReceipt): _157.ErrorReceiptProtoMsg;
                };
                responseResultTypeFromJSON(object: any): _156.ResponseResultType;
                responseResultTypeToJSON(object: _156.ResponseResultType): string;
                ResponseResultType: typeof _156.ResponseResultType;
                ResponseResultTypeSDKType: typeof _156.ResponseResultType;
                MsgChannelOpenInit: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenInit";
                    encode(message: _156.MsgChannelOpenInit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelOpenInit;
                    fromJSON(object: any): _156.MsgChannelOpenInit;
                    toJSON(message: _156.MsgChannelOpenInit): import("../json-safe.ts").JsonSafe<_156.MsgChannelOpenInit>;
                    fromPartial(object: Partial<_156.MsgChannelOpenInit>): _156.MsgChannelOpenInit;
                    fromProtoMsg(message: _156.MsgChannelOpenInitProtoMsg): _156.MsgChannelOpenInit;
                    toProto(message: _156.MsgChannelOpenInit): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelOpenInit): _156.MsgChannelOpenInitProtoMsg;
                };
                MsgChannelOpenInitResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenInitResponse";
                    encode(message: _156.MsgChannelOpenInitResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelOpenInitResponse;
                    fromJSON(object: any): _156.MsgChannelOpenInitResponse;
                    toJSON(message: _156.MsgChannelOpenInitResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelOpenInitResponse>;
                    fromPartial(object: Partial<_156.MsgChannelOpenInitResponse>): _156.MsgChannelOpenInitResponse;
                    fromProtoMsg(message: _156.MsgChannelOpenInitResponseProtoMsg): _156.MsgChannelOpenInitResponse;
                    toProto(message: _156.MsgChannelOpenInitResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelOpenInitResponse): _156.MsgChannelOpenInitResponseProtoMsg;
                };
                MsgChannelOpenTry: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenTry";
                    encode(message: _156.MsgChannelOpenTry, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelOpenTry;
                    fromJSON(object: any): _156.MsgChannelOpenTry;
                    toJSON(message: _156.MsgChannelOpenTry): import("../json-safe.ts").JsonSafe<_156.MsgChannelOpenTry>;
                    fromPartial(object: Partial<_156.MsgChannelOpenTry>): _156.MsgChannelOpenTry;
                    fromProtoMsg(message: _156.MsgChannelOpenTryProtoMsg): _156.MsgChannelOpenTry;
                    toProto(message: _156.MsgChannelOpenTry): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelOpenTry): _156.MsgChannelOpenTryProtoMsg;
                };
                MsgChannelOpenTryResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenTryResponse";
                    encode(message: _156.MsgChannelOpenTryResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelOpenTryResponse;
                    fromJSON(object: any): _156.MsgChannelOpenTryResponse;
                    toJSON(message: _156.MsgChannelOpenTryResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelOpenTryResponse>;
                    fromPartial(object: Partial<_156.MsgChannelOpenTryResponse>): _156.MsgChannelOpenTryResponse;
                    fromProtoMsg(message: _156.MsgChannelOpenTryResponseProtoMsg): _156.MsgChannelOpenTryResponse;
                    toProto(message: _156.MsgChannelOpenTryResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelOpenTryResponse): _156.MsgChannelOpenTryResponseProtoMsg;
                };
                MsgChannelOpenAck: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenAck";
                    encode(message: _156.MsgChannelOpenAck, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelOpenAck;
                    fromJSON(object: any): _156.MsgChannelOpenAck;
                    toJSON(message: _156.MsgChannelOpenAck): import("../json-safe.ts").JsonSafe<_156.MsgChannelOpenAck>;
                    fromPartial(object: Partial<_156.MsgChannelOpenAck>): _156.MsgChannelOpenAck;
                    fromProtoMsg(message: _156.MsgChannelOpenAckProtoMsg): _156.MsgChannelOpenAck;
                    toProto(message: _156.MsgChannelOpenAck): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelOpenAck): _156.MsgChannelOpenAckProtoMsg;
                };
                MsgChannelOpenAckResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenAckResponse";
                    encode(_: _156.MsgChannelOpenAckResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelOpenAckResponse;
                    fromJSON(_: any): _156.MsgChannelOpenAckResponse;
                    toJSON(_: _156.MsgChannelOpenAckResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelOpenAckResponse>;
                    fromPartial(_: Partial<_156.MsgChannelOpenAckResponse>): _156.MsgChannelOpenAckResponse;
                    fromProtoMsg(message: _156.MsgChannelOpenAckResponseProtoMsg): _156.MsgChannelOpenAckResponse;
                    toProto(message: _156.MsgChannelOpenAckResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelOpenAckResponse): _156.MsgChannelOpenAckResponseProtoMsg;
                };
                MsgChannelOpenConfirm: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenConfirm";
                    encode(message: _156.MsgChannelOpenConfirm, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelOpenConfirm;
                    fromJSON(object: any): _156.MsgChannelOpenConfirm;
                    toJSON(message: _156.MsgChannelOpenConfirm): import("../json-safe.ts").JsonSafe<_156.MsgChannelOpenConfirm>;
                    fromPartial(object: Partial<_156.MsgChannelOpenConfirm>): _156.MsgChannelOpenConfirm;
                    fromProtoMsg(message: _156.MsgChannelOpenConfirmProtoMsg): _156.MsgChannelOpenConfirm;
                    toProto(message: _156.MsgChannelOpenConfirm): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelOpenConfirm): _156.MsgChannelOpenConfirmProtoMsg;
                };
                MsgChannelOpenConfirmResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelOpenConfirmResponse";
                    encode(_: _156.MsgChannelOpenConfirmResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelOpenConfirmResponse;
                    fromJSON(_: any): _156.MsgChannelOpenConfirmResponse;
                    toJSON(_: _156.MsgChannelOpenConfirmResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelOpenConfirmResponse>;
                    fromPartial(_: Partial<_156.MsgChannelOpenConfirmResponse>): _156.MsgChannelOpenConfirmResponse;
                    fromProtoMsg(message: _156.MsgChannelOpenConfirmResponseProtoMsg): _156.MsgChannelOpenConfirmResponse;
                    toProto(message: _156.MsgChannelOpenConfirmResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelOpenConfirmResponse): _156.MsgChannelOpenConfirmResponseProtoMsg;
                };
                MsgChannelCloseInit: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelCloseInit";
                    encode(message: _156.MsgChannelCloseInit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelCloseInit;
                    fromJSON(object: any): _156.MsgChannelCloseInit;
                    toJSON(message: _156.MsgChannelCloseInit): import("../json-safe.ts").JsonSafe<_156.MsgChannelCloseInit>;
                    fromPartial(object: Partial<_156.MsgChannelCloseInit>): _156.MsgChannelCloseInit;
                    fromProtoMsg(message: _156.MsgChannelCloseInitProtoMsg): _156.MsgChannelCloseInit;
                    toProto(message: _156.MsgChannelCloseInit): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelCloseInit): _156.MsgChannelCloseInitProtoMsg;
                };
                MsgChannelCloseInitResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelCloseInitResponse";
                    encode(_: _156.MsgChannelCloseInitResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelCloseInitResponse;
                    fromJSON(_: any): _156.MsgChannelCloseInitResponse;
                    toJSON(_: _156.MsgChannelCloseInitResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelCloseInitResponse>;
                    fromPartial(_: Partial<_156.MsgChannelCloseInitResponse>): _156.MsgChannelCloseInitResponse;
                    fromProtoMsg(message: _156.MsgChannelCloseInitResponseProtoMsg): _156.MsgChannelCloseInitResponse;
                    toProto(message: _156.MsgChannelCloseInitResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelCloseInitResponse): _156.MsgChannelCloseInitResponseProtoMsg;
                };
                MsgChannelCloseConfirm: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelCloseConfirm";
                    encode(message: _156.MsgChannelCloseConfirm, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelCloseConfirm;
                    fromJSON(object: any): _156.MsgChannelCloseConfirm;
                    toJSON(message: _156.MsgChannelCloseConfirm): import("../json-safe.ts").JsonSafe<_156.MsgChannelCloseConfirm>;
                    fromPartial(object: Partial<_156.MsgChannelCloseConfirm>): _156.MsgChannelCloseConfirm;
                    fromProtoMsg(message: _156.MsgChannelCloseConfirmProtoMsg): _156.MsgChannelCloseConfirm;
                    toProto(message: _156.MsgChannelCloseConfirm): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelCloseConfirm): _156.MsgChannelCloseConfirmProtoMsg;
                };
                MsgChannelCloseConfirmResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelCloseConfirmResponse";
                    encode(_: _156.MsgChannelCloseConfirmResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelCloseConfirmResponse;
                    fromJSON(_: any): _156.MsgChannelCloseConfirmResponse;
                    toJSON(_: _156.MsgChannelCloseConfirmResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelCloseConfirmResponse>;
                    fromPartial(_: Partial<_156.MsgChannelCloseConfirmResponse>): _156.MsgChannelCloseConfirmResponse;
                    fromProtoMsg(message: _156.MsgChannelCloseConfirmResponseProtoMsg): _156.MsgChannelCloseConfirmResponse;
                    toProto(message: _156.MsgChannelCloseConfirmResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelCloseConfirmResponse): _156.MsgChannelCloseConfirmResponseProtoMsg;
                };
                MsgRecvPacket: {
                    typeUrl: "/ibc.core.channel.v1.MsgRecvPacket";
                    encode(message: _156.MsgRecvPacket, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgRecvPacket;
                    fromJSON(object: any): _156.MsgRecvPacket;
                    toJSON(message: _156.MsgRecvPacket): import("../json-safe.ts").JsonSafe<_156.MsgRecvPacket>;
                    fromPartial(object: Partial<_156.MsgRecvPacket>): _156.MsgRecvPacket;
                    fromProtoMsg(message: _156.MsgRecvPacketProtoMsg): _156.MsgRecvPacket;
                    toProto(message: _156.MsgRecvPacket): Uint8Array;
                    toProtoMsg(message: _156.MsgRecvPacket): _156.MsgRecvPacketProtoMsg;
                };
                MsgRecvPacketResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgRecvPacketResponse";
                    encode(message: _156.MsgRecvPacketResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgRecvPacketResponse;
                    fromJSON(object: any): _156.MsgRecvPacketResponse;
                    toJSON(message: _156.MsgRecvPacketResponse): import("../json-safe.ts").JsonSafe<_156.MsgRecvPacketResponse>;
                    fromPartial(object: Partial<_156.MsgRecvPacketResponse>): _156.MsgRecvPacketResponse;
                    fromProtoMsg(message: _156.MsgRecvPacketResponseProtoMsg): _156.MsgRecvPacketResponse;
                    toProto(message: _156.MsgRecvPacketResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgRecvPacketResponse): _156.MsgRecvPacketResponseProtoMsg;
                };
                MsgTimeout: {
                    typeUrl: "/ibc.core.channel.v1.MsgTimeout";
                    encode(message: _156.MsgTimeout, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgTimeout;
                    fromJSON(object: any): _156.MsgTimeout;
                    toJSON(message: _156.MsgTimeout): import("../json-safe.ts").JsonSafe<_156.MsgTimeout>;
                    fromPartial(object: Partial<_156.MsgTimeout>): _156.MsgTimeout;
                    fromProtoMsg(message: _156.MsgTimeoutProtoMsg): _156.MsgTimeout;
                    toProto(message: _156.MsgTimeout): Uint8Array;
                    toProtoMsg(message: _156.MsgTimeout): _156.MsgTimeoutProtoMsg;
                };
                MsgTimeoutResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgTimeoutResponse";
                    encode(message: _156.MsgTimeoutResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgTimeoutResponse;
                    fromJSON(object: any): _156.MsgTimeoutResponse;
                    toJSON(message: _156.MsgTimeoutResponse): import("../json-safe.ts").JsonSafe<_156.MsgTimeoutResponse>;
                    fromPartial(object: Partial<_156.MsgTimeoutResponse>): _156.MsgTimeoutResponse;
                    fromProtoMsg(message: _156.MsgTimeoutResponseProtoMsg): _156.MsgTimeoutResponse;
                    toProto(message: _156.MsgTimeoutResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgTimeoutResponse): _156.MsgTimeoutResponseProtoMsg;
                };
                MsgTimeoutOnClose: {
                    typeUrl: "/ibc.core.channel.v1.MsgTimeoutOnClose";
                    encode(message: _156.MsgTimeoutOnClose, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgTimeoutOnClose;
                    fromJSON(object: any): _156.MsgTimeoutOnClose;
                    toJSON(message: _156.MsgTimeoutOnClose): import("../json-safe.ts").JsonSafe<_156.MsgTimeoutOnClose>;
                    fromPartial(object: Partial<_156.MsgTimeoutOnClose>): _156.MsgTimeoutOnClose;
                    fromProtoMsg(message: _156.MsgTimeoutOnCloseProtoMsg): _156.MsgTimeoutOnClose;
                    toProto(message: _156.MsgTimeoutOnClose): Uint8Array;
                    toProtoMsg(message: _156.MsgTimeoutOnClose): _156.MsgTimeoutOnCloseProtoMsg;
                };
                MsgTimeoutOnCloseResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgTimeoutOnCloseResponse";
                    encode(message: _156.MsgTimeoutOnCloseResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgTimeoutOnCloseResponse;
                    fromJSON(object: any): _156.MsgTimeoutOnCloseResponse;
                    toJSON(message: _156.MsgTimeoutOnCloseResponse): import("../json-safe.ts").JsonSafe<_156.MsgTimeoutOnCloseResponse>;
                    fromPartial(object: Partial<_156.MsgTimeoutOnCloseResponse>): _156.MsgTimeoutOnCloseResponse;
                    fromProtoMsg(message: _156.MsgTimeoutOnCloseResponseProtoMsg): _156.MsgTimeoutOnCloseResponse;
                    toProto(message: _156.MsgTimeoutOnCloseResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgTimeoutOnCloseResponse): _156.MsgTimeoutOnCloseResponseProtoMsg;
                };
                MsgAcknowledgement: {
                    typeUrl: "/ibc.core.channel.v1.MsgAcknowledgement";
                    encode(message: _156.MsgAcknowledgement, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgAcknowledgement;
                    fromJSON(object: any): _156.MsgAcknowledgement;
                    toJSON(message: _156.MsgAcknowledgement): import("../json-safe.ts").JsonSafe<_156.MsgAcknowledgement>;
                    fromPartial(object: Partial<_156.MsgAcknowledgement>): _156.MsgAcknowledgement;
                    fromProtoMsg(message: _156.MsgAcknowledgementProtoMsg): _156.MsgAcknowledgement;
                    toProto(message: _156.MsgAcknowledgement): Uint8Array;
                    toProtoMsg(message: _156.MsgAcknowledgement): _156.MsgAcknowledgementProtoMsg;
                };
                MsgAcknowledgementResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgAcknowledgementResponse";
                    encode(message: _156.MsgAcknowledgementResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgAcknowledgementResponse;
                    fromJSON(object: any): _156.MsgAcknowledgementResponse;
                    toJSON(message: _156.MsgAcknowledgementResponse): import("../json-safe.ts").JsonSafe<_156.MsgAcknowledgementResponse>;
                    fromPartial(object: Partial<_156.MsgAcknowledgementResponse>): _156.MsgAcknowledgementResponse;
                    fromProtoMsg(message: _156.MsgAcknowledgementResponseProtoMsg): _156.MsgAcknowledgementResponse;
                    toProto(message: _156.MsgAcknowledgementResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgAcknowledgementResponse): _156.MsgAcknowledgementResponseProtoMsg;
                };
                MsgChannelUpgradeInit: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeInit";
                    encode(message: _156.MsgChannelUpgradeInit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeInit;
                    fromJSON(object: any): _156.MsgChannelUpgradeInit;
                    toJSON(message: _156.MsgChannelUpgradeInit): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeInit>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeInit>): _156.MsgChannelUpgradeInit;
                    fromProtoMsg(message: _156.MsgChannelUpgradeInitProtoMsg): _156.MsgChannelUpgradeInit;
                    toProto(message: _156.MsgChannelUpgradeInit): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeInit): _156.MsgChannelUpgradeInitProtoMsg;
                };
                MsgChannelUpgradeInitResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeInitResponse";
                    encode(message: _156.MsgChannelUpgradeInitResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeInitResponse;
                    fromJSON(object: any): _156.MsgChannelUpgradeInitResponse;
                    toJSON(message: _156.MsgChannelUpgradeInitResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeInitResponse>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeInitResponse>): _156.MsgChannelUpgradeInitResponse;
                    fromProtoMsg(message: _156.MsgChannelUpgradeInitResponseProtoMsg): _156.MsgChannelUpgradeInitResponse;
                    toProto(message: _156.MsgChannelUpgradeInitResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeInitResponse): _156.MsgChannelUpgradeInitResponseProtoMsg;
                };
                MsgChannelUpgradeTry: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeTry";
                    encode(message: _156.MsgChannelUpgradeTry, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeTry;
                    fromJSON(object: any): _156.MsgChannelUpgradeTry;
                    toJSON(message: _156.MsgChannelUpgradeTry): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeTry>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeTry>): _156.MsgChannelUpgradeTry;
                    fromProtoMsg(message: _156.MsgChannelUpgradeTryProtoMsg): _156.MsgChannelUpgradeTry;
                    toProto(message: _156.MsgChannelUpgradeTry): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeTry): _156.MsgChannelUpgradeTryProtoMsg;
                };
                MsgChannelUpgradeTryResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeTryResponse";
                    encode(message: _156.MsgChannelUpgradeTryResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeTryResponse;
                    fromJSON(object: any): _156.MsgChannelUpgradeTryResponse;
                    toJSON(message: _156.MsgChannelUpgradeTryResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeTryResponse>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeTryResponse>): _156.MsgChannelUpgradeTryResponse;
                    fromProtoMsg(message: _156.MsgChannelUpgradeTryResponseProtoMsg): _156.MsgChannelUpgradeTryResponse;
                    toProto(message: _156.MsgChannelUpgradeTryResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeTryResponse): _156.MsgChannelUpgradeTryResponseProtoMsg;
                };
                MsgChannelUpgradeAck: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeAck";
                    encode(message: _156.MsgChannelUpgradeAck, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeAck;
                    fromJSON(object: any): _156.MsgChannelUpgradeAck;
                    toJSON(message: _156.MsgChannelUpgradeAck): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeAck>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeAck>): _156.MsgChannelUpgradeAck;
                    fromProtoMsg(message: _156.MsgChannelUpgradeAckProtoMsg): _156.MsgChannelUpgradeAck;
                    toProto(message: _156.MsgChannelUpgradeAck): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeAck): _156.MsgChannelUpgradeAckProtoMsg;
                };
                MsgChannelUpgradeAckResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeAckResponse";
                    encode(message: _156.MsgChannelUpgradeAckResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeAckResponse;
                    fromJSON(object: any): _156.MsgChannelUpgradeAckResponse;
                    toJSON(message: _156.MsgChannelUpgradeAckResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeAckResponse>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeAckResponse>): _156.MsgChannelUpgradeAckResponse;
                    fromProtoMsg(message: _156.MsgChannelUpgradeAckResponseProtoMsg): _156.MsgChannelUpgradeAckResponse;
                    toProto(message: _156.MsgChannelUpgradeAckResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeAckResponse): _156.MsgChannelUpgradeAckResponseProtoMsg;
                };
                MsgChannelUpgradeConfirm: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeConfirm";
                    encode(message: _156.MsgChannelUpgradeConfirm, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeConfirm;
                    fromJSON(object: any): _156.MsgChannelUpgradeConfirm;
                    toJSON(message: _156.MsgChannelUpgradeConfirm): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeConfirm>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeConfirm>): _156.MsgChannelUpgradeConfirm;
                    fromProtoMsg(message: _156.MsgChannelUpgradeConfirmProtoMsg): _156.MsgChannelUpgradeConfirm;
                    toProto(message: _156.MsgChannelUpgradeConfirm): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeConfirm): _156.MsgChannelUpgradeConfirmProtoMsg;
                };
                MsgChannelUpgradeConfirmResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeConfirmResponse";
                    encode(message: _156.MsgChannelUpgradeConfirmResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeConfirmResponse;
                    fromJSON(object: any): _156.MsgChannelUpgradeConfirmResponse;
                    toJSON(message: _156.MsgChannelUpgradeConfirmResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeConfirmResponse>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeConfirmResponse>): _156.MsgChannelUpgradeConfirmResponse;
                    fromProtoMsg(message: _156.MsgChannelUpgradeConfirmResponseProtoMsg): _156.MsgChannelUpgradeConfirmResponse;
                    toProto(message: _156.MsgChannelUpgradeConfirmResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeConfirmResponse): _156.MsgChannelUpgradeConfirmResponseProtoMsg;
                };
                MsgChannelUpgradeOpen: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeOpen";
                    encode(message: _156.MsgChannelUpgradeOpen, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeOpen;
                    fromJSON(object: any): _156.MsgChannelUpgradeOpen;
                    toJSON(message: _156.MsgChannelUpgradeOpen): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeOpen>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeOpen>): _156.MsgChannelUpgradeOpen;
                    fromProtoMsg(message: _156.MsgChannelUpgradeOpenProtoMsg): _156.MsgChannelUpgradeOpen;
                    toProto(message: _156.MsgChannelUpgradeOpen): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeOpen): _156.MsgChannelUpgradeOpenProtoMsg;
                };
                MsgChannelUpgradeOpenResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeOpenResponse";
                    encode(_: _156.MsgChannelUpgradeOpenResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeOpenResponse;
                    fromJSON(_: any): _156.MsgChannelUpgradeOpenResponse;
                    toJSON(_: _156.MsgChannelUpgradeOpenResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeOpenResponse>;
                    fromPartial(_: Partial<_156.MsgChannelUpgradeOpenResponse>): _156.MsgChannelUpgradeOpenResponse;
                    fromProtoMsg(message: _156.MsgChannelUpgradeOpenResponseProtoMsg): _156.MsgChannelUpgradeOpenResponse;
                    toProto(message: _156.MsgChannelUpgradeOpenResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeOpenResponse): _156.MsgChannelUpgradeOpenResponseProtoMsg;
                };
                MsgChannelUpgradeTimeout: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeTimeout";
                    encode(message: _156.MsgChannelUpgradeTimeout, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeTimeout;
                    fromJSON(object: any): _156.MsgChannelUpgradeTimeout;
                    toJSON(message: _156.MsgChannelUpgradeTimeout): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeTimeout>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeTimeout>): _156.MsgChannelUpgradeTimeout;
                    fromProtoMsg(message: _156.MsgChannelUpgradeTimeoutProtoMsg): _156.MsgChannelUpgradeTimeout;
                    toProto(message: _156.MsgChannelUpgradeTimeout): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeTimeout): _156.MsgChannelUpgradeTimeoutProtoMsg;
                };
                MsgChannelUpgradeTimeoutResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeTimeoutResponse";
                    encode(_: _156.MsgChannelUpgradeTimeoutResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeTimeoutResponse;
                    fromJSON(_: any): _156.MsgChannelUpgradeTimeoutResponse;
                    toJSON(_: _156.MsgChannelUpgradeTimeoutResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeTimeoutResponse>;
                    fromPartial(_: Partial<_156.MsgChannelUpgradeTimeoutResponse>): _156.MsgChannelUpgradeTimeoutResponse;
                    fromProtoMsg(message: _156.MsgChannelUpgradeTimeoutResponseProtoMsg): _156.MsgChannelUpgradeTimeoutResponse;
                    toProto(message: _156.MsgChannelUpgradeTimeoutResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeTimeoutResponse): _156.MsgChannelUpgradeTimeoutResponseProtoMsg;
                };
                MsgChannelUpgradeCancel: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeCancel";
                    encode(message: _156.MsgChannelUpgradeCancel, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeCancel;
                    fromJSON(object: any): _156.MsgChannelUpgradeCancel;
                    toJSON(message: _156.MsgChannelUpgradeCancel): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeCancel>;
                    fromPartial(object: Partial<_156.MsgChannelUpgradeCancel>): _156.MsgChannelUpgradeCancel;
                    fromProtoMsg(message: _156.MsgChannelUpgradeCancelProtoMsg): _156.MsgChannelUpgradeCancel;
                    toProto(message: _156.MsgChannelUpgradeCancel): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeCancel): _156.MsgChannelUpgradeCancelProtoMsg;
                };
                MsgChannelUpgradeCancelResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgChannelUpgradeCancelResponse";
                    encode(_: _156.MsgChannelUpgradeCancelResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgChannelUpgradeCancelResponse;
                    fromJSON(_: any): _156.MsgChannelUpgradeCancelResponse;
                    toJSON(_: _156.MsgChannelUpgradeCancelResponse): import("../json-safe.ts").JsonSafe<_156.MsgChannelUpgradeCancelResponse>;
                    fromPartial(_: Partial<_156.MsgChannelUpgradeCancelResponse>): _156.MsgChannelUpgradeCancelResponse;
                    fromProtoMsg(message: _156.MsgChannelUpgradeCancelResponseProtoMsg): _156.MsgChannelUpgradeCancelResponse;
                    toProto(message: _156.MsgChannelUpgradeCancelResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgChannelUpgradeCancelResponse): _156.MsgChannelUpgradeCancelResponseProtoMsg;
                };
                MsgUpdateParams: {
                    typeUrl: "/ibc.core.channel.v1.MsgUpdateParams";
                    encode(message: _156.MsgUpdateParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgUpdateParams;
                    fromJSON(object: any): _156.MsgUpdateParams;
                    toJSON(message: _156.MsgUpdateParams): import("../json-safe.ts").JsonSafe<_156.MsgUpdateParams>;
                    fromPartial(object: Partial<_156.MsgUpdateParams>): _156.MsgUpdateParams;
                    fromProtoMsg(message: _156.MsgUpdateParamsProtoMsg): _156.MsgUpdateParams;
                    toProto(message: _156.MsgUpdateParams): Uint8Array;
                    toProtoMsg(message: _156.MsgUpdateParams): _156.MsgUpdateParamsProtoMsg;
                };
                MsgUpdateParamsResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgUpdateParamsResponse";
                    encode(_: _156.MsgUpdateParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgUpdateParamsResponse;
                    fromJSON(_: any): _156.MsgUpdateParamsResponse;
                    toJSON(_: _156.MsgUpdateParamsResponse): import("../json-safe.ts").JsonSafe<_156.MsgUpdateParamsResponse>;
                    fromPartial(_: Partial<_156.MsgUpdateParamsResponse>): _156.MsgUpdateParamsResponse;
                    fromProtoMsg(message: _156.MsgUpdateParamsResponseProtoMsg): _156.MsgUpdateParamsResponse;
                    toProto(message: _156.MsgUpdateParamsResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgUpdateParamsResponse): _156.MsgUpdateParamsResponseProtoMsg;
                };
                MsgPruneAcknowledgements: {
                    typeUrl: "/ibc.core.channel.v1.MsgPruneAcknowledgements";
                    encode(message: _156.MsgPruneAcknowledgements, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgPruneAcknowledgements;
                    fromJSON(object: any): _156.MsgPruneAcknowledgements;
                    toJSON(message: _156.MsgPruneAcknowledgements): import("../json-safe.ts").JsonSafe<_156.MsgPruneAcknowledgements>;
                    fromPartial(object: Partial<_156.MsgPruneAcknowledgements>): _156.MsgPruneAcknowledgements;
                    fromProtoMsg(message: _156.MsgPruneAcknowledgementsProtoMsg): _156.MsgPruneAcknowledgements;
                    toProto(message: _156.MsgPruneAcknowledgements): Uint8Array;
                    toProtoMsg(message: _156.MsgPruneAcknowledgements): _156.MsgPruneAcknowledgementsProtoMsg;
                };
                MsgPruneAcknowledgementsResponse: {
                    typeUrl: "/ibc.core.channel.v1.MsgPruneAcknowledgementsResponse";
                    encode(message: _156.MsgPruneAcknowledgementsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _156.MsgPruneAcknowledgementsResponse;
                    fromJSON(object: any): _156.MsgPruneAcknowledgementsResponse;
                    toJSON(message: _156.MsgPruneAcknowledgementsResponse): import("../json-safe.ts").JsonSafe<_156.MsgPruneAcknowledgementsResponse>;
                    fromPartial(object: Partial<_156.MsgPruneAcknowledgementsResponse>): _156.MsgPruneAcknowledgementsResponse;
                    fromProtoMsg(message: _156.MsgPruneAcknowledgementsResponseProtoMsg): _156.MsgPruneAcknowledgementsResponse;
                    toProto(message: _156.MsgPruneAcknowledgementsResponse): Uint8Array;
                    toProtoMsg(message: _156.MsgPruneAcknowledgementsResponse): _156.MsgPruneAcknowledgementsResponseProtoMsg;
                };
                QueryChannelRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelRequest";
                    encode(message: _155.QueryChannelRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelRequest;
                    fromJSON(object: any): _155.QueryChannelRequest;
                    toJSON(message: _155.QueryChannelRequest): import("../json-safe.ts").JsonSafe<_155.QueryChannelRequest>;
                    fromPartial(object: Partial<_155.QueryChannelRequest>): _155.QueryChannelRequest;
                    fromProtoMsg(message: _155.QueryChannelRequestProtoMsg): _155.QueryChannelRequest;
                    toProto(message: _155.QueryChannelRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelRequest): _155.QueryChannelRequestProtoMsg;
                };
                QueryChannelResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelResponse";
                    encode(message: _155.QueryChannelResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelResponse;
                    fromJSON(object: any): _155.QueryChannelResponse;
                    toJSON(message: _155.QueryChannelResponse): import("../json-safe.ts").JsonSafe<_155.QueryChannelResponse>;
                    fromPartial(object: Partial<_155.QueryChannelResponse>): _155.QueryChannelResponse;
                    fromProtoMsg(message: _155.QueryChannelResponseProtoMsg): _155.QueryChannelResponse;
                    toProto(message: _155.QueryChannelResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelResponse): _155.QueryChannelResponseProtoMsg;
                };
                QueryChannelsRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelsRequest";
                    encode(message: _155.QueryChannelsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelsRequest;
                    fromJSON(object: any): _155.QueryChannelsRequest;
                    toJSON(message: _155.QueryChannelsRequest): import("../json-safe.ts").JsonSafe<_155.QueryChannelsRequest>;
                    fromPartial(object: Partial<_155.QueryChannelsRequest>): _155.QueryChannelsRequest;
                    fromProtoMsg(message: _155.QueryChannelsRequestProtoMsg): _155.QueryChannelsRequest;
                    toProto(message: _155.QueryChannelsRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelsRequest): _155.QueryChannelsRequestProtoMsg;
                };
                QueryChannelsResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelsResponse";
                    encode(message: _155.QueryChannelsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelsResponse;
                    fromJSON(object: any): _155.QueryChannelsResponse;
                    toJSON(message: _155.QueryChannelsResponse): import("../json-safe.ts").JsonSafe<_155.QueryChannelsResponse>;
                    fromPartial(object: Partial<_155.QueryChannelsResponse>): _155.QueryChannelsResponse;
                    fromProtoMsg(message: _155.QueryChannelsResponseProtoMsg): _155.QueryChannelsResponse;
                    toProto(message: _155.QueryChannelsResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelsResponse): _155.QueryChannelsResponseProtoMsg;
                };
                QueryConnectionChannelsRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryConnectionChannelsRequest";
                    encode(message: _155.QueryConnectionChannelsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionChannelsRequest;
                    fromJSON(object: any): _155.QueryConnectionChannelsRequest;
                    toJSON(message: _155.QueryConnectionChannelsRequest): import("../json-safe.ts").JsonSafe<_155.QueryConnectionChannelsRequest>;
                    fromPartial(object: Partial<_155.QueryConnectionChannelsRequest>): _155.QueryConnectionChannelsRequest;
                    fromProtoMsg(message: _155.QueryConnectionChannelsRequestProtoMsg): _155.QueryConnectionChannelsRequest;
                    toProto(message: _155.QueryConnectionChannelsRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryConnectionChannelsRequest): _155.QueryConnectionChannelsRequestProtoMsg;
                };
                QueryConnectionChannelsResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryConnectionChannelsResponse";
                    encode(message: _155.QueryConnectionChannelsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryConnectionChannelsResponse;
                    fromJSON(object: any): _155.QueryConnectionChannelsResponse;
                    toJSON(message: _155.QueryConnectionChannelsResponse): import("../json-safe.ts").JsonSafe<_155.QueryConnectionChannelsResponse>;
                    fromPartial(object: Partial<_155.QueryConnectionChannelsResponse>): _155.QueryConnectionChannelsResponse;
                    fromProtoMsg(message: _155.QueryConnectionChannelsResponseProtoMsg): _155.QueryConnectionChannelsResponse;
                    toProto(message: _155.QueryConnectionChannelsResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryConnectionChannelsResponse): _155.QueryConnectionChannelsResponseProtoMsg;
                };
                QueryChannelClientStateRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelClientStateRequest";
                    encode(message: _155.QueryChannelClientStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelClientStateRequest;
                    fromJSON(object: any): _155.QueryChannelClientStateRequest;
                    toJSON(message: _155.QueryChannelClientStateRequest): import("../json-safe.ts").JsonSafe<_155.QueryChannelClientStateRequest>;
                    fromPartial(object: Partial<_155.QueryChannelClientStateRequest>): _155.QueryChannelClientStateRequest;
                    fromProtoMsg(message: _155.QueryChannelClientStateRequestProtoMsg): _155.QueryChannelClientStateRequest;
                    toProto(message: _155.QueryChannelClientStateRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelClientStateRequest): _155.QueryChannelClientStateRequestProtoMsg;
                };
                QueryChannelClientStateResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelClientStateResponse";
                    encode(message: _155.QueryChannelClientStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelClientStateResponse;
                    fromJSON(object: any): _155.QueryChannelClientStateResponse;
                    toJSON(message: _155.QueryChannelClientStateResponse): import("../json-safe.ts").JsonSafe<_155.QueryChannelClientStateResponse>;
                    fromPartial(object: Partial<_155.QueryChannelClientStateResponse>): _155.QueryChannelClientStateResponse;
                    fromProtoMsg(message: _155.QueryChannelClientStateResponseProtoMsg): _155.QueryChannelClientStateResponse;
                    toProto(message: _155.QueryChannelClientStateResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelClientStateResponse): _155.QueryChannelClientStateResponseProtoMsg;
                };
                QueryChannelConsensusStateRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelConsensusStateRequest";
                    encode(message: _155.QueryChannelConsensusStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelConsensusStateRequest;
                    fromJSON(object: any): _155.QueryChannelConsensusStateRequest;
                    toJSON(message: _155.QueryChannelConsensusStateRequest): import("../json-safe.ts").JsonSafe<_155.QueryChannelConsensusStateRequest>;
                    fromPartial(object: Partial<_155.QueryChannelConsensusStateRequest>): _155.QueryChannelConsensusStateRequest;
                    fromProtoMsg(message: _155.QueryChannelConsensusStateRequestProtoMsg): _155.QueryChannelConsensusStateRequest;
                    toProto(message: _155.QueryChannelConsensusStateRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelConsensusStateRequest): _155.QueryChannelConsensusStateRequestProtoMsg;
                };
                QueryChannelConsensusStateResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelConsensusStateResponse";
                    encode(message: _155.QueryChannelConsensusStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelConsensusStateResponse;
                    fromJSON(object: any): _155.QueryChannelConsensusStateResponse;
                    toJSON(message: _155.QueryChannelConsensusStateResponse): import("../json-safe.ts").JsonSafe<_155.QueryChannelConsensusStateResponse>;
                    fromPartial(object: Partial<_155.QueryChannelConsensusStateResponse>): _155.QueryChannelConsensusStateResponse;
                    fromProtoMsg(message: _155.QueryChannelConsensusStateResponseProtoMsg): _155.QueryChannelConsensusStateResponse;
                    toProto(message: _155.QueryChannelConsensusStateResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelConsensusStateResponse): _155.QueryChannelConsensusStateResponseProtoMsg;
                };
                QueryPacketCommitmentRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketCommitmentRequest";
                    encode(message: _155.QueryPacketCommitmentRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketCommitmentRequest;
                    fromJSON(object: any): _155.QueryPacketCommitmentRequest;
                    toJSON(message: _155.QueryPacketCommitmentRequest): import("../json-safe.ts").JsonSafe<_155.QueryPacketCommitmentRequest>;
                    fromPartial(object: Partial<_155.QueryPacketCommitmentRequest>): _155.QueryPacketCommitmentRequest;
                    fromProtoMsg(message: _155.QueryPacketCommitmentRequestProtoMsg): _155.QueryPacketCommitmentRequest;
                    toProto(message: _155.QueryPacketCommitmentRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketCommitmentRequest): _155.QueryPacketCommitmentRequestProtoMsg;
                };
                QueryPacketCommitmentResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketCommitmentResponse";
                    encode(message: _155.QueryPacketCommitmentResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketCommitmentResponse;
                    fromJSON(object: any): _155.QueryPacketCommitmentResponse;
                    toJSON(message: _155.QueryPacketCommitmentResponse): import("../json-safe.ts").JsonSafe<_155.QueryPacketCommitmentResponse>;
                    fromPartial(object: Partial<_155.QueryPacketCommitmentResponse>): _155.QueryPacketCommitmentResponse;
                    fromProtoMsg(message: _155.QueryPacketCommitmentResponseProtoMsg): _155.QueryPacketCommitmentResponse;
                    toProto(message: _155.QueryPacketCommitmentResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketCommitmentResponse): _155.QueryPacketCommitmentResponseProtoMsg;
                };
                QueryPacketCommitmentsRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketCommitmentsRequest";
                    encode(message: _155.QueryPacketCommitmentsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketCommitmentsRequest;
                    fromJSON(object: any): _155.QueryPacketCommitmentsRequest;
                    toJSON(message: _155.QueryPacketCommitmentsRequest): import("../json-safe.ts").JsonSafe<_155.QueryPacketCommitmentsRequest>;
                    fromPartial(object: Partial<_155.QueryPacketCommitmentsRequest>): _155.QueryPacketCommitmentsRequest;
                    fromProtoMsg(message: _155.QueryPacketCommitmentsRequestProtoMsg): _155.QueryPacketCommitmentsRequest;
                    toProto(message: _155.QueryPacketCommitmentsRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketCommitmentsRequest): _155.QueryPacketCommitmentsRequestProtoMsg;
                };
                QueryPacketCommitmentsResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketCommitmentsResponse";
                    encode(message: _155.QueryPacketCommitmentsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketCommitmentsResponse;
                    fromJSON(object: any): _155.QueryPacketCommitmentsResponse;
                    toJSON(message: _155.QueryPacketCommitmentsResponse): import("../json-safe.ts").JsonSafe<_155.QueryPacketCommitmentsResponse>;
                    fromPartial(object: Partial<_155.QueryPacketCommitmentsResponse>): _155.QueryPacketCommitmentsResponse;
                    fromProtoMsg(message: _155.QueryPacketCommitmentsResponseProtoMsg): _155.QueryPacketCommitmentsResponse;
                    toProto(message: _155.QueryPacketCommitmentsResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketCommitmentsResponse): _155.QueryPacketCommitmentsResponseProtoMsg;
                };
                QueryPacketReceiptRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketReceiptRequest";
                    encode(message: _155.QueryPacketReceiptRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketReceiptRequest;
                    fromJSON(object: any): _155.QueryPacketReceiptRequest;
                    toJSON(message: _155.QueryPacketReceiptRequest): import("../json-safe.ts").JsonSafe<_155.QueryPacketReceiptRequest>;
                    fromPartial(object: Partial<_155.QueryPacketReceiptRequest>): _155.QueryPacketReceiptRequest;
                    fromProtoMsg(message: _155.QueryPacketReceiptRequestProtoMsg): _155.QueryPacketReceiptRequest;
                    toProto(message: _155.QueryPacketReceiptRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketReceiptRequest): _155.QueryPacketReceiptRequestProtoMsg;
                };
                QueryPacketReceiptResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketReceiptResponse";
                    encode(message: _155.QueryPacketReceiptResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketReceiptResponse;
                    fromJSON(object: any): _155.QueryPacketReceiptResponse;
                    toJSON(message: _155.QueryPacketReceiptResponse): import("../json-safe.ts").JsonSafe<_155.QueryPacketReceiptResponse>;
                    fromPartial(object: Partial<_155.QueryPacketReceiptResponse>): _155.QueryPacketReceiptResponse;
                    fromProtoMsg(message: _155.QueryPacketReceiptResponseProtoMsg): _155.QueryPacketReceiptResponse;
                    toProto(message: _155.QueryPacketReceiptResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketReceiptResponse): _155.QueryPacketReceiptResponseProtoMsg;
                };
                QueryPacketAcknowledgementRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketAcknowledgementRequest";
                    encode(message: _155.QueryPacketAcknowledgementRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketAcknowledgementRequest;
                    fromJSON(object: any): _155.QueryPacketAcknowledgementRequest;
                    toJSON(message: _155.QueryPacketAcknowledgementRequest): import("../json-safe.ts").JsonSafe<_155.QueryPacketAcknowledgementRequest>;
                    fromPartial(object: Partial<_155.QueryPacketAcknowledgementRequest>): _155.QueryPacketAcknowledgementRequest;
                    fromProtoMsg(message: _155.QueryPacketAcknowledgementRequestProtoMsg): _155.QueryPacketAcknowledgementRequest;
                    toProto(message: _155.QueryPacketAcknowledgementRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketAcknowledgementRequest): _155.QueryPacketAcknowledgementRequestProtoMsg;
                };
                QueryPacketAcknowledgementResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketAcknowledgementResponse";
                    encode(message: _155.QueryPacketAcknowledgementResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketAcknowledgementResponse;
                    fromJSON(object: any): _155.QueryPacketAcknowledgementResponse;
                    toJSON(message: _155.QueryPacketAcknowledgementResponse): import("../json-safe.ts").JsonSafe<_155.QueryPacketAcknowledgementResponse>;
                    fromPartial(object: Partial<_155.QueryPacketAcknowledgementResponse>): _155.QueryPacketAcknowledgementResponse;
                    fromProtoMsg(message: _155.QueryPacketAcknowledgementResponseProtoMsg): _155.QueryPacketAcknowledgementResponse;
                    toProto(message: _155.QueryPacketAcknowledgementResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketAcknowledgementResponse): _155.QueryPacketAcknowledgementResponseProtoMsg;
                };
                QueryPacketAcknowledgementsRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketAcknowledgementsRequest";
                    encode(message: _155.QueryPacketAcknowledgementsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketAcknowledgementsRequest;
                    fromJSON(object: any): _155.QueryPacketAcknowledgementsRequest;
                    toJSON(message: _155.QueryPacketAcknowledgementsRequest): import("../json-safe.ts").JsonSafe<_155.QueryPacketAcknowledgementsRequest>;
                    fromPartial(object: Partial<_155.QueryPacketAcknowledgementsRequest>): _155.QueryPacketAcknowledgementsRequest;
                    fromProtoMsg(message: _155.QueryPacketAcknowledgementsRequestProtoMsg): _155.QueryPacketAcknowledgementsRequest;
                    toProto(message: _155.QueryPacketAcknowledgementsRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketAcknowledgementsRequest): _155.QueryPacketAcknowledgementsRequestProtoMsg;
                };
                QueryPacketAcknowledgementsResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryPacketAcknowledgementsResponse";
                    encode(message: _155.QueryPacketAcknowledgementsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryPacketAcknowledgementsResponse;
                    fromJSON(object: any): _155.QueryPacketAcknowledgementsResponse;
                    toJSON(message: _155.QueryPacketAcknowledgementsResponse): import("../json-safe.ts").JsonSafe<_155.QueryPacketAcknowledgementsResponse>;
                    fromPartial(object: Partial<_155.QueryPacketAcknowledgementsResponse>): _155.QueryPacketAcknowledgementsResponse;
                    fromProtoMsg(message: _155.QueryPacketAcknowledgementsResponseProtoMsg): _155.QueryPacketAcknowledgementsResponse;
                    toProto(message: _155.QueryPacketAcknowledgementsResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryPacketAcknowledgementsResponse): _155.QueryPacketAcknowledgementsResponseProtoMsg;
                };
                QueryUnreceivedPacketsRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryUnreceivedPacketsRequest";
                    encode(message: _155.QueryUnreceivedPacketsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryUnreceivedPacketsRequest;
                    fromJSON(object: any): _155.QueryUnreceivedPacketsRequest;
                    toJSON(message: _155.QueryUnreceivedPacketsRequest): import("../json-safe.ts").JsonSafe<_155.QueryUnreceivedPacketsRequest>;
                    fromPartial(object: Partial<_155.QueryUnreceivedPacketsRequest>): _155.QueryUnreceivedPacketsRequest;
                    fromProtoMsg(message: _155.QueryUnreceivedPacketsRequestProtoMsg): _155.QueryUnreceivedPacketsRequest;
                    toProto(message: _155.QueryUnreceivedPacketsRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryUnreceivedPacketsRequest): _155.QueryUnreceivedPacketsRequestProtoMsg;
                };
                QueryUnreceivedPacketsResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryUnreceivedPacketsResponse";
                    encode(message: _155.QueryUnreceivedPacketsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryUnreceivedPacketsResponse;
                    fromJSON(object: any): _155.QueryUnreceivedPacketsResponse;
                    toJSON(message: _155.QueryUnreceivedPacketsResponse): import("../json-safe.ts").JsonSafe<_155.QueryUnreceivedPacketsResponse>;
                    fromPartial(object: Partial<_155.QueryUnreceivedPacketsResponse>): _155.QueryUnreceivedPacketsResponse;
                    fromProtoMsg(message: _155.QueryUnreceivedPacketsResponseProtoMsg): _155.QueryUnreceivedPacketsResponse;
                    toProto(message: _155.QueryUnreceivedPacketsResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryUnreceivedPacketsResponse): _155.QueryUnreceivedPacketsResponseProtoMsg;
                };
                QueryUnreceivedAcksRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryUnreceivedAcksRequest";
                    encode(message: _155.QueryUnreceivedAcksRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryUnreceivedAcksRequest;
                    fromJSON(object: any): _155.QueryUnreceivedAcksRequest;
                    toJSON(message: _155.QueryUnreceivedAcksRequest): import("../json-safe.ts").JsonSafe<_155.QueryUnreceivedAcksRequest>;
                    fromPartial(object: Partial<_155.QueryUnreceivedAcksRequest>): _155.QueryUnreceivedAcksRequest;
                    fromProtoMsg(message: _155.QueryUnreceivedAcksRequestProtoMsg): _155.QueryUnreceivedAcksRequest;
                    toProto(message: _155.QueryUnreceivedAcksRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryUnreceivedAcksRequest): _155.QueryUnreceivedAcksRequestProtoMsg;
                };
                QueryUnreceivedAcksResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryUnreceivedAcksResponse";
                    encode(message: _155.QueryUnreceivedAcksResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryUnreceivedAcksResponse;
                    fromJSON(object: any): _155.QueryUnreceivedAcksResponse;
                    toJSON(message: _155.QueryUnreceivedAcksResponse): import("../json-safe.ts").JsonSafe<_155.QueryUnreceivedAcksResponse>;
                    fromPartial(object: Partial<_155.QueryUnreceivedAcksResponse>): _155.QueryUnreceivedAcksResponse;
                    fromProtoMsg(message: _155.QueryUnreceivedAcksResponseProtoMsg): _155.QueryUnreceivedAcksResponse;
                    toProto(message: _155.QueryUnreceivedAcksResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryUnreceivedAcksResponse): _155.QueryUnreceivedAcksResponseProtoMsg;
                };
                QueryNextSequenceReceiveRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryNextSequenceReceiveRequest";
                    encode(message: _155.QueryNextSequenceReceiveRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryNextSequenceReceiveRequest;
                    fromJSON(object: any): _155.QueryNextSequenceReceiveRequest;
                    toJSON(message: _155.QueryNextSequenceReceiveRequest): import("../json-safe.ts").JsonSafe<_155.QueryNextSequenceReceiveRequest>;
                    fromPartial(object: Partial<_155.QueryNextSequenceReceiveRequest>): _155.QueryNextSequenceReceiveRequest;
                    fromProtoMsg(message: _155.QueryNextSequenceReceiveRequestProtoMsg): _155.QueryNextSequenceReceiveRequest;
                    toProto(message: _155.QueryNextSequenceReceiveRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryNextSequenceReceiveRequest): _155.QueryNextSequenceReceiveRequestProtoMsg;
                };
                QueryNextSequenceReceiveResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryNextSequenceReceiveResponse";
                    encode(message: _155.QueryNextSequenceReceiveResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryNextSequenceReceiveResponse;
                    fromJSON(object: any): _155.QueryNextSequenceReceiveResponse;
                    toJSON(message: _155.QueryNextSequenceReceiveResponse): import("../json-safe.ts").JsonSafe<_155.QueryNextSequenceReceiveResponse>;
                    fromPartial(object: Partial<_155.QueryNextSequenceReceiveResponse>): _155.QueryNextSequenceReceiveResponse;
                    fromProtoMsg(message: _155.QueryNextSequenceReceiveResponseProtoMsg): _155.QueryNextSequenceReceiveResponse;
                    toProto(message: _155.QueryNextSequenceReceiveResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryNextSequenceReceiveResponse): _155.QueryNextSequenceReceiveResponseProtoMsg;
                };
                QueryNextSequenceSendRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryNextSequenceSendRequest";
                    encode(message: _155.QueryNextSequenceSendRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryNextSequenceSendRequest;
                    fromJSON(object: any): _155.QueryNextSequenceSendRequest;
                    toJSON(message: _155.QueryNextSequenceSendRequest): import("../json-safe.ts").JsonSafe<_155.QueryNextSequenceSendRequest>;
                    fromPartial(object: Partial<_155.QueryNextSequenceSendRequest>): _155.QueryNextSequenceSendRequest;
                    fromProtoMsg(message: _155.QueryNextSequenceSendRequestProtoMsg): _155.QueryNextSequenceSendRequest;
                    toProto(message: _155.QueryNextSequenceSendRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryNextSequenceSendRequest): _155.QueryNextSequenceSendRequestProtoMsg;
                };
                QueryNextSequenceSendResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryNextSequenceSendResponse";
                    encode(message: _155.QueryNextSequenceSendResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryNextSequenceSendResponse;
                    fromJSON(object: any): _155.QueryNextSequenceSendResponse;
                    toJSON(message: _155.QueryNextSequenceSendResponse): import("../json-safe.ts").JsonSafe<_155.QueryNextSequenceSendResponse>;
                    fromPartial(object: Partial<_155.QueryNextSequenceSendResponse>): _155.QueryNextSequenceSendResponse;
                    fromProtoMsg(message: _155.QueryNextSequenceSendResponseProtoMsg): _155.QueryNextSequenceSendResponse;
                    toProto(message: _155.QueryNextSequenceSendResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryNextSequenceSendResponse): _155.QueryNextSequenceSendResponseProtoMsg;
                };
                QueryUpgradeErrorRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryUpgradeErrorRequest";
                    encode(message: _155.QueryUpgradeErrorRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryUpgradeErrorRequest;
                    fromJSON(object: any): _155.QueryUpgradeErrorRequest;
                    toJSON(message: _155.QueryUpgradeErrorRequest): import("../json-safe.ts").JsonSafe<_155.QueryUpgradeErrorRequest>;
                    fromPartial(object: Partial<_155.QueryUpgradeErrorRequest>): _155.QueryUpgradeErrorRequest;
                    fromProtoMsg(message: _155.QueryUpgradeErrorRequestProtoMsg): _155.QueryUpgradeErrorRequest;
                    toProto(message: _155.QueryUpgradeErrorRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryUpgradeErrorRequest): _155.QueryUpgradeErrorRequestProtoMsg;
                };
                QueryUpgradeErrorResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryUpgradeErrorResponse";
                    encode(message: _155.QueryUpgradeErrorResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryUpgradeErrorResponse;
                    fromJSON(object: any): _155.QueryUpgradeErrorResponse;
                    toJSON(message: _155.QueryUpgradeErrorResponse): import("../json-safe.ts").JsonSafe<_155.QueryUpgradeErrorResponse>;
                    fromPartial(object: Partial<_155.QueryUpgradeErrorResponse>): _155.QueryUpgradeErrorResponse;
                    fromProtoMsg(message: _155.QueryUpgradeErrorResponseProtoMsg): _155.QueryUpgradeErrorResponse;
                    toProto(message: _155.QueryUpgradeErrorResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryUpgradeErrorResponse): _155.QueryUpgradeErrorResponseProtoMsg;
                };
                QueryUpgradeRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryUpgradeRequest";
                    encode(message: _155.QueryUpgradeRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryUpgradeRequest;
                    fromJSON(object: any): _155.QueryUpgradeRequest;
                    toJSON(message: _155.QueryUpgradeRequest): import("../json-safe.ts").JsonSafe<_155.QueryUpgradeRequest>;
                    fromPartial(object: Partial<_155.QueryUpgradeRequest>): _155.QueryUpgradeRequest;
                    fromProtoMsg(message: _155.QueryUpgradeRequestProtoMsg): _155.QueryUpgradeRequest;
                    toProto(message: _155.QueryUpgradeRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryUpgradeRequest): _155.QueryUpgradeRequestProtoMsg;
                };
                QueryUpgradeResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryUpgradeResponse";
                    encode(message: _155.QueryUpgradeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryUpgradeResponse;
                    fromJSON(object: any): _155.QueryUpgradeResponse;
                    toJSON(message: _155.QueryUpgradeResponse): import("../json-safe.ts").JsonSafe<_155.QueryUpgradeResponse>;
                    fromPartial(object: Partial<_155.QueryUpgradeResponse>): _155.QueryUpgradeResponse;
                    fromProtoMsg(message: _155.QueryUpgradeResponseProtoMsg): _155.QueryUpgradeResponse;
                    toProto(message: _155.QueryUpgradeResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryUpgradeResponse): _155.QueryUpgradeResponseProtoMsg;
                };
                QueryChannelParamsRequest: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelParamsRequest";
                    encode(_: _155.QueryChannelParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelParamsRequest;
                    fromJSON(_: any): _155.QueryChannelParamsRequest;
                    toJSON(_: _155.QueryChannelParamsRequest): import("../json-safe.ts").JsonSafe<_155.QueryChannelParamsRequest>;
                    fromPartial(_: Partial<_155.QueryChannelParamsRequest>): _155.QueryChannelParamsRequest;
                    fromProtoMsg(message: _155.QueryChannelParamsRequestProtoMsg): _155.QueryChannelParamsRequest;
                    toProto(message: _155.QueryChannelParamsRequest): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelParamsRequest): _155.QueryChannelParamsRequestProtoMsg;
                };
                QueryChannelParamsResponse: {
                    typeUrl: "/ibc.core.channel.v1.QueryChannelParamsResponse";
                    encode(message: _155.QueryChannelParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _155.QueryChannelParamsResponse;
                    fromJSON(object: any): _155.QueryChannelParamsResponse;
                    toJSON(message: _155.QueryChannelParamsResponse): import("../json-safe.ts").JsonSafe<_155.QueryChannelParamsResponse>;
                    fromPartial(object: Partial<_155.QueryChannelParamsResponse>): _155.QueryChannelParamsResponse;
                    fromProtoMsg(message: _155.QueryChannelParamsResponseProtoMsg): _155.QueryChannelParamsResponse;
                    toProto(message: _155.QueryChannelParamsResponse): Uint8Array;
                    toProtoMsg(message: _155.QueryChannelParamsResponse): _155.QueryChannelParamsResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: "/ibc.core.channel.v1.GenesisState";
                    encode(message: _154.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _154.GenesisState;
                    fromJSON(object: any): _154.GenesisState;
                    toJSON(message: _154.GenesisState): import("../json-safe.ts").JsonSafe<_154.GenesisState>;
                    fromPartial(object: Partial<_154.GenesisState>): _154.GenesisState;
                    fromProtoMsg(message: _154.GenesisStateProtoMsg): _154.GenesisState;
                    toProto(message: _154.GenesisState): Uint8Array;
                    toProtoMsg(message: _154.GenesisState): _154.GenesisStateProtoMsg;
                };
                PacketSequence: {
                    typeUrl: "/ibc.core.channel.v1.PacketSequence";
                    encode(message: _154.PacketSequence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _154.PacketSequence;
                    fromJSON(object: any): _154.PacketSequence;
                    toJSON(message: _154.PacketSequence): import("../json-safe.ts").JsonSafe<_154.PacketSequence>;
                    fromPartial(object: Partial<_154.PacketSequence>): _154.PacketSequence;
                    fromProtoMsg(message: _154.PacketSequenceProtoMsg): _154.PacketSequence;
                    toProto(message: _154.PacketSequence): Uint8Array;
                    toProtoMsg(message: _154.PacketSequence): _154.PacketSequenceProtoMsg;
                };
                stateFromJSON(object: any): _153.State;
                stateToJSON(object: _153.State): string;
                orderFromJSON(object: any): _153.Order;
                orderToJSON(object: _153.Order): string;
                State: typeof _153.State;
                StateSDKType: typeof _153.State;
                Order: typeof _153.Order;
                OrderSDKType: typeof _153.Order;
                Channel: {
                    typeUrl: "/ibc.core.channel.v1.Channel";
                    encode(message: _153.Channel, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Channel;
                    fromJSON(object: any): _153.Channel;
                    toJSON(message: _153.Channel): import("../json-safe.ts").JsonSafe<_153.Channel>;
                    fromPartial(object: Partial<_153.Channel>): _153.Channel;
                    fromProtoMsg(message: _153.ChannelProtoMsg): _153.Channel;
                    toProto(message: _153.Channel): Uint8Array;
                    toProtoMsg(message: _153.Channel): _153.ChannelProtoMsg;
                };
                IdentifiedChannel: {
                    typeUrl: "/ibc.core.channel.v1.IdentifiedChannel";
                    encode(message: _153.IdentifiedChannel, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.IdentifiedChannel;
                    fromJSON(object: any): _153.IdentifiedChannel;
                    toJSON(message: _153.IdentifiedChannel): import("../json-safe.ts").JsonSafe<_153.IdentifiedChannel>;
                    fromPartial(object: Partial<_153.IdentifiedChannel>): _153.IdentifiedChannel;
                    fromProtoMsg(message: _153.IdentifiedChannelProtoMsg): _153.IdentifiedChannel;
                    toProto(message: _153.IdentifiedChannel): Uint8Array;
                    toProtoMsg(message: _153.IdentifiedChannel): _153.IdentifiedChannelProtoMsg;
                };
                Counterparty: {
                    typeUrl: "/ibc.core.channel.v1.Counterparty";
                    encode(message: _153.Counterparty, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Counterparty;
                    fromJSON(object: any): _153.Counterparty;
                    toJSON(message: _153.Counterparty): import("../json-safe.ts").JsonSafe<_153.Counterparty>;
                    fromPartial(object: Partial<_153.Counterparty>): _153.Counterparty;
                    fromProtoMsg(message: _153.CounterpartyProtoMsg): _153.Counterparty;
                    toProto(message: _153.Counterparty): Uint8Array;
                    toProtoMsg(message: _153.Counterparty): _153.CounterpartyProtoMsg;
                };
                Packet: {
                    typeUrl: "/ibc.core.channel.v1.Packet";
                    encode(message: _153.Packet, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Packet;
                    fromJSON(object: any): _153.Packet;
                    toJSON(message: _153.Packet): import("../json-safe.ts").JsonSafe<_153.Packet>;
                    fromPartial(object: Partial<_153.Packet>): _153.Packet;
                    fromProtoMsg(message: _153.PacketProtoMsg): _153.Packet;
                    toProto(message: _153.Packet): Uint8Array;
                    toProtoMsg(message: _153.Packet): _153.PacketProtoMsg;
                };
                PacketState: {
                    typeUrl: "/ibc.core.channel.v1.PacketState";
                    encode(message: _153.PacketState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.PacketState;
                    fromJSON(object: any): _153.PacketState;
                    toJSON(message: _153.PacketState): import("../json-safe.ts").JsonSafe<_153.PacketState>;
                    fromPartial(object: Partial<_153.PacketState>): _153.PacketState;
                    fromProtoMsg(message: _153.PacketStateProtoMsg): _153.PacketState;
                    toProto(message: _153.PacketState): Uint8Array;
                    toProtoMsg(message: _153.PacketState): _153.PacketStateProtoMsg;
                };
                PacketId: {
                    typeUrl: "/ibc.core.channel.v1.PacketId";
                    encode(message: _153.PacketId, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.PacketId;
                    fromJSON(object: any): _153.PacketId;
                    toJSON(message: _153.PacketId): import("../json-safe.ts").JsonSafe<_153.PacketId>;
                    fromPartial(object: Partial<_153.PacketId>): _153.PacketId;
                    fromProtoMsg(message: _153.PacketIdProtoMsg): _153.PacketId;
                    toProto(message: _153.PacketId): Uint8Array;
                    toProtoMsg(message: _153.PacketId): _153.PacketIdProtoMsg;
                };
                Acknowledgement: {
                    typeUrl: "/ibc.core.channel.v1.Acknowledgement";
                    encode(message: _153.Acknowledgement, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Acknowledgement;
                    fromJSON(object: any): _153.Acknowledgement;
                    toJSON(message: _153.Acknowledgement): import("../json-safe.ts").JsonSafe<_153.Acknowledgement>;
                    fromPartial(object: Partial<_153.Acknowledgement>): _153.Acknowledgement;
                    fromProtoMsg(message: _153.AcknowledgementProtoMsg): _153.Acknowledgement;
                    toProto(message: _153.Acknowledgement): Uint8Array;
                    toProtoMsg(message: _153.Acknowledgement): _153.AcknowledgementProtoMsg;
                };
                Timeout: {
                    typeUrl: "/ibc.core.channel.v1.Timeout";
                    encode(message: _153.Timeout, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Timeout;
                    fromJSON(object: any): _153.Timeout;
                    toJSON(message: _153.Timeout): import("../json-safe.ts").JsonSafe<_153.Timeout>;
                    fromPartial(object: Partial<_153.Timeout>): _153.Timeout;
                    fromProtoMsg(message: _153.TimeoutProtoMsg): _153.Timeout;
                    toProto(message: _153.Timeout): Uint8Array;
                    toProtoMsg(message: _153.Timeout): _153.TimeoutProtoMsg;
                };
                Params: {
                    typeUrl: "/ibc.core.channel.v1.Params";
                    encode(message: _153.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _153.Params;
                    fromJSON(object: any): _153.Params;
                    toJSON(message: _153.Params): import("../json-safe.ts").JsonSafe<_153.Params>;
                    fromPartial(object: Partial<_153.Params>): _153.Params;
                    fromProtoMsg(message: _153.ParamsProtoMsg): _153.Params;
                    toProto(message: _153.Params): Uint8Array;
                    toProtoMsg(message: _153.Params): _153.ParamsProtoMsg;
                };
            };
        }
        namespace client {
            const v1: {
                MsgCreateClient: {
                    typeUrl: "/ibc.core.client.v1.MsgCreateClient";
                    encode(message: _161.MsgCreateClient, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgCreateClient;
                    fromJSON(object: any): _161.MsgCreateClient;
                    toJSON(message: _161.MsgCreateClient): import("../json-safe.ts").JsonSafe<_161.MsgCreateClient>;
                    fromPartial(object: Partial<_161.MsgCreateClient>): _161.MsgCreateClient;
                    fromProtoMsg(message: _161.MsgCreateClientProtoMsg): _161.MsgCreateClient;
                    toProto(message: _161.MsgCreateClient): Uint8Array;
                    toProtoMsg(message: _161.MsgCreateClient): _161.MsgCreateClientProtoMsg;
                };
                MsgCreateClientResponse: {
                    typeUrl: "/ibc.core.client.v1.MsgCreateClientResponse";
                    encode(_: _161.MsgCreateClientResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgCreateClientResponse;
                    fromJSON(_: any): _161.MsgCreateClientResponse;
                    toJSON(_: _161.MsgCreateClientResponse): import("../json-safe.ts").JsonSafe<_161.MsgCreateClientResponse>;
                    fromPartial(_: Partial<_161.MsgCreateClientResponse>): _161.MsgCreateClientResponse;
                    fromProtoMsg(message: _161.MsgCreateClientResponseProtoMsg): _161.MsgCreateClientResponse;
                    toProto(message: _161.MsgCreateClientResponse): Uint8Array;
                    toProtoMsg(message: _161.MsgCreateClientResponse): _161.MsgCreateClientResponseProtoMsg;
                };
                MsgUpdateClient: {
                    typeUrl: "/ibc.core.client.v1.MsgUpdateClient";
                    encode(message: _161.MsgUpdateClient, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgUpdateClient;
                    fromJSON(object: any): _161.MsgUpdateClient;
                    toJSON(message: _161.MsgUpdateClient): import("../json-safe.ts").JsonSafe<_161.MsgUpdateClient>;
                    fromPartial(object: Partial<_161.MsgUpdateClient>): _161.MsgUpdateClient;
                    fromProtoMsg(message: _161.MsgUpdateClientProtoMsg): _161.MsgUpdateClient;
                    toProto(message: _161.MsgUpdateClient): Uint8Array;
                    toProtoMsg(message: _161.MsgUpdateClient): _161.MsgUpdateClientProtoMsg;
                };
                MsgUpdateClientResponse: {
                    typeUrl: "/ibc.core.client.v1.MsgUpdateClientResponse";
                    encode(_: _161.MsgUpdateClientResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgUpdateClientResponse;
                    fromJSON(_: any): _161.MsgUpdateClientResponse;
                    toJSON(_: _161.MsgUpdateClientResponse): import("../json-safe.ts").JsonSafe<_161.MsgUpdateClientResponse>;
                    fromPartial(_: Partial<_161.MsgUpdateClientResponse>): _161.MsgUpdateClientResponse;
                    fromProtoMsg(message: _161.MsgUpdateClientResponseProtoMsg): _161.MsgUpdateClientResponse;
                    toProto(message: _161.MsgUpdateClientResponse): Uint8Array;
                    toProtoMsg(message: _161.MsgUpdateClientResponse): _161.MsgUpdateClientResponseProtoMsg;
                };
                MsgUpgradeClient: {
                    typeUrl: "/ibc.core.client.v1.MsgUpgradeClient";
                    encode(message: _161.MsgUpgradeClient, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgUpgradeClient;
                    fromJSON(object: any): _161.MsgUpgradeClient;
                    toJSON(message: _161.MsgUpgradeClient): import("../json-safe.ts").JsonSafe<_161.MsgUpgradeClient>;
                    fromPartial(object: Partial<_161.MsgUpgradeClient>): _161.MsgUpgradeClient;
                    fromProtoMsg(message: _161.MsgUpgradeClientProtoMsg): _161.MsgUpgradeClient;
                    toProto(message: _161.MsgUpgradeClient): Uint8Array;
                    toProtoMsg(message: _161.MsgUpgradeClient): _161.MsgUpgradeClientProtoMsg;
                };
                MsgUpgradeClientResponse: {
                    typeUrl: "/ibc.core.client.v1.MsgUpgradeClientResponse";
                    encode(_: _161.MsgUpgradeClientResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgUpgradeClientResponse;
                    fromJSON(_: any): _161.MsgUpgradeClientResponse;
                    toJSON(_: _161.MsgUpgradeClientResponse): import("../json-safe.ts").JsonSafe<_161.MsgUpgradeClientResponse>;
                    fromPartial(_: Partial<_161.MsgUpgradeClientResponse>): _161.MsgUpgradeClientResponse;
                    fromProtoMsg(message: _161.MsgUpgradeClientResponseProtoMsg): _161.MsgUpgradeClientResponse;
                    toProto(message: _161.MsgUpgradeClientResponse): Uint8Array;
                    toProtoMsg(message: _161.MsgUpgradeClientResponse): _161.MsgUpgradeClientResponseProtoMsg;
                };
                MsgSubmitMisbehaviour: {
                    typeUrl: "/ibc.core.client.v1.MsgSubmitMisbehaviour";
                    encode(message: _161.MsgSubmitMisbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgSubmitMisbehaviour;
                    fromJSON(object: any): _161.MsgSubmitMisbehaviour;
                    toJSON(message: _161.MsgSubmitMisbehaviour): import("../json-safe.ts").JsonSafe<_161.MsgSubmitMisbehaviour>;
                    fromPartial(object: Partial<_161.MsgSubmitMisbehaviour>): _161.MsgSubmitMisbehaviour;
                    fromProtoMsg(message: _161.MsgSubmitMisbehaviourProtoMsg): _161.MsgSubmitMisbehaviour;
                    toProto(message: _161.MsgSubmitMisbehaviour): Uint8Array;
                    toProtoMsg(message: _161.MsgSubmitMisbehaviour): _161.MsgSubmitMisbehaviourProtoMsg;
                };
                MsgSubmitMisbehaviourResponse: {
                    typeUrl: "/ibc.core.client.v1.MsgSubmitMisbehaviourResponse";
                    encode(_: _161.MsgSubmitMisbehaviourResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgSubmitMisbehaviourResponse;
                    fromJSON(_: any): _161.MsgSubmitMisbehaviourResponse;
                    toJSON(_: _161.MsgSubmitMisbehaviourResponse): import("../json-safe.ts").JsonSafe<_161.MsgSubmitMisbehaviourResponse>;
                    fromPartial(_: Partial<_161.MsgSubmitMisbehaviourResponse>): _161.MsgSubmitMisbehaviourResponse;
                    fromProtoMsg(message: _161.MsgSubmitMisbehaviourResponseProtoMsg): _161.MsgSubmitMisbehaviourResponse;
                    toProto(message: _161.MsgSubmitMisbehaviourResponse): Uint8Array;
                    toProtoMsg(message: _161.MsgSubmitMisbehaviourResponse): _161.MsgSubmitMisbehaviourResponseProtoMsg;
                };
                MsgRecoverClient: {
                    typeUrl: "/ibc.core.client.v1.MsgRecoverClient";
                    encode(message: _161.MsgRecoverClient, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgRecoverClient;
                    fromJSON(object: any): _161.MsgRecoverClient;
                    toJSON(message: _161.MsgRecoverClient): import("../json-safe.ts").JsonSafe<_161.MsgRecoverClient>;
                    fromPartial(object: Partial<_161.MsgRecoverClient>): _161.MsgRecoverClient;
                    fromProtoMsg(message: _161.MsgRecoverClientProtoMsg): _161.MsgRecoverClient;
                    toProto(message: _161.MsgRecoverClient): Uint8Array;
                    toProtoMsg(message: _161.MsgRecoverClient): _161.MsgRecoverClientProtoMsg;
                };
                MsgRecoverClientResponse: {
                    typeUrl: "/ibc.core.client.v1.MsgRecoverClientResponse";
                    encode(_: _161.MsgRecoverClientResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgRecoverClientResponse;
                    fromJSON(_: any): _161.MsgRecoverClientResponse;
                    toJSON(_: _161.MsgRecoverClientResponse): import("../json-safe.ts").JsonSafe<_161.MsgRecoverClientResponse>;
                    fromPartial(_: Partial<_161.MsgRecoverClientResponse>): _161.MsgRecoverClientResponse;
                    fromProtoMsg(message: _161.MsgRecoverClientResponseProtoMsg): _161.MsgRecoverClientResponse;
                    toProto(message: _161.MsgRecoverClientResponse): Uint8Array;
                    toProtoMsg(message: _161.MsgRecoverClientResponse): _161.MsgRecoverClientResponseProtoMsg;
                };
                MsgIBCSoftwareUpgrade: {
                    typeUrl: "/ibc.core.client.v1.MsgIBCSoftwareUpgrade";
                    encode(message: _161.MsgIBCSoftwareUpgrade, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgIBCSoftwareUpgrade;
                    fromJSON(object: any): _161.MsgIBCSoftwareUpgrade;
                    toJSON(message: _161.MsgIBCSoftwareUpgrade): import("../json-safe.ts").JsonSafe<_161.MsgIBCSoftwareUpgrade>;
                    fromPartial(object: Partial<_161.MsgIBCSoftwareUpgrade>): _161.MsgIBCSoftwareUpgrade;
                    fromProtoMsg(message: _161.MsgIBCSoftwareUpgradeProtoMsg): _161.MsgIBCSoftwareUpgrade;
                    toProto(message: _161.MsgIBCSoftwareUpgrade): Uint8Array;
                    toProtoMsg(message: _161.MsgIBCSoftwareUpgrade): _161.MsgIBCSoftwareUpgradeProtoMsg;
                };
                MsgIBCSoftwareUpgradeResponse: {
                    typeUrl: "/ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse";
                    encode(_: _161.MsgIBCSoftwareUpgradeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgIBCSoftwareUpgradeResponse;
                    fromJSON(_: any): _161.MsgIBCSoftwareUpgradeResponse;
                    toJSON(_: _161.MsgIBCSoftwareUpgradeResponse): import("../json-safe.ts").JsonSafe<_161.MsgIBCSoftwareUpgradeResponse>;
                    fromPartial(_: Partial<_161.MsgIBCSoftwareUpgradeResponse>): _161.MsgIBCSoftwareUpgradeResponse;
                    fromProtoMsg(message: _161.MsgIBCSoftwareUpgradeResponseProtoMsg): _161.MsgIBCSoftwareUpgradeResponse;
                    toProto(message: _161.MsgIBCSoftwareUpgradeResponse): Uint8Array;
                    toProtoMsg(message: _161.MsgIBCSoftwareUpgradeResponse): _161.MsgIBCSoftwareUpgradeResponseProtoMsg;
                };
                MsgUpdateParams: {
                    typeUrl: "/ibc.core.client.v1.MsgUpdateParams";
                    encode(message: _161.MsgUpdateParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgUpdateParams;
                    fromJSON(object: any): _161.MsgUpdateParams;
                    toJSON(message: _161.MsgUpdateParams): import("../json-safe.ts").JsonSafe<_161.MsgUpdateParams>;
                    fromPartial(object: Partial<_161.MsgUpdateParams>): _161.MsgUpdateParams;
                    fromProtoMsg(message: _161.MsgUpdateParamsProtoMsg): _161.MsgUpdateParams;
                    toProto(message: _161.MsgUpdateParams): Uint8Array;
                    toProtoMsg(message: _161.MsgUpdateParams): _161.MsgUpdateParamsProtoMsg;
                };
                MsgUpdateParamsResponse: {
                    typeUrl: "/ibc.core.client.v1.MsgUpdateParamsResponse";
                    encode(_: _161.MsgUpdateParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _161.MsgUpdateParamsResponse;
                    fromJSON(_: any): _161.MsgUpdateParamsResponse;
                    toJSON(_: _161.MsgUpdateParamsResponse): import("../json-safe.ts").JsonSafe<_161.MsgUpdateParamsResponse>;
                    fromPartial(_: Partial<_161.MsgUpdateParamsResponse>): _161.MsgUpdateParamsResponse;
                    fromProtoMsg(message: _161.MsgUpdateParamsResponseProtoMsg): _161.MsgUpdateParamsResponse;
                    toProto(message: _161.MsgUpdateParamsResponse): Uint8Array;
                    toProtoMsg(message: _161.MsgUpdateParamsResponse): _161.MsgUpdateParamsResponseProtoMsg;
                };
                QueryClientStateRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryClientStateRequest";
                    encode(message: _160.QueryClientStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryClientStateRequest;
                    fromJSON(object: any): _160.QueryClientStateRequest;
                    toJSON(message: _160.QueryClientStateRequest): import("../json-safe.ts").JsonSafe<_160.QueryClientStateRequest>;
                    fromPartial(object: Partial<_160.QueryClientStateRequest>): _160.QueryClientStateRequest;
                    fromProtoMsg(message: _160.QueryClientStateRequestProtoMsg): _160.QueryClientStateRequest;
                    toProto(message: _160.QueryClientStateRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryClientStateRequest): _160.QueryClientStateRequestProtoMsg;
                };
                QueryClientStateResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryClientStateResponse";
                    encode(message: _160.QueryClientStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryClientStateResponse;
                    fromJSON(object: any): _160.QueryClientStateResponse;
                    toJSON(message: _160.QueryClientStateResponse): import("../json-safe.ts").JsonSafe<_160.QueryClientStateResponse>;
                    fromPartial(object: Partial<_160.QueryClientStateResponse>): _160.QueryClientStateResponse;
                    fromProtoMsg(message: _160.QueryClientStateResponseProtoMsg): _160.QueryClientStateResponse;
                    toProto(message: _160.QueryClientStateResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryClientStateResponse): _160.QueryClientStateResponseProtoMsg;
                };
                QueryClientStatesRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryClientStatesRequest";
                    encode(message: _160.QueryClientStatesRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryClientStatesRequest;
                    fromJSON(object: any): _160.QueryClientStatesRequest;
                    toJSON(message: _160.QueryClientStatesRequest): import("../json-safe.ts").JsonSafe<_160.QueryClientStatesRequest>;
                    fromPartial(object: Partial<_160.QueryClientStatesRequest>): _160.QueryClientStatesRequest;
                    fromProtoMsg(message: _160.QueryClientStatesRequestProtoMsg): _160.QueryClientStatesRequest;
                    toProto(message: _160.QueryClientStatesRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryClientStatesRequest): _160.QueryClientStatesRequestProtoMsg;
                };
                QueryClientStatesResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryClientStatesResponse";
                    encode(message: _160.QueryClientStatesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryClientStatesResponse;
                    fromJSON(object: any): _160.QueryClientStatesResponse;
                    toJSON(message: _160.QueryClientStatesResponse): import("../json-safe.ts").JsonSafe<_160.QueryClientStatesResponse>;
                    fromPartial(object: Partial<_160.QueryClientStatesResponse>): _160.QueryClientStatesResponse;
                    fromProtoMsg(message: _160.QueryClientStatesResponseProtoMsg): _160.QueryClientStatesResponse;
                    toProto(message: _160.QueryClientStatesResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryClientStatesResponse): _160.QueryClientStatesResponseProtoMsg;
                };
                QueryConsensusStateRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryConsensusStateRequest";
                    encode(message: _160.QueryConsensusStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryConsensusStateRequest;
                    fromJSON(object: any): _160.QueryConsensusStateRequest;
                    toJSON(message: _160.QueryConsensusStateRequest): import("../json-safe.ts").JsonSafe<_160.QueryConsensusStateRequest>;
                    fromPartial(object: Partial<_160.QueryConsensusStateRequest>): _160.QueryConsensusStateRequest;
                    fromProtoMsg(message: _160.QueryConsensusStateRequestProtoMsg): _160.QueryConsensusStateRequest;
                    toProto(message: _160.QueryConsensusStateRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryConsensusStateRequest): _160.QueryConsensusStateRequestProtoMsg;
                };
                QueryConsensusStateResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryConsensusStateResponse";
                    encode(message: _160.QueryConsensusStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryConsensusStateResponse;
                    fromJSON(object: any): _160.QueryConsensusStateResponse;
                    toJSON(message: _160.QueryConsensusStateResponse): import("../json-safe.ts").JsonSafe<_160.QueryConsensusStateResponse>;
                    fromPartial(object: Partial<_160.QueryConsensusStateResponse>): _160.QueryConsensusStateResponse;
                    fromProtoMsg(message: _160.QueryConsensusStateResponseProtoMsg): _160.QueryConsensusStateResponse;
                    toProto(message: _160.QueryConsensusStateResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryConsensusStateResponse): _160.QueryConsensusStateResponseProtoMsg;
                };
                QueryConsensusStatesRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryConsensusStatesRequest";
                    encode(message: _160.QueryConsensusStatesRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryConsensusStatesRequest;
                    fromJSON(object: any): _160.QueryConsensusStatesRequest;
                    toJSON(message: _160.QueryConsensusStatesRequest): import("../json-safe.ts").JsonSafe<_160.QueryConsensusStatesRequest>;
                    fromPartial(object: Partial<_160.QueryConsensusStatesRequest>): _160.QueryConsensusStatesRequest;
                    fromProtoMsg(message: _160.QueryConsensusStatesRequestProtoMsg): _160.QueryConsensusStatesRequest;
                    toProto(message: _160.QueryConsensusStatesRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryConsensusStatesRequest): _160.QueryConsensusStatesRequestProtoMsg;
                };
                QueryConsensusStatesResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryConsensusStatesResponse";
                    encode(message: _160.QueryConsensusStatesResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryConsensusStatesResponse;
                    fromJSON(object: any): _160.QueryConsensusStatesResponse;
                    toJSON(message: _160.QueryConsensusStatesResponse): import("../json-safe.ts").JsonSafe<_160.QueryConsensusStatesResponse>;
                    fromPartial(object: Partial<_160.QueryConsensusStatesResponse>): _160.QueryConsensusStatesResponse;
                    fromProtoMsg(message: _160.QueryConsensusStatesResponseProtoMsg): _160.QueryConsensusStatesResponse;
                    toProto(message: _160.QueryConsensusStatesResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryConsensusStatesResponse): _160.QueryConsensusStatesResponseProtoMsg;
                };
                QueryConsensusStateHeightsRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryConsensusStateHeightsRequest";
                    encode(message: _160.QueryConsensusStateHeightsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryConsensusStateHeightsRequest;
                    fromJSON(object: any): _160.QueryConsensusStateHeightsRequest;
                    toJSON(message: _160.QueryConsensusStateHeightsRequest): import("../json-safe.ts").JsonSafe<_160.QueryConsensusStateHeightsRequest>;
                    fromPartial(object: Partial<_160.QueryConsensusStateHeightsRequest>): _160.QueryConsensusStateHeightsRequest;
                    fromProtoMsg(message: _160.QueryConsensusStateHeightsRequestProtoMsg): _160.QueryConsensusStateHeightsRequest;
                    toProto(message: _160.QueryConsensusStateHeightsRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryConsensusStateHeightsRequest): _160.QueryConsensusStateHeightsRequestProtoMsg;
                };
                QueryConsensusStateHeightsResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryConsensusStateHeightsResponse";
                    encode(message: _160.QueryConsensusStateHeightsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryConsensusStateHeightsResponse;
                    fromJSON(object: any): _160.QueryConsensusStateHeightsResponse;
                    toJSON(message: _160.QueryConsensusStateHeightsResponse): import("../json-safe.ts").JsonSafe<_160.QueryConsensusStateHeightsResponse>;
                    fromPartial(object: Partial<_160.QueryConsensusStateHeightsResponse>): _160.QueryConsensusStateHeightsResponse;
                    fromProtoMsg(message: _160.QueryConsensusStateHeightsResponseProtoMsg): _160.QueryConsensusStateHeightsResponse;
                    toProto(message: _160.QueryConsensusStateHeightsResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryConsensusStateHeightsResponse): _160.QueryConsensusStateHeightsResponseProtoMsg;
                };
                QueryClientStatusRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryClientStatusRequest";
                    encode(message: _160.QueryClientStatusRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryClientStatusRequest;
                    fromJSON(object: any): _160.QueryClientStatusRequest;
                    toJSON(message: _160.QueryClientStatusRequest): import("../json-safe.ts").JsonSafe<_160.QueryClientStatusRequest>;
                    fromPartial(object: Partial<_160.QueryClientStatusRequest>): _160.QueryClientStatusRequest;
                    fromProtoMsg(message: _160.QueryClientStatusRequestProtoMsg): _160.QueryClientStatusRequest;
                    toProto(message: _160.QueryClientStatusRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryClientStatusRequest): _160.QueryClientStatusRequestProtoMsg;
                };
                QueryClientStatusResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryClientStatusResponse";
                    encode(message: _160.QueryClientStatusResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryClientStatusResponse;
                    fromJSON(object: any): _160.QueryClientStatusResponse;
                    toJSON(message: _160.QueryClientStatusResponse): import("../json-safe.ts").JsonSafe<_160.QueryClientStatusResponse>;
                    fromPartial(object: Partial<_160.QueryClientStatusResponse>): _160.QueryClientStatusResponse;
                    fromProtoMsg(message: _160.QueryClientStatusResponseProtoMsg): _160.QueryClientStatusResponse;
                    toProto(message: _160.QueryClientStatusResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryClientStatusResponse): _160.QueryClientStatusResponseProtoMsg;
                };
                QueryClientParamsRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryClientParamsRequest";
                    encode(_: _160.QueryClientParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryClientParamsRequest;
                    fromJSON(_: any): _160.QueryClientParamsRequest;
                    toJSON(_: _160.QueryClientParamsRequest): import("../json-safe.ts").JsonSafe<_160.QueryClientParamsRequest>;
                    fromPartial(_: Partial<_160.QueryClientParamsRequest>): _160.QueryClientParamsRequest;
                    fromProtoMsg(message: _160.QueryClientParamsRequestProtoMsg): _160.QueryClientParamsRequest;
                    toProto(message: _160.QueryClientParamsRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryClientParamsRequest): _160.QueryClientParamsRequestProtoMsg;
                };
                QueryClientParamsResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryClientParamsResponse";
                    encode(message: _160.QueryClientParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryClientParamsResponse;
                    fromJSON(object: any): _160.QueryClientParamsResponse;
                    toJSON(message: _160.QueryClientParamsResponse): import("../json-safe.ts").JsonSafe<_160.QueryClientParamsResponse>;
                    fromPartial(object: Partial<_160.QueryClientParamsResponse>): _160.QueryClientParamsResponse;
                    fromProtoMsg(message: _160.QueryClientParamsResponseProtoMsg): _160.QueryClientParamsResponse;
                    toProto(message: _160.QueryClientParamsResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryClientParamsResponse): _160.QueryClientParamsResponseProtoMsg;
                };
                QueryUpgradedClientStateRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryUpgradedClientStateRequest";
                    encode(_: _160.QueryUpgradedClientStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryUpgradedClientStateRequest;
                    fromJSON(_: any): _160.QueryUpgradedClientStateRequest;
                    toJSON(_: _160.QueryUpgradedClientStateRequest): import("../json-safe.ts").JsonSafe<_160.QueryUpgradedClientStateRequest>;
                    fromPartial(_: Partial<_160.QueryUpgradedClientStateRequest>): _160.QueryUpgradedClientStateRequest;
                    fromProtoMsg(message: _160.QueryUpgradedClientStateRequestProtoMsg): _160.QueryUpgradedClientStateRequest;
                    toProto(message: _160.QueryUpgradedClientStateRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryUpgradedClientStateRequest): _160.QueryUpgradedClientStateRequestProtoMsg;
                };
                QueryUpgradedClientStateResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryUpgradedClientStateResponse";
                    encode(message: _160.QueryUpgradedClientStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryUpgradedClientStateResponse;
                    fromJSON(object: any): _160.QueryUpgradedClientStateResponse;
                    toJSON(message: _160.QueryUpgradedClientStateResponse): import("../json-safe.ts").JsonSafe<_160.QueryUpgradedClientStateResponse>;
                    fromPartial(object: Partial<_160.QueryUpgradedClientStateResponse>): _160.QueryUpgradedClientStateResponse;
                    fromProtoMsg(message: _160.QueryUpgradedClientStateResponseProtoMsg): _160.QueryUpgradedClientStateResponse;
                    toProto(message: _160.QueryUpgradedClientStateResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryUpgradedClientStateResponse): _160.QueryUpgradedClientStateResponseProtoMsg;
                };
                QueryUpgradedConsensusStateRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryUpgradedConsensusStateRequest";
                    encode(_: _160.QueryUpgradedConsensusStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryUpgradedConsensusStateRequest;
                    fromJSON(_: any): _160.QueryUpgradedConsensusStateRequest;
                    toJSON(_: _160.QueryUpgradedConsensusStateRequest): import("../json-safe.ts").JsonSafe<_160.QueryUpgradedConsensusStateRequest>;
                    fromPartial(_: Partial<_160.QueryUpgradedConsensusStateRequest>): _160.QueryUpgradedConsensusStateRequest;
                    fromProtoMsg(message: _160.QueryUpgradedConsensusStateRequestProtoMsg): _160.QueryUpgradedConsensusStateRequest;
                    toProto(message: _160.QueryUpgradedConsensusStateRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryUpgradedConsensusStateRequest): _160.QueryUpgradedConsensusStateRequestProtoMsg;
                };
                QueryUpgradedConsensusStateResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryUpgradedConsensusStateResponse";
                    encode(message: _160.QueryUpgradedConsensusStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryUpgradedConsensusStateResponse;
                    fromJSON(object: any): _160.QueryUpgradedConsensusStateResponse;
                    toJSON(message: _160.QueryUpgradedConsensusStateResponse): import("../json-safe.ts").JsonSafe<_160.QueryUpgradedConsensusStateResponse>;
                    fromPartial(object: Partial<_160.QueryUpgradedConsensusStateResponse>): _160.QueryUpgradedConsensusStateResponse;
                    fromProtoMsg(message: _160.QueryUpgradedConsensusStateResponseProtoMsg): _160.QueryUpgradedConsensusStateResponse;
                    toProto(message: _160.QueryUpgradedConsensusStateResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryUpgradedConsensusStateResponse): _160.QueryUpgradedConsensusStateResponseProtoMsg;
                };
                QueryVerifyMembershipRequest: {
                    typeUrl: "/ibc.core.client.v1.QueryVerifyMembershipRequest";
                    encode(message: _160.QueryVerifyMembershipRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryVerifyMembershipRequest;
                    fromJSON(object: any): _160.QueryVerifyMembershipRequest;
                    toJSON(message: _160.QueryVerifyMembershipRequest): import("../json-safe.ts").JsonSafe<_160.QueryVerifyMembershipRequest>;
                    fromPartial(object: Partial<_160.QueryVerifyMembershipRequest>): _160.QueryVerifyMembershipRequest;
                    fromProtoMsg(message: _160.QueryVerifyMembershipRequestProtoMsg): _160.QueryVerifyMembershipRequest;
                    toProto(message: _160.QueryVerifyMembershipRequest): Uint8Array;
                    toProtoMsg(message: _160.QueryVerifyMembershipRequest): _160.QueryVerifyMembershipRequestProtoMsg;
                };
                QueryVerifyMembershipResponse: {
                    typeUrl: "/ibc.core.client.v1.QueryVerifyMembershipResponse";
                    encode(message: _160.QueryVerifyMembershipResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _160.QueryVerifyMembershipResponse;
                    fromJSON(object: any): _160.QueryVerifyMembershipResponse;
                    toJSON(message: _160.QueryVerifyMembershipResponse): import("../json-safe.ts").JsonSafe<_160.QueryVerifyMembershipResponse>;
                    fromPartial(object: Partial<_160.QueryVerifyMembershipResponse>): _160.QueryVerifyMembershipResponse;
                    fromProtoMsg(message: _160.QueryVerifyMembershipResponseProtoMsg): _160.QueryVerifyMembershipResponse;
                    toProto(message: _160.QueryVerifyMembershipResponse): Uint8Array;
                    toProtoMsg(message: _160.QueryVerifyMembershipResponse): _160.QueryVerifyMembershipResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: "/ibc.core.client.v1.GenesisState";
                    encode(message: _159.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.GenesisState;
                    fromJSON(object: any): _159.GenesisState;
                    toJSON(message: _159.GenesisState): import("../json-safe.ts").JsonSafe<_159.GenesisState>;
                    fromPartial(object: Partial<_159.GenesisState>): _159.GenesisState;
                    fromProtoMsg(message: _159.GenesisStateProtoMsg): _159.GenesisState;
                    toProto(message: _159.GenesisState): Uint8Array;
                    toProtoMsg(message: _159.GenesisState): _159.GenesisStateProtoMsg;
                };
                GenesisMetadata: {
                    typeUrl: "/ibc.core.client.v1.GenesisMetadata";
                    encode(message: _159.GenesisMetadata, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.GenesisMetadata;
                    fromJSON(object: any): _159.GenesisMetadata;
                    toJSON(message: _159.GenesisMetadata): import("../json-safe.ts").JsonSafe<_159.GenesisMetadata>;
                    fromPartial(object: Partial<_159.GenesisMetadata>): _159.GenesisMetadata;
                    fromProtoMsg(message: _159.GenesisMetadataProtoMsg): _159.GenesisMetadata;
                    toProto(message: _159.GenesisMetadata): Uint8Array;
                    toProtoMsg(message: _159.GenesisMetadata): _159.GenesisMetadataProtoMsg;
                };
                IdentifiedGenesisMetadata: {
                    typeUrl: "/ibc.core.client.v1.IdentifiedGenesisMetadata";
                    encode(message: _159.IdentifiedGenesisMetadata, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _159.IdentifiedGenesisMetadata;
                    fromJSON(object: any): _159.IdentifiedGenesisMetadata;
                    toJSON(message: _159.IdentifiedGenesisMetadata): import("../json-safe.ts").JsonSafe<_159.IdentifiedGenesisMetadata>;
                    fromPartial(object: Partial<_159.IdentifiedGenesisMetadata>): _159.IdentifiedGenesisMetadata;
                    fromProtoMsg(message: _159.IdentifiedGenesisMetadataProtoMsg): _159.IdentifiedGenesisMetadata;
                    toProto(message: _159.IdentifiedGenesisMetadata): Uint8Array;
                    toProtoMsg(message: _159.IdentifiedGenesisMetadata): _159.IdentifiedGenesisMetadataProtoMsg;
                };
                IdentifiedClientState: {
                    typeUrl: "/ibc.core.client.v1.IdentifiedClientState";
                    encode(message: _158.IdentifiedClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _158.IdentifiedClientState;
                    fromJSON(object: any): _158.IdentifiedClientState;
                    toJSON(message: _158.IdentifiedClientState): import("../json-safe.ts").JsonSafe<_158.IdentifiedClientState>;
                    fromPartial(object: Partial<_158.IdentifiedClientState>): _158.IdentifiedClientState;
                    fromProtoMsg(message: _158.IdentifiedClientStateProtoMsg): _158.IdentifiedClientState;
                    toProto(message: _158.IdentifiedClientState): Uint8Array;
                    toProtoMsg(message: _158.IdentifiedClientState): _158.IdentifiedClientStateProtoMsg;
                };
                ConsensusStateWithHeight: {
                    typeUrl: "/ibc.core.client.v1.ConsensusStateWithHeight";
                    encode(message: _158.ConsensusStateWithHeight, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _158.ConsensusStateWithHeight;
                    fromJSON(object: any): _158.ConsensusStateWithHeight;
                    toJSON(message: _158.ConsensusStateWithHeight): import("../json-safe.ts").JsonSafe<_158.ConsensusStateWithHeight>;
                    fromPartial(object: Partial<_158.ConsensusStateWithHeight>): _158.ConsensusStateWithHeight;
                    fromProtoMsg(message: _158.ConsensusStateWithHeightProtoMsg): _158.ConsensusStateWithHeight;
                    toProto(message: _158.ConsensusStateWithHeight): Uint8Array;
                    toProtoMsg(message: _158.ConsensusStateWithHeight): _158.ConsensusStateWithHeightProtoMsg;
                };
                ClientConsensusStates: {
                    typeUrl: "/ibc.core.client.v1.ClientConsensusStates";
                    encode(message: _158.ClientConsensusStates, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _158.ClientConsensusStates;
                    fromJSON(object: any): _158.ClientConsensusStates;
                    toJSON(message: _158.ClientConsensusStates): import("../json-safe.ts").JsonSafe<_158.ClientConsensusStates>;
                    fromPartial(object: Partial<_158.ClientConsensusStates>): _158.ClientConsensusStates;
                    fromProtoMsg(message: _158.ClientConsensusStatesProtoMsg): _158.ClientConsensusStates;
                    toProto(message: _158.ClientConsensusStates): Uint8Array;
                    toProtoMsg(message: _158.ClientConsensusStates): _158.ClientConsensusStatesProtoMsg;
                };
                Height: {
                    typeUrl: "/ibc.core.client.v1.Height";
                    encode(message: _158.Height, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _158.Height;
                    fromJSON(object: any): _158.Height;
                    toJSON(message: _158.Height): import("../json-safe.ts").JsonSafe<_158.Height>;
                    fromPartial(object: Partial<_158.Height>): _158.Height;
                    fromProtoMsg(message: _158.HeightProtoMsg): _158.Height;
                    toProto(message: _158.Height): Uint8Array;
                    toProtoMsg(message: _158.Height): _158.HeightProtoMsg;
                };
                Params: {
                    typeUrl: "/ibc.core.client.v1.Params";
                    encode(message: _158.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _158.Params;
                    fromJSON(object: any): _158.Params;
                    toJSON(message: _158.Params): import("../json-safe.ts").JsonSafe<_158.Params>;
                    fromPartial(object: Partial<_158.Params>): _158.Params;
                    fromProtoMsg(message: _158.ParamsProtoMsg): _158.Params;
                    toProto(message: _158.Params): Uint8Array;
                    toProtoMsg(message: _158.Params): _158.ParamsProtoMsg;
                };
                ClientUpdateProposal: {
                    typeUrl: "/ibc.core.client.v1.ClientUpdateProposal";
                    encode(message: _158.ClientUpdateProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _158.ClientUpdateProposal;
                    fromJSON(object: any): _158.ClientUpdateProposal;
                    toJSON(message: _158.ClientUpdateProposal): import("../json-safe.ts").JsonSafe<_158.ClientUpdateProposal>;
                    fromPartial(object: Partial<_158.ClientUpdateProposal>): _158.ClientUpdateProposal;
                    fromProtoMsg(message: _158.ClientUpdateProposalProtoMsg): _158.ClientUpdateProposal;
                    toProto(message: _158.ClientUpdateProposal): Uint8Array;
                    toProtoMsg(message: _158.ClientUpdateProposal): _158.ClientUpdateProposalProtoMsg;
                };
                UpgradeProposal: {
                    typeUrl: "/ibc.core.client.v1.UpgradeProposal";
                    encode(message: _158.UpgradeProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _158.UpgradeProposal;
                    fromJSON(object: any): _158.UpgradeProposal;
                    toJSON(message: _158.UpgradeProposal): import("../json-safe.ts").JsonSafe<_158.UpgradeProposal>;
                    fromPartial(object: Partial<_158.UpgradeProposal>): _158.UpgradeProposal;
                    fromProtoMsg(message: _158.UpgradeProposalProtoMsg): _158.UpgradeProposal;
                    toProto(message: _158.UpgradeProposal): Uint8Array;
                    toProtoMsg(message: _158.UpgradeProposal): _158.UpgradeProposalProtoMsg;
                };
            };
        }
        namespace commitment {
            const v1: {
                MerkleRoot: {
                    typeUrl: "/ibc.core.commitment.v1.MerkleRoot";
                    encode(message: _162.MerkleRoot, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.MerkleRoot;
                    fromJSON(object: any): _162.MerkleRoot;
                    toJSON(message: _162.MerkleRoot): import("../json-safe.ts").JsonSafe<_162.MerkleRoot>;
                    fromPartial(object: Partial<_162.MerkleRoot>): _162.MerkleRoot;
                    fromProtoMsg(message: _162.MerkleRootProtoMsg): _162.MerkleRoot;
                    toProto(message: _162.MerkleRoot): Uint8Array;
                    toProtoMsg(message: _162.MerkleRoot): _162.MerkleRootProtoMsg;
                };
                MerklePrefix: {
                    typeUrl: "/ibc.core.commitment.v1.MerklePrefix";
                    encode(message: _162.MerklePrefix, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.MerklePrefix;
                    fromJSON(object: any): _162.MerklePrefix;
                    toJSON(message: _162.MerklePrefix): import("../json-safe.ts").JsonSafe<_162.MerklePrefix>;
                    fromPartial(object: Partial<_162.MerklePrefix>): _162.MerklePrefix;
                    fromProtoMsg(message: _162.MerklePrefixProtoMsg): _162.MerklePrefix;
                    toProto(message: _162.MerklePrefix): Uint8Array;
                    toProtoMsg(message: _162.MerklePrefix): _162.MerklePrefixProtoMsg;
                };
                MerklePath: {
                    typeUrl: "/ibc.core.commitment.v1.MerklePath";
                    encode(message: _162.MerklePath, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.MerklePath;
                    fromJSON(object: any): _162.MerklePath;
                    toJSON(message: _162.MerklePath): import("../json-safe.ts").JsonSafe<_162.MerklePath>;
                    fromPartial(object: Partial<_162.MerklePath>): _162.MerklePath;
                    fromProtoMsg(message: _162.MerklePathProtoMsg): _162.MerklePath;
                    toProto(message: _162.MerklePath): Uint8Array;
                    toProtoMsg(message: _162.MerklePath): _162.MerklePathProtoMsg;
                };
                MerkleProof: {
                    typeUrl: "/ibc.core.commitment.v1.MerkleProof";
                    encode(message: _162.MerkleProof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _162.MerkleProof;
                    fromJSON(object: any): _162.MerkleProof;
                    toJSON(message: _162.MerkleProof): import("../json-safe.ts").JsonSafe<_162.MerkleProof>;
                    fromPartial(object: Partial<_162.MerkleProof>): _162.MerkleProof;
                    fromProtoMsg(message: _162.MerkleProofProtoMsg): _162.MerkleProof;
                    toProto(message: _162.MerkleProof): Uint8Array;
                    toProtoMsg(message: _162.MerkleProof): _162.MerkleProofProtoMsg;
                };
            };
        }
        namespace connection {
            const v1: {
                MsgConnectionOpenInit: {
                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenInit";
                    encode(message: _166.MsgConnectionOpenInit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgConnectionOpenInit;
                    fromJSON(object: any): _166.MsgConnectionOpenInit;
                    toJSON(message: _166.MsgConnectionOpenInit): import("../json-safe.ts").JsonSafe<_166.MsgConnectionOpenInit>;
                    fromPartial(object: Partial<_166.MsgConnectionOpenInit>): _166.MsgConnectionOpenInit;
                    fromProtoMsg(message: _166.MsgConnectionOpenInitProtoMsg): _166.MsgConnectionOpenInit;
                    toProto(message: _166.MsgConnectionOpenInit): Uint8Array;
                    toProtoMsg(message: _166.MsgConnectionOpenInit): _166.MsgConnectionOpenInitProtoMsg;
                };
                MsgConnectionOpenInitResponse: {
                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenInitResponse";
                    encode(_: _166.MsgConnectionOpenInitResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgConnectionOpenInitResponse;
                    fromJSON(_: any): _166.MsgConnectionOpenInitResponse;
                    toJSON(_: _166.MsgConnectionOpenInitResponse): import("../json-safe.ts").JsonSafe<_166.MsgConnectionOpenInitResponse>;
                    fromPartial(_: Partial<_166.MsgConnectionOpenInitResponse>): _166.MsgConnectionOpenInitResponse;
                    fromProtoMsg(message: _166.MsgConnectionOpenInitResponseProtoMsg): _166.MsgConnectionOpenInitResponse;
                    toProto(message: _166.MsgConnectionOpenInitResponse): Uint8Array;
                    toProtoMsg(message: _166.MsgConnectionOpenInitResponse): _166.MsgConnectionOpenInitResponseProtoMsg;
                };
                MsgConnectionOpenTry: {
                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenTry";
                    encode(message: _166.MsgConnectionOpenTry, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgConnectionOpenTry;
                    fromJSON(object: any): _166.MsgConnectionOpenTry;
                    toJSON(message: _166.MsgConnectionOpenTry): import("../json-safe.ts").JsonSafe<_166.MsgConnectionOpenTry>;
                    fromPartial(object: Partial<_166.MsgConnectionOpenTry>): _166.MsgConnectionOpenTry;
                    fromProtoMsg(message: _166.MsgConnectionOpenTryProtoMsg): _166.MsgConnectionOpenTry;
                    toProto(message: _166.MsgConnectionOpenTry): Uint8Array;
                    toProtoMsg(message: _166.MsgConnectionOpenTry): _166.MsgConnectionOpenTryProtoMsg;
                };
                MsgConnectionOpenTryResponse: {
                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenTryResponse";
                    encode(_: _166.MsgConnectionOpenTryResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgConnectionOpenTryResponse;
                    fromJSON(_: any): _166.MsgConnectionOpenTryResponse;
                    toJSON(_: _166.MsgConnectionOpenTryResponse): import("../json-safe.ts").JsonSafe<_166.MsgConnectionOpenTryResponse>;
                    fromPartial(_: Partial<_166.MsgConnectionOpenTryResponse>): _166.MsgConnectionOpenTryResponse;
                    fromProtoMsg(message: _166.MsgConnectionOpenTryResponseProtoMsg): _166.MsgConnectionOpenTryResponse;
                    toProto(message: _166.MsgConnectionOpenTryResponse): Uint8Array;
                    toProtoMsg(message: _166.MsgConnectionOpenTryResponse): _166.MsgConnectionOpenTryResponseProtoMsg;
                };
                MsgConnectionOpenAck: {
                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenAck";
                    encode(message: _166.MsgConnectionOpenAck, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgConnectionOpenAck;
                    fromJSON(object: any): _166.MsgConnectionOpenAck;
                    toJSON(message: _166.MsgConnectionOpenAck): import("../json-safe.ts").JsonSafe<_166.MsgConnectionOpenAck>;
                    fromPartial(object: Partial<_166.MsgConnectionOpenAck>): _166.MsgConnectionOpenAck;
                    fromProtoMsg(message: _166.MsgConnectionOpenAckProtoMsg): _166.MsgConnectionOpenAck;
                    toProto(message: _166.MsgConnectionOpenAck): Uint8Array;
                    toProtoMsg(message: _166.MsgConnectionOpenAck): _166.MsgConnectionOpenAckProtoMsg;
                };
                MsgConnectionOpenAckResponse: {
                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenAckResponse";
                    encode(_: _166.MsgConnectionOpenAckResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgConnectionOpenAckResponse;
                    fromJSON(_: any): _166.MsgConnectionOpenAckResponse;
                    toJSON(_: _166.MsgConnectionOpenAckResponse): import("../json-safe.ts").JsonSafe<_166.MsgConnectionOpenAckResponse>;
                    fromPartial(_: Partial<_166.MsgConnectionOpenAckResponse>): _166.MsgConnectionOpenAckResponse;
                    fromProtoMsg(message: _166.MsgConnectionOpenAckResponseProtoMsg): _166.MsgConnectionOpenAckResponse;
                    toProto(message: _166.MsgConnectionOpenAckResponse): Uint8Array;
                    toProtoMsg(message: _166.MsgConnectionOpenAckResponse): _166.MsgConnectionOpenAckResponseProtoMsg;
                };
                MsgConnectionOpenConfirm: {
                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenConfirm";
                    encode(message: _166.MsgConnectionOpenConfirm, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgConnectionOpenConfirm;
                    fromJSON(object: any): _166.MsgConnectionOpenConfirm;
                    toJSON(message: _166.MsgConnectionOpenConfirm): import("../json-safe.ts").JsonSafe<_166.MsgConnectionOpenConfirm>;
                    fromPartial(object: Partial<_166.MsgConnectionOpenConfirm>): _166.MsgConnectionOpenConfirm;
                    fromProtoMsg(message: _166.MsgConnectionOpenConfirmProtoMsg): _166.MsgConnectionOpenConfirm;
                    toProto(message: _166.MsgConnectionOpenConfirm): Uint8Array;
                    toProtoMsg(message: _166.MsgConnectionOpenConfirm): _166.MsgConnectionOpenConfirmProtoMsg;
                };
                MsgConnectionOpenConfirmResponse: {
                    typeUrl: "/ibc.core.connection.v1.MsgConnectionOpenConfirmResponse";
                    encode(_: _166.MsgConnectionOpenConfirmResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgConnectionOpenConfirmResponse;
                    fromJSON(_: any): _166.MsgConnectionOpenConfirmResponse;
                    toJSON(_: _166.MsgConnectionOpenConfirmResponse): import("../json-safe.ts").JsonSafe<_166.MsgConnectionOpenConfirmResponse>;
                    fromPartial(_: Partial<_166.MsgConnectionOpenConfirmResponse>): _166.MsgConnectionOpenConfirmResponse;
                    fromProtoMsg(message: _166.MsgConnectionOpenConfirmResponseProtoMsg): _166.MsgConnectionOpenConfirmResponse;
                    toProto(message: _166.MsgConnectionOpenConfirmResponse): Uint8Array;
                    toProtoMsg(message: _166.MsgConnectionOpenConfirmResponse): _166.MsgConnectionOpenConfirmResponseProtoMsg;
                };
                MsgUpdateParams: {
                    typeUrl: "/ibc.core.connection.v1.MsgUpdateParams";
                    encode(message: _166.MsgUpdateParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgUpdateParams;
                    fromJSON(object: any): _166.MsgUpdateParams;
                    toJSON(message: _166.MsgUpdateParams): import("../json-safe.ts").JsonSafe<_166.MsgUpdateParams>;
                    fromPartial(object: Partial<_166.MsgUpdateParams>): _166.MsgUpdateParams;
                    fromProtoMsg(message: _166.MsgUpdateParamsProtoMsg): _166.MsgUpdateParams;
                    toProto(message: _166.MsgUpdateParams): Uint8Array;
                    toProtoMsg(message: _166.MsgUpdateParams): _166.MsgUpdateParamsProtoMsg;
                };
                MsgUpdateParamsResponse: {
                    typeUrl: "/ibc.core.connection.v1.MsgUpdateParamsResponse";
                    encode(_: _166.MsgUpdateParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _166.MsgUpdateParamsResponse;
                    fromJSON(_: any): _166.MsgUpdateParamsResponse;
                    toJSON(_: _166.MsgUpdateParamsResponse): import("../json-safe.ts").JsonSafe<_166.MsgUpdateParamsResponse>;
                    fromPartial(_: Partial<_166.MsgUpdateParamsResponse>): _166.MsgUpdateParamsResponse;
                    fromProtoMsg(message: _166.MsgUpdateParamsResponseProtoMsg): _166.MsgUpdateParamsResponse;
                    toProto(message: _166.MsgUpdateParamsResponse): Uint8Array;
                    toProtoMsg(message: _166.MsgUpdateParamsResponse): _166.MsgUpdateParamsResponseProtoMsg;
                };
                QueryConnectionRequest: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionRequest";
                    encode(message: _165.QueryConnectionRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionRequest;
                    fromJSON(object: any): _165.QueryConnectionRequest;
                    toJSON(message: _165.QueryConnectionRequest): import("../json-safe.ts").JsonSafe<_165.QueryConnectionRequest>;
                    fromPartial(object: Partial<_165.QueryConnectionRequest>): _165.QueryConnectionRequest;
                    fromProtoMsg(message: _165.QueryConnectionRequestProtoMsg): _165.QueryConnectionRequest;
                    toProto(message: _165.QueryConnectionRequest): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionRequest): _165.QueryConnectionRequestProtoMsg;
                };
                QueryConnectionResponse: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionResponse";
                    encode(message: _165.QueryConnectionResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionResponse;
                    fromJSON(object: any): _165.QueryConnectionResponse;
                    toJSON(message: _165.QueryConnectionResponse): import("../json-safe.ts").JsonSafe<_165.QueryConnectionResponse>;
                    fromPartial(object: Partial<_165.QueryConnectionResponse>): _165.QueryConnectionResponse;
                    fromProtoMsg(message: _165.QueryConnectionResponseProtoMsg): _165.QueryConnectionResponse;
                    toProto(message: _165.QueryConnectionResponse): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionResponse): _165.QueryConnectionResponseProtoMsg;
                };
                QueryConnectionsRequest: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionsRequest";
                    encode(message: _165.QueryConnectionsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionsRequest;
                    fromJSON(object: any): _165.QueryConnectionsRequest;
                    toJSON(message: _165.QueryConnectionsRequest): import("../json-safe.ts").JsonSafe<_165.QueryConnectionsRequest>;
                    fromPartial(object: Partial<_165.QueryConnectionsRequest>): _165.QueryConnectionsRequest;
                    fromProtoMsg(message: _165.QueryConnectionsRequestProtoMsg): _165.QueryConnectionsRequest;
                    toProto(message: _165.QueryConnectionsRequest): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionsRequest): _165.QueryConnectionsRequestProtoMsg;
                };
                QueryConnectionsResponse: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionsResponse";
                    encode(message: _165.QueryConnectionsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionsResponse;
                    fromJSON(object: any): _165.QueryConnectionsResponse;
                    toJSON(message: _165.QueryConnectionsResponse): import("../json-safe.ts").JsonSafe<_165.QueryConnectionsResponse>;
                    fromPartial(object: Partial<_165.QueryConnectionsResponse>): _165.QueryConnectionsResponse;
                    fromProtoMsg(message: _165.QueryConnectionsResponseProtoMsg): _165.QueryConnectionsResponse;
                    toProto(message: _165.QueryConnectionsResponse): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionsResponse): _165.QueryConnectionsResponseProtoMsg;
                };
                QueryClientConnectionsRequest: {
                    typeUrl: "/ibc.core.connection.v1.QueryClientConnectionsRequest";
                    encode(message: _165.QueryClientConnectionsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryClientConnectionsRequest;
                    fromJSON(object: any): _165.QueryClientConnectionsRequest;
                    toJSON(message: _165.QueryClientConnectionsRequest): import("../json-safe.ts").JsonSafe<_165.QueryClientConnectionsRequest>;
                    fromPartial(object: Partial<_165.QueryClientConnectionsRequest>): _165.QueryClientConnectionsRequest;
                    fromProtoMsg(message: _165.QueryClientConnectionsRequestProtoMsg): _165.QueryClientConnectionsRequest;
                    toProto(message: _165.QueryClientConnectionsRequest): Uint8Array;
                    toProtoMsg(message: _165.QueryClientConnectionsRequest): _165.QueryClientConnectionsRequestProtoMsg;
                };
                QueryClientConnectionsResponse: {
                    typeUrl: "/ibc.core.connection.v1.QueryClientConnectionsResponse";
                    encode(message: _165.QueryClientConnectionsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryClientConnectionsResponse;
                    fromJSON(object: any): _165.QueryClientConnectionsResponse;
                    toJSON(message: _165.QueryClientConnectionsResponse): import("../json-safe.ts").JsonSafe<_165.QueryClientConnectionsResponse>;
                    fromPartial(object: Partial<_165.QueryClientConnectionsResponse>): _165.QueryClientConnectionsResponse;
                    fromProtoMsg(message: _165.QueryClientConnectionsResponseProtoMsg): _165.QueryClientConnectionsResponse;
                    toProto(message: _165.QueryClientConnectionsResponse): Uint8Array;
                    toProtoMsg(message: _165.QueryClientConnectionsResponse): _165.QueryClientConnectionsResponseProtoMsg;
                };
                QueryConnectionClientStateRequest: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionClientStateRequest";
                    encode(message: _165.QueryConnectionClientStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionClientStateRequest;
                    fromJSON(object: any): _165.QueryConnectionClientStateRequest;
                    toJSON(message: _165.QueryConnectionClientStateRequest): import("../json-safe.ts").JsonSafe<_165.QueryConnectionClientStateRequest>;
                    fromPartial(object: Partial<_165.QueryConnectionClientStateRequest>): _165.QueryConnectionClientStateRequest;
                    fromProtoMsg(message: _165.QueryConnectionClientStateRequestProtoMsg): _165.QueryConnectionClientStateRequest;
                    toProto(message: _165.QueryConnectionClientStateRequest): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionClientStateRequest): _165.QueryConnectionClientStateRequestProtoMsg;
                };
                QueryConnectionClientStateResponse: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionClientStateResponse";
                    encode(message: _165.QueryConnectionClientStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionClientStateResponse;
                    fromJSON(object: any): _165.QueryConnectionClientStateResponse;
                    toJSON(message: _165.QueryConnectionClientStateResponse): import("../json-safe.ts").JsonSafe<_165.QueryConnectionClientStateResponse>;
                    fromPartial(object: Partial<_165.QueryConnectionClientStateResponse>): _165.QueryConnectionClientStateResponse;
                    fromProtoMsg(message: _165.QueryConnectionClientStateResponseProtoMsg): _165.QueryConnectionClientStateResponse;
                    toProto(message: _165.QueryConnectionClientStateResponse): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionClientStateResponse): _165.QueryConnectionClientStateResponseProtoMsg;
                };
                QueryConnectionConsensusStateRequest: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionConsensusStateRequest";
                    encode(message: _165.QueryConnectionConsensusStateRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionConsensusStateRequest;
                    fromJSON(object: any): _165.QueryConnectionConsensusStateRequest;
                    toJSON(message: _165.QueryConnectionConsensusStateRequest): import("../json-safe.ts").JsonSafe<_165.QueryConnectionConsensusStateRequest>;
                    fromPartial(object: Partial<_165.QueryConnectionConsensusStateRequest>): _165.QueryConnectionConsensusStateRequest;
                    fromProtoMsg(message: _165.QueryConnectionConsensusStateRequestProtoMsg): _165.QueryConnectionConsensusStateRequest;
                    toProto(message: _165.QueryConnectionConsensusStateRequest): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionConsensusStateRequest): _165.QueryConnectionConsensusStateRequestProtoMsg;
                };
                QueryConnectionConsensusStateResponse: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionConsensusStateResponse";
                    encode(message: _165.QueryConnectionConsensusStateResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionConsensusStateResponse;
                    fromJSON(object: any): _165.QueryConnectionConsensusStateResponse;
                    toJSON(message: _165.QueryConnectionConsensusStateResponse): import("../json-safe.ts").JsonSafe<_165.QueryConnectionConsensusStateResponse>;
                    fromPartial(object: Partial<_165.QueryConnectionConsensusStateResponse>): _165.QueryConnectionConsensusStateResponse;
                    fromProtoMsg(message: _165.QueryConnectionConsensusStateResponseProtoMsg): _165.QueryConnectionConsensusStateResponse;
                    toProto(message: _165.QueryConnectionConsensusStateResponse): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionConsensusStateResponse): _165.QueryConnectionConsensusStateResponseProtoMsg;
                };
                QueryConnectionParamsRequest: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionParamsRequest";
                    encode(_: _165.QueryConnectionParamsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionParamsRequest;
                    fromJSON(_: any): _165.QueryConnectionParamsRequest;
                    toJSON(_: _165.QueryConnectionParamsRequest): import("../json-safe.ts").JsonSafe<_165.QueryConnectionParamsRequest>;
                    fromPartial(_: Partial<_165.QueryConnectionParamsRequest>): _165.QueryConnectionParamsRequest;
                    fromProtoMsg(message: _165.QueryConnectionParamsRequestProtoMsg): _165.QueryConnectionParamsRequest;
                    toProto(message: _165.QueryConnectionParamsRequest): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionParamsRequest): _165.QueryConnectionParamsRequestProtoMsg;
                };
                QueryConnectionParamsResponse: {
                    typeUrl: "/ibc.core.connection.v1.QueryConnectionParamsResponse";
                    encode(message: _165.QueryConnectionParamsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _165.QueryConnectionParamsResponse;
                    fromJSON(object: any): _165.QueryConnectionParamsResponse;
                    toJSON(message: _165.QueryConnectionParamsResponse): import("../json-safe.ts").JsonSafe<_165.QueryConnectionParamsResponse>;
                    fromPartial(object: Partial<_165.QueryConnectionParamsResponse>): _165.QueryConnectionParamsResponse;
                    fromProtoMsg(message: _165.QueryConnectionParamsResponseProtoMsg): _165.QueryConnectionParamsResponse;
                    toProto(message: _165.QueryConnectionParamsResponse): Uint8Array;
                    toProtoMsg(message: _165.QueryConnectionParamsResponse): _165.QueryConnectionParamsResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: "/ibc.core.connection.v1.GenesisState";
                    encode(message: _164.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _164.GenesisState;
                    fromJSON(object: any): _164.GenesisState;
                    toJSON(message: _164.GenesisState): import("../json-safe.ts").JsonSafe<_164.GenesisState>;
                    fromPartial(object: Partial<_164.GenesisState>): _164.GenesisState;
                    fromProtoMsg(message: _164.GenesisStateProtoMsg): _164.GenesisState;
                    toProto(message: _164.GenesisState): Uint8Array;
                    toProtoMsg(message: _164.GenesisState): _164.GenesisStateProtoMsg;
                };
                stateFromJSON(object: any): _163.State;
                stateToJSON(object: _163.State): string;
                State: typeof _163.State;
                StateSDKType: typeof _163.State;
                ConnectionEnd: {
                    typeUrl: "/ibc.core.connection.v1.ConnectionEnd";
                    encode(message: _163.ConnectionEnd, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _163.ConnectionEnd;
                    fromJSON(object: any): _163.ConnectionEnd;
                    toJSON(message: _163.ConnectionEnd): import("../json-safe.ts").JsonSafe<_163.ConnectionEnd>;
                    fromPartial(object: Partial<_163.ConnectionEnd>): _163.ConnectionEnd;
                    fromProtoMsg(message: _163.ConnectionEndProtoMsg): _163.ConnectionEnd;
                    toProto(message: _163.ConnectionEnd): Uint8Array;
                    toProtoMsg(message: _163.ConnectionEnd): _163.ConnectionEndProtoMsg;
                };
                IdentifiedConnection: {
                    typeUrl: "/ibc.core.connection.v1.IdentifiedConnection";
                    encode(message: _163.IdentifiedConnection, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _163.IdentifiedConnection;
                    fromJSON(object: any): _163.IdentifiedConnection;
                    toJSON(message: _163.IdentifiedConnection): import("../json-safe.ts").JsonSafe<_163.IdentifiedConnection>;
                    fromPartial(object: Partial<_163.IdentifiedConnection>): _163.IdentifiedConnection;
                    fromProtoMsg(message: _163.IdentifiedConnectionProtoMsg): _163.IdentifiedConnection;
                    toProto(message: _163.IdentifiedConnection): Uint8Array;
                    toProtoMsg(message: _163.IdentifiedConnection): _163.IdentifiedConnectionProtoMsg;
                };
                Counterparty: {
                    typeUrl: "/ibc.core.connection.v1.Counterparty";
                    encode(message: _163.Counterparty, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _163.Counterparty;
                    fromJSON(object: any): _163.Counterparty;
                    toJSON(message: _163.Counterparty): import("../json-safe.ts").JsonSafe<_163.Counterparty>;
                    fromPartial(object: Partial<_163.Counterparty>): _163.Counterparty;
                    fromProtoMsg(message: _163.CounterpartyProtoMsg): _163.Counterparty;
                    toProto(message: _163.Counterparty): Uint8Array;
                    toProtoMsg(message: _163.Counterparty): _163.CounterpartyProtoMsg;
                };
                ClientPaths: {
                    typeUrl: "/ibc.core.connection.v1.ClientPaths";
                    encode(message: _163.ClientPaths, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _163.ClientPaths;
                    fromJSON(object: any): _163.ClientPaths;
                    toJSON(message: _163.ClientPaths): import("../json-safe.ts").JsonSafe<_163.ClientPaths>;
                    fromPartial(object: Partial<_163.ClientPaths>): _163.ClientPaths;
                    fromProtoMsg(message: _163.ClientPathsProtoMsg): _163.ClientPaths;
                    toProto(message: _163.ClientPaths): Uint8Array;
                    toProtoMsg(message: _163.ClientPaths): _163.ClientPathsProtoMsg;
                };
                ConnectionPaths: {
                    typeUrl: "/ibc.core.connection.v1.ConnectionPaths";
                    encode(message: _163.ConnectionPaths, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _163.ConnectionPaths;
                    fromJSON(object: any): _163.ConnectionPaths;
                    toJSON(message: _163.ConnectionPaths): import("../json-safe.ts").JsonSafe<_163.ConnectionPaths>;
                    fromPartial(object: Partial<_163.ConnectionPaths>): _163.ConnectionPaths;
                    fromProtoMsg(message: _163.ConnectionPathsProtoMsg): _163.ConnectionPaths;
                    toProto(message: _163.ConnectionPaths): Uint8Array;
                    toProtoMsg(message: _163.ConnectionPaths): _163.ConnectionPathsProtoMsg;
                };
                Version: {
                    typeUrl: "/ibc.core.connection.v1.Version";
                    encode(message: _163.Version, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _163.Version;
                    fromJSON(object: any): _163.Version;
                    toJSON(message: _163.Version): import("../json-safe.ts").JsonSafe<_163.Version>;
                    fromPartial(object: Partial<_163.Version>): _163.Version;
                    fromProtoMsg(message: _163.VersionProtoMsg): _163.Version;
                    toProto(message: _163.Version): Uint8Array;
                    toProtoMsg(message: _163.Version): _163.VersionProtoMsg;
                };
                Params: {
                    typeUrl: "/ibc.core.connection.v1.Params";
                    encode(message: _163.Params, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _163.Params;
                    fromJSON(object: any): _163.Params;
                    toJSON(message: _163.Params): import("../json-safe.ts").JsonSafe<_163.Params>;
                    fromPartial(object: Partial<_163.Params>): _163.Params;
                    fromProtoMsg(message: _163.ParamsProtoMsg): _163.Params;
                    toProto(message: _163.Params): Uint8Array;
                    toProtoMsg(message: _163.Params): _163.ParamsProtoMsg;
                };
            };
        }
    }
    namespace lightclients {
        namespace localhost {
            const v1: {
                ClientState: {
                    typeUrl: "/ibc.lightclients.localhost.v1.ClientState";
                    encode(message: _167.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _167.ClientState;
                    fromJSON(object: any): _167.ClientState;
                    toJSON(message: _167.ClientState): import("../json-safe.ts").JsonSafe<_167.ClientState>;
                    fromPartial(object: Partial<_167.ClientState>): _167.ClientState;
                    fromProtoMsg(message: _167.ClientStateProtoMsg): _167.ClientState;
                    toProto(message: _167.ClientState): Uint8Array;
                    toProtoMsg(message: _167.ClientState): _167.ClientStateProtoMsg;
                };
            };
            const v2: {
                ClientState: {
                    typeUrl: "/ibc.lightclients.localhost.v2.ClientState";
                    encode(message: _168.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _168.ClientState;
                    fromJSON(object: any): _168.ClientState;
                    toJSON(message: _168.ClientState): import("../json-safe.ts").JsonSafe<_168.ClientState>;
                    fromPartial(object: Partial<_168.ClientState>): _168.ClientState;
                    fromProtoMsg(message: _168.ClientStateProtoMsg): _168.ClientState;
                    toProto(message: _168.ClientState): Uint8Array;
                    toProtoMsg(message: _168.ClientState): _168.ClientStateProtoMsg;
                };
            };
        }
        namespace solomachine {
            const v1: {
                dataTypeFromJSON(object: any): _169.DataType;
                dataTypeToJSON(object: _169.DataType): string;
                DataType: typeof _169.DataType;
                DataTypeSDKType: typeof _169.DataType;
                ClientState: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.ClientState";
                    encode(message: _169.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.ClientState;
                    fromJSON(object: any): _169.ClientState;
                    toJSON(message: _169.ClientState): import("../json-safe.ts").JsonSafe<_169.ClientState>;
                    fromPartial(object: Partial<_169.ClientState>): _169.ClientState;
                    fromProtoMsg(message: _169.ClientStateProtoMsg): _169.ClientState;
                    toProto(message: _169.ClientState): Uint8Array;
                    toProtoMsg(message: _169.ClientState): _169.ClientStateProtoMsg;
                };
                ConsensusState: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.ConsensusState";
                    encode(message: _169.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.ConsensusState;
                    fromJSON(object: any): _169.ConsensusState;
                    toJSON(message: _169.ConsensusState): import("../json-safe.ts").JsonSafe<_169.ConsensusState>;
                    fromPartial(object: Partial<_169.ConsensusState>): _169.ConsensusState;
                    fromProtoMsg(message: _169.ConsensusStateProtoMsg): _169.ConsensusState;
                    toProto(message: _169.ConsensusState): Uint8Array;
                    toProtoMsg(message: _169.ConsensusState): _169.ConsensusStateProtoMsg;
                };
                Header: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.Header";
                    encode(message: _169.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.Header;
                    fromJSON(object: any): _169.Header;
                    toJSON(message: _169.Header): import("../json-safe.ts").JsonSafe<_169.Header>;
                    fromPartial(object: Partial<_169.Header>): _169.Header;
                    fromProtoMsg(message: _169.HeaderProtoMsg): _169.Header;
                    toProto(message: _169.Header): Uint8Array;
                    toProtoMsg(message: _169.Header): _169.HeaderProtoMsg;
                };
                Misbehaviour: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.Misbehaviour";
                    encode(message: _169.Misbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.Misbehaviour;
                    fromJSON(object: any): _169.Misbehaviour;
                    toJSON(message: _169.Misbehaviour): import("../json-safe.ts").JsonSafe<_169.Misbehaviour>;
                    fromPartial(object: Partial<_169.Misbehaviour>): _169.Misbehaviour;
                    fromProtoMsg(message: _169.MisbehaviourProtoMsg): _169.Misbehaviour;
                    toProto(message: _169.Misbehaviour): Uint8Array;
                    toProtoMsg(message: _169.Misbehaviour): _169.MisbehaviourProtoMsg;
                };
                SignatureAndData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.SignatureAndData";
                    encode(message: _169.SignatureAndData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.SignatureAndData;
                    fromJSON(object: any): _169.SignatureAndData;
                    toJSON(message: _169.SignatureAndData): import("../json-safe.ts").JsonSafe<_169.SignatureAndData>;
                    fromPartial(object: Partial<_169.SignatureAndData>): _169.SignatureAndData;
                    fromProtoMsg(message: _169.SignatureAndDataProtoMsg): _169.SignatureAndData;
                    toProto(message: _169.SignatureAndData): Uint8Array;
                    toProtoMsg(message: _169.SignatureAndData): _169.SignatureAndDataProtoMsg;
                };
                TimestampedSignatureData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.TimestampedSignatureData";
                    encode(message: _169.TimestampedSignatureData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.TimestampedSignatureData;
                    fromJSON(object: any): _169.TimestampedSignatureData;
                    toJSON(message: _169.TimestampedSignatureData): import("../json-safe.ts").JsonSafe<_169.TimestampedSignatureData>;
                    fromPartial(object: Partial<_169.TimestampedSignatureData>): _169.TimestampedSignatureData;
                    fromProtoMsg(message: _169.TimestampedSignatureDataProtoMsg): _169.TimestampedSignatureData;
                    toProto(message: _169.TimestampedSignatureData): Uint8Array;
                    toProtoMsg(message: _169.TimestampedSignatureData): _169.TimestampedSignatureDataProtoMsg;
                };
                SignBytes: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.SignBytes";
                    encode(message: _169.SignBytes, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.SignBytes;
                    fromJSON(object: any): _169.SignBytes;
                    toJSON(message: _169.SignBytes): import("../json-safe.ts").JsonSafe<_169.SignBytes>;
                    fromPartial(object: Partial<_169.SignBytes>): _169.SignBytes;
                    fromProtoMsg(message: _169.SignBytesProtoMsg): _169.SignBytes;
                    toProto(message: _169.SignBytes): Uint8Array;
                    toProtoMsg(message: _169.SignBytes): _169.SignBytesProtoMsg;
                };
                HeaderData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.HeaderData";
                    encode(message: _169.HeaderData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.HeaderData;
                    fromJSON(object: any): _169.HeaderData;
                    toJSON(message: _169.HeaderData): import("../json-safe.ts").JsonSafe<_169.HeaderData>;
                    fromPartial(object: Partial<_169.HeaderData>): _169.HeaderData;
                    fromProtoMsg(message: _169.HeaderDataProtoMsg): _169.HeaderData;
                    toProto(message: _169.HeaderData): Uint8Array;
                    toProtoMsg(message: _169.HeaderData): _169.HeaderDataProtoMsg;
                };
                ClientStateData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.ClientStateData";
                    encode(message: _169.ClientStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.ClientStateData;
                    fromJSON(object: any): _169.ClientStateData;
                    toJSON(message: _169.ClientStateData): import("../json-safe.ts").JsonSafe<_169.ClientStateData>;
                    fromPartial(object: Partial<_169.ClientStateData>): _169.ClientStateData;
                    fromProtoMsg(message: _169.ClientStateDataProtoMsg): _169.ClientStateData;
                    toProto(message: _169.ClientStateData): Uint8Array;
                    toProtoMsg(message: _169.ClientStateData): _169.ClientStateDataProtoMsg;
                };
                ConsensusStateData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.ConsensusStateData";
                    encode(message: _169.ConsensusStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.ConsensusStateData;
                    fromJSON(object: any): _169.ConsensusStateData;
                    toJSON(message: _169.ConsensusStateData): import("../json-safe.ts").JsonSafe<_169.ConsensusStateData>;
                    fromPartial(object: Partial<_169.ConsensusStateData>): _169.ConsensusStateData;
                    fromProtoMsg(message: _169.ConsensusStateDataProtoMsg): _169.ConsensusStateData;
                    toProto(message: _169.ConsensusStateData): Uint8Array;
                    toProtoMsg(message: _169.ConsensusStateData): _169.ConsensusStateDataProtoMsg;
                };
                ConnectionStateData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.ConnectionStateData";
                    encode(message: _169.ConnectionStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.ConnectionStateData;
                    fromJSON(object: any): _169.ConnectionStateData;
                    toJSON(message: _169.ConnectionStateData): import("../json-safe.ts").JsonSafe<_169.ConnectionStateData>;
                    fromPartial(object: Partial<_169.ConnectionStateData>): _169.ConnectionStateData;
                    fromProtoMsg(message: _169.ConnectionStateDataProtoMsg): _169.ConnectionStateData;
                    toProto(message: _169.ConnectionStateData): Uint8Array;
                    toProtoMsg(message: _169.ConnectionStateData): _169.ConnectionStateDataProtoMsg;
                };
                ChannelStateData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.ChannelStateData";
                    encode(message: _169.ChannelStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.ChannelStateData;
                    fromJSON(object: any): _169.ChannelStateData;
                    toJSON(message: _169.ChannelStateData): import("../json-safe.ts").JsonSafe<_169.ChannelStateData>;
                    fromPartial(object: Partial<_169.ChannelStateData>): _169.ChannelStateData;
                    fromProtoMsg(message: _169.ChannelStateDataProtoMsg): _169.ChannelStateData;
                    toProto(message: _169.ChannelStateData): Uint8Array;
                    toProtoMsg(message: _169.ChannelStateData): _169.ChannelStateDataProtoMsg;
                };
                PacketCommitmentData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.PacketCommitmentData";
                    encode(message: _169.PacketCommitmentData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.PacketCommitmentData;
                    fromJSON(object: any): _169.PacketCommitmentData;
                    toJSON(message: _169.PacketCommitmentData): import("../json-safe.ts").JsonSafe<_169.PacketCommitmentData>;
                    fromPartial(object: Partial<_169.PacketCommitmentData>): _169.PacketCommitmentData;
                    fromProtoMsg(message: _169.PacketCommitmentDataProtoMsg): _169.PacketCommitmentData;
                    toProto(message: _169.PacketCommitmentData): Uint8Array;
                    toProtoMsg(message: _169.PacketCommitmentData): _169.PacketCommitmentDataProtoMsg;
                };
                PacketAcknowledgementData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.PacketAcknowledgementData";
                    encode(message: _169.PacketAcknowledgementData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.PacketAcknowledgementData;
                    fromJSON(object: any): _169.PacketAcknowledgementData;
                    toJSON(message: _169.PacketAcknowledgementData): import("../json-safe.ts").JsonSafe<_169.PacketAcknowledgementData>;
                    fromPartial(object: Partial<_169.PacketAcknowledgementData>): _169.PacketAcknowledgementData;
                    fromProtoMsg(message: _169.PacketAcknowledgementDataProtoMsg): _169.PacketAcknowledgementData;
                    toProto(message: _169.PacketAcknowledgementData): Uint8Array;
                    toProtoMsg(message: _169.PacketAcknowledgementData): _169.PacketAcknowledgementDataProtoMsg;
                };
                PacketReceiptAbsenceData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.PacketReceiptAbsenceData";
                    encode(message: _169.PacketReceiptAbsenceData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.PacketReceiptAbsenceData;
                    fromJSON(object: any): _169.PacketReceiptAbsenceData;
                    toJSON(message: _169.PacketReceiptAbsenceData): import("../json-safe.ts").JsonSafe<_169.PacketReceiptAbsenceData>;
                    fromPartial(object: Partial<_169.PacketReceiptAbsenceData>): _169.PacketReceiptAbsenceData;
                    fromProtoMsg(message: _169.PacketReceiptAbsenceDataProtoMsg): _169.PacketReceiptAbsenceData;
                    toProto(message: _169.PacketReceiptAbsenceData): Uint8Array;
                    toProtoMsg(message: _169.PacketReceiptAbsenceData): _169.PacketReceiptAbsenceDataProtoMsg;
                };
                NextSequenceRecvData: {
                    typeUrl: "/ibc.lightclients.solomachine.v1.NextSequenceRecvData";
                    encode(message: _169.NextSequenceRecvData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _169.NextSequenceRecvData;
                    fromJSON(object: any): _169.NextSequenceRecvData;
                    toJSON(message: _169.NextSequenceRecvData): import("../json-safe.ts").JsonSafe<_169.NextSequenceRecvData>;
                    fromPartial(object: Partial<_169.NextSequenceRecvData>): _169.NextSequenceRecvData;
                    fromProtoMsg(message: _169.NextSequenceRecvDataProtoMsg): _169.NextSequenceRecvData;
                    toProto(message: _169.NextSequenceRecvData): Uint8Array;
                    toProtoMsg(message: _169.NextSequenceRecvData): _169.NextSequenceRecvDataProtoMsg;
                };
            };
            const v2: {
                dataTypeFromJSON(object: any): _170.DataType;
                dataTypeToJSON(object: _170.DataType): string;
                DataType: typeof _170.DataType;
                DataTypeSDKType: typeof _170.DataType;
                ClientState: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.ClientState";
                    encode(message: _170.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ClientState;
                    fromJSON(object: any): _170.ClientState;
                    toJSON(message: _170.ClientState): import("../json-safe.ts").JsonSafe<_170.ClientState>;
                    fromPartial(object: Partial<_170.ClientState>): _170.ClientState;
                    fromProtoMsg(message: _170.ClientStateProtoMsg): _170.ClientState;
                    toProto(message: _170.ClientState): Uint8Array;
                    toProtoMsg(message: _170.ClientState): _170.ClientStateProtoMsg;
                };
                ConsensusState: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.ConsensusState";
                    encode(message: _170.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ConsensusState;
                    fromJSON(object: any): _170.ConsensusState;
                    toJSON(message: _170.ConsensusState): import("../json-safe.ts").JsonSafe<_170.ConsensusState>;
                    fromPartial(object: Partial<_170.ConsensusState>): _170.ConsensusState;
                    fromProtoMsg(message: _170.ConsensusStateProtoMsg): _170.ConsensusState;
                    toProto(message: _170.ConsensusState): Uint8Array;
                    toProtoMsg(message: _170.ConsensusState): _170.ConsensusStateProtoMsg;
                };
                Header: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.Header";
                    encode(message: _170.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.Header;
                    fromJSON(object: any): _170.Header;
                    toJSON(message: _170.Header): import("../json-safe.ts").JsonSafe<_170.Header>;
                    fromPartial(object: Partial<_170.Header>): _170.Header;
                    fromProtoMsg(message: _170.HeaderProtoMsg): _170.Header;
                    toProto(message: _170.Header): Uint8Array;
                    toProtoMsg(message: _170.Header): _170.HeaderProtoMsg;
                };
                Misbehaviour: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.Misbehaviour";
                    encode(message: _170.Misbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.Misbehaviour;
                    fromJSON(object: any): _170.Misbehaviour;
                    toJSON(message: _170.Misbehaviour): import("../json-safe.ts").JsonSafe<_170.Misbehaviour>;
                    fromPartial(object: Partial<_170.Misbehaviour>): _170.Misbehaviour;
                    fromProtoMsg(message: _170.MisbehaviourProtoMsg): _170.Misbehaviour;
                    toProto(message: _170.Misbehaviour): Uint8Array;
                    toProtoMsg(message: _170.Misbehaviour): _170.MisbehaviourProtoMsg;
                };
                SignatureAndData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.SignatureAndData";
                    encode(message: _170.SignatureAndData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.SignatureAndData;
                    fromJSON(object: any): _170.SignatureAndData;
                    toJSON(message: _170.SignatureAndData): import("../json-safe.ts").JsonSafe<_170.SignatureAndData>;
                    fromPartial(object: Partial<_170.SignatureAndData>): _170.SignatureAndData;
                    fromProtoMsg(message: _170.SignatureAndDataProtoMsg): _170.SignatureAndData;
                    toProto(message: _170.SignatureAndData): Uint8Array;
                    toProtoMsg(message: _170.SignatureAndData): _170.SignatureAndDataProtoMsg;
                };
                TimestampedSignatureData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.TimestampedSignatureData";
                    encode(message: _170.TimestampedSignatureData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.TimestampedSignatureData;
                    fromJSON(object: any): _170.TimestampedSignatureData;
                    toJSON(message: _170.TimestampedSignatureData): import("../json-safe.ts").JsonSafe<_170.TimestampedSignatureData>;
                    fromPartial(object: Partial<_170.TimestampedSignatureData>): _170.TimestampedSignatureData;
                    fromProtoMsg(message: _170.TimestampedSignatureDataProtoMsg): _170.TimestampedSignatureData;
                    toProto(message: _170.TimestampedSignatureData): Uint8Array;
                    toProtoMsg(message: _170.TimestampedSignatureData): _170.TimestampedSignatureDataProtoMsg;
                };
                SignBytes: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.SignBytes";
                    encode(message: _170.SignBytes, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.SignBytes;
                    fromJSON(object: any): _170.SignBytes;
                    toJSON(message: _170.SignBytes): import("../json-safe.ts").JsonSafe<_170.SignBytes>;
                    fromPartial(object: Partial<_170.SignBytes>): _170.SignBytes;
                    fromProtoMsg(message: _170.SignBytesProtoMsg): _170.SignBytes;
                    toProto(message: _170.SignBytes): Uint8Array;
                    toProtoMsg(message: _170.SignBytes): _170.SignBytesProtoMsg;
                };
                HeaderData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.HeaderData";
                    encode(message: _170.HeaderData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.HeaderData;
                    fromJSON(object: any): _170.HeaderData;
                    toJSON(message: _170.HeaderData): import("../json-safe.ts").JsonSafe<_170.HeaderData>;
                    fromPartial(object: Partial<_170.HeaderData>): _170.HeaderData;
                    fromProtoMsg(message: _170.HeaderDataProtoMsg): _170.HeaderData;
                    toProto(message: _170.HeaderData): Uint8Array;
                    toProtoMsg(message: _170.HeaderData): _170.HeaderDataProtoMsg;
                };
                ClientStateData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.ClientStateData";
                    encode(message: _170.ClientStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ClientStateData;
                    fromJSON(object: any): _170.ClientStateData;
                    toJSON(message: _170.ClientStateData): import("../json-safe.ts").JsonSafe<_170.ClientStateData>;
                    fromPartial(object: Partial<_170.ClientStateData>): _170.ClientStateData;
                    fromProtoMsg(message: _170.ClientStateDataProtoMsg): _170.ClientStateData;
                    toProto(message: _170.ClientStateData): Uint8Array;
                    toProtoMsg(message: _170.ClientStateData): _170.ClientStateDataProtoMsg;
                };
                ConsensusStateData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.ConsensusStateData";
                    encode(message: _170.ConsensusStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ConsensusStateData;
                    fromJSON(object: any): _170.ConsensusStateData;
                    toJSON(message: _170.ConsensusStateData): import("../json-safe.ts").JsonSafe<_170.ConsensusStateData>;
                    fromPartial(object: Partial<_170.ConsensusStateData>): _170.ConsensusStateData;
                    fromProtoMsg(message: _170.ConsensusStateDataProtoMsg): _170.ConsensusStateData;
                    toProto(message: _170.ConsensusStateData): Uint8Array;
                    toProtoMsg(message: _170.ConsensusStateData): _170.ConsensusStateDataProtoMsg;
                };
                ConnectionStateData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.ConnectionStateData";
                    encode(message: _170.ConnectionStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ConnectionStateData;
                    fromJSON(object: any): _170.ConnectionStateData;
                    toJSON(message: _170.ConnectionStateData): import("../json-safe.ts").JsonSafe<_170.ConnectionStateData>;
                    fromPartial(object: Partial<_170.ConnectionStateData>): _170.ConnectionStateData;
                    fromProtoMsg(message: _170.ConnectionStateDataProtoMsg): _170.ConnectionStateData;
                    toProto(message: _170.ConnectionStateData): Uint8Array;
                    toProtoMsg(message: _170.ConnectionStateData): _170.ConnectionStateDataProtoMsg;
                };
                ChannelStateData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.ChannelStateData";
                    encode(message: _170.ChannelStateData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.ChannelStateData;
                    fromJSON(object: any): _170.ChannelStateData;
                    toJSON(message: _170.ChannelStateData): import("../json-safe.ts").JsonSafe<_170.ChannelStateData>;
                    fromPartial(object: Partial<_170.ChannelStateData>): _170.ChannelStateData;
                    fromProtoMsg(message: _170.ChannelStateDataProtoMsg): _170.ChannelStateData;
                    toProto(message: _170.ChannelStateData): Uint8Array;
                    toProtoMsg(message: _170.ChannelStateData): _170.ChannelStateDataProtoMsg;
                };
                PacketCommitmentData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.PacketCommitmentData";
                    encode(message: _170.PacketCommitmentData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.PacketCommitmentData;
                    fromJSON(object: any): _170.PacketCommitmentData;
                    toJSON(message: _170.PacketCommitmentData): import("../json-safe.ts").JsonSafe<_170.PacketCommitmentData>;
                    fromPartial(object: Partial<_170.PacketCommitmentData>): _170.PacketCommitmentData;
                    fromProtoMsg(message: _170.PacketCommitmentDataProtoMsg): _170.PacketCommitmentData;
                    toProto(message: _170.PacketCommitmentData): Uint8Array;
                    toProtoMsg(message: _170.PacketCommitmentData): _170.PacketCommitmentDataProtoMsg;
                };
                PacketAcknowledgementData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.PacketAcknowledgementData";
                    encode(message: _170.PacketAcknowledgementData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.PacketAcknowledgementData;
                    fromJSON(object: any): _170.PacketAcknowledgementData;
                    toJSON(message: _170.PacketAcknowledgementData): import("../json-safe.ts").JsonSafe<_170.PacketAcknowledgementData>;
                    fromPartial(object: Partial<_170.PacketAcknowledgementData>): _170.PacketAcknowledgementData;
                    fromProtoMsg(message: _170.PacketAcknowledgementDataProtoMsg): _170.PacketAcknowledgementData;
                    toProto(message: _170.PacketAcknowledgementData): Uint8Array;
                    toProtoMsg(message: _170.PacketAcknowledgementData): _170.PacketAcknowledgementDataProtoMsg;
                };
                PacketReceiptAbsenceData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData";
                    encode(message: _170.PacketReceiptAbsenceData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.PacketReceiptAbsenceData;
                    fromJSON(object: any): _170.PacketReceiptAbsenceData;
                    toJSON(message: _170.PacketReceiptAbsenceData): import("../json-safe.ts").JsonSafe<_170.PacketReceiptAbsenceData>;
                    fromPartial(object: Partial<_170.PacketReceiptAbsenceData>): _170.PacketReceiptAbsenceData;
                    fromProtoMsg(message: _170.PacketReceiptAbsenceDataProtoMsg): _170.PacketReceiptAbsenceData;
                    toProto(message: _170.PacketReceiptAbsenceData): Uint8Array;
                    toProtoMsg(message: _170.PacketReceiptAbsenceData): _170.PacketReceiptAbsenceDataProtoMsg;
                };
                NextSequenceRecvData: {
                    typeUrl: "/ibc.lightclients.solomachine.v2.NextSequenceRecvData";
                    encode(message: _170.NextSequenceRecvData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _170.NextSequenceRecvData;
                    fromJSON(object: any): _170.NextSequenceRecvData;
                    toJSON(message: _170.NextSequenceRecvData): import("../json-safe.ts").JsonSafe<_170.NextSequenceRecvData>;
                    fromPartial(object: Partial<_170.NextSequenceRecvData>): _170.NextSequenceRecvData;
                    fromProtoMsg(message: _170.NextSequenceRecvDataProtoMsg): _170.NextSequenceRecvData;
                    toProto(message: _170.NextSequenceRecvData): Uint8Array;
                    toProtoMsg(message: _170.NextSequenceRecvData): _170.NextSequenceRecvDataProtoMsg;
                };
            };
            const v3: {
                ClientState: {
                    typeUrl: "/ibc.lightclients.solomachine.v3.ClientState";
                    encode(message: _171.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.ClientState;
                    fromJSON(object: any): _171.ClientState;
                    toJSON(message: _171.ClientState): import("../json-safe.ts").JsonSafe<_171.ClientState>;
                    fromPartial(object: Partial<_171.ClientState>): _171.ClientState;
                    fromProtoMsg(message: _171.ClientStateProtoMsg): _171.ClientState;
                    toProto(message: _171.ClientState): Uint8Array;
                    toProtoMsg(message: _171.ClientState): _171.ClientStateProtoMsg;
                };
                ConsensusState: {
                    typeUrl: "/ibc.lightclients.solomachine.v3.ConsensusState";
                    encode(message: _171.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.ConsensusState;
                    fromJSON(object: any): _171.ConsensusState;
                    toJSON(message: _171.ConsensusState): import("../json-safe.ts").JsonSafe<_171.ConsensusState>;
                    fromPartial(object: Partial<_171.ConsensusState>): _171.ConsensusState;
                    fromProtoMsg(message: _171.ConsensusStateProtoMsg): _171.ConsensusState;
                    toProto(message: _171.ConsensusState): Uint8Array;
                    toProtoMsg(message: _171.ConsensusState): _171.ConsensusStateProtoMsg;
                };
                Header: {
                    typeUrl: "/ibc.lightclients.solomachine.v3.Header";
                    encode(message: _171.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.Header;
                    fromJSON(object: any): _171.Header;
                    toJSON(message: _171.Header): import("../json-safe.ts").JsonSafe<_171.Header>;
                    fromPartial(object: Partial<_171.Header>): _171.Header;
                    fromProtoMsg(message: _171.HeaderProtoMsg): _171.Header;
                    toProto(message: _171.Header): Uint8Array;
                    toProtoMsg(message: _171.Header): _171.HeaderProtoMsg;
                };
                Misbehaviour: {
                    typeUrl: "/ibc.lightclients.solomachine.v3.Misbehaviour";
                    encode(message: _171.Misbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.Misbehaviour;
                    fromJSON(object: any): _171.Misbehaviour;
                    toJSON(message: _171.Misbehaviour): import("../json-safe.ts").JsonSafe<_171.Misbehaviour>;
                    fromPartial(object: Partial<_171.Misbehaviour>): _171.Misbehaviour;
                    fromProtoMsg(message: _171.MisbehaviourProtoMsg): _171.Misbehaviour;
                    toProto(message: _171.Misbehaviour): Uint8Array;
                    toProtoMsg(message: _171.Misbehaviour): _171.MisbehaviourProtoMsg;
                };
                SignatureAndData: {
                    typeUrl: "/ibc.lightclients.solomachine.v3.SignatureAndData";
                    encode(message: _171.SignatureAndData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.SignatureAndData;
                    fromJSON(object: any): _171.SignatureAndData;
                    toJSON(message: _171.SignatureAndData): import("../json-safe.ts").JsonSafe<_171.SignatureAndData>;
                    fromPartial(object: Partial<_171.SignatureAndData>): _171.SignatureAndData;
                    fromProtoMsg(message: _171.SignatureAndDataProtoMsg): _171.SignatureAndData;
                    toProto(message: _171.SignatureAndData): Uint8Array;
                    toProtoMsg(message: _171.SignatureAndData): _171.SignatureAndDataProtoMsg;
                };
                TimestampedSignatureData: {
                    typeUrl: "/ibc.lightclients.solomachine.v3.TimestampedSignatureData";
                    encode(message: _171.TimestampedSignatureData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.TimestampedSignatureData;
                    fromJSON(object: any): _171.TimestampedSignatureData;
                    toJSON(message: _171.TimestampedSignatureData): import("../json-safe.ts").JsonSafe<_171.TimestampedSignatureData>;
                    fromPartial(object: Partial<_171.TimestampedSignatureData>): _171.TimestampedSignatureData;
                    fromProtoMsg(message: _171.TimestampedSignatureDataProtoMsg): _171.TimestampedSignatureData;
                    toProto(message: _171.TimestampedSignatureData): Uint8Array;
                    toProtoMsg(message: _171.TimestampedSignatureData): _171.TimestampedSignatureDataProtoMsg;
                };
                SignBytes: {
                    typeUrl: "/ibc.lightclients.solomachine.v3.SignBytes";
                    encode(message: _171.SignBytes, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.SignBytes;
                    fromJSON(object: any): _171.SignBytes;
                    toJSON(message: _171.SignBytes): import("../json-safe.ts").JsonSafe<_171.SignBytes>;
                    fromPartial(object: Partial<_171.SignBytes>): _171.SignBytes;
                    fromProtoMsg(message: _171.SignBytesProtoMsg): _171.SignBytes;
                    toProto(message: _171.SignBytes): Uint8Array;
                    toProtoMsg(message: _171.SignBytes): _171.SignBytesProtoMsg;
                };
                HeaderData: {
                    typeUrl: "/ibc.lightclients.solomachine.v3.HeaderData";
                    encode(message: _171.HeaderData, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _171.HeaderData;
                    fromJSON(object: any): _171.HeaderData;
                    toJSON(message: _171.HeaderData): import("../json-safe.ts").JsonSafe<_171.HeaderData>;
                    fromPartial(object: Partial<_171.HeaderData>): _171.HeaderData;
                    fromProtoMsg(message: _171.HeaderDataProtoMsg): _171.HeaderData;
                    toProto(message: _171.HeaderData): Uint8Array;
                    toProtoMsg(message: _171.HeaderData): _171.HeaderDataProtoMsg;
                };
            };
        }
        namespace tendermint {
            const v1: {
                ClientState: {
                    typeUrl: "/ibc.lightclients.tendermint.v1.ClientState";
                    encode(message: _172.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.ClientState;
                    fromJSON(object: any): _172.ClientState;
                    toJSON(message: _172.ClientState): import("../json-safe.ts").JsonSafe<_172.ClientState>;
                    fromPartial(object: Partial<_172.ClientState>): _172.ClientState;
                    fromProtoMsg(message: _172.ClientStateProtoMsg): _172.ClientState;
                    toProto(message: _172.ClientState): Uint8Array;
                    toProtoMsg(message: _172.ClientState): _172.ClientStateProtoMsg;
                };
                ConsensusState: {
                    typeUrl: "/ibc.lightclients.tendermint.v1.ConsensusState";
                    encode(message: _172.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.ConsensusState;
                    fromJSON(object: any): _172.ConsensusState;
                    toJSON(message: _172.ConsensusState): import("../json-safe.ts").JsonSafe<_172.ConsensusState>;
                    fromPartial(object: Partial<_172.ConsensusState>): _172.ConsensusState;
                    fromProtoMsg(message: _172.ConsensusStateProtoMsg): _172.ConsensusState;
                    toProto(message: _172.ConsensusState): Uint8Array;
                    toProtoMsg(message: _172.ConsensusState): _172.ConsensusStateProtoMsg;
                };
                Misbehaviour: {
                    typeUrl: "/ibc.lightclients.tendermint.v1.Misbehaviour";
                    encode(message: _172.Misbehaviour, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.Misbehaviour;
                    fromJSON(object: any): _172.Misbehaviour;
                    toJSON(message: _172.Misbehaviour): import("../json-safe.ts").JsonSafe<_172.Misbehaviour>;
                    fromPartial(object: Partial<_172.Misbehaviour>): _172.Misbehaviour;
                    fromProtoMsg(message: _172.MisbehaviourProtoMsg): _172.Misbehaviour;
                    toProto(message: _172.Misbehaviour): Uint8Array;
                    toProtoMsg(message: _172.Misbehaviour): _172.MisbehaviourProtoMsg;
                };
                Header: {
                    typeUrl: "/ibc.lightclients.tendermint.v1.Header";
                    encode(message: _172.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.Header;
                    fromJSON(object: any): _172.Header;
                    toJSON(message: _172.Header): import("../json-safe.ts").JsonSafe<_172.Header>;
                    fromPartial(object: Partial<_172.Header>): _172.Header;
                    fromProtoMsg(message: _172.HeaderProtoMsg): _172.Header;
                    toProto(message: _172.Header): Uint8Array;
                    toProtoMsg(message: _172.Header): _172.HeaderProtoMsg;
                };
                Fraction: {
                    typeUrl: "/ibc.lightclients.tendermint.v1.Fraction";
                    encode(message: _172.Fraction, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _172.Fraction;
                    fromJSON(object: any): _172.Fraction;
                    toJSON(message: _172.Fraction): import("../json-safe.ts").JsonSafe<_172.Fraction>;
                    fromPartial(object: Partial<_172.Fraction>): _172.Fraction;
                    fromProtoMsg(message: _172.FractionProtoMsg): _172.Fraction;
                    toProto(message: _172.Fraction): Uint8Array;
                    toProtoMsg(message: _172.Fraction): _172.FractionProtoMsg;
                };
            };
        }
        namespace wasm {
            const v1: {
                ClientState: {
                    typeUrl: "/ibc.lightclients.wasm.v1.ClientState";
                    encode(message: _176.ClientState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.ClientState;
                    fromJSON(object: any): _176.ClientState;
                    toJSON(message: _176.ClientState): import("../json-safe.ts").JsonSafe<_176.ClientState>;
                    fromPartial(object: Partial<_176.ClientState>): _176.ClientState;
                    fromProtoMsg(message: _176.ClientStateProtoMsg): _176.ClientState;
                    toProto(message: _176.ClientState): Uint8Array;
                    toProtoMsg(message: _176.ClientState): _176.ClientStateProtoMsg;
                };
                ConsensusState: {
                    typeUrl: "/ibc.lightclients.wasm.v1.ConsensusState";
                    encode(message: _176.ConsensusState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.ConsensusState;
                    fromJSON(object: any): _176.ConsensusState;
                    toJSON(message: _176.ConsensusState): import("../json-safe.ts").JsonSafe<_176.ConsensusState>;
                    fromPartial(object: Partial<_176.ConsensusState>): _176.ConsensusState;
                    fromProtoMsg(message: _176.ConsensusStateProtoMsg): _176.ConsensusState;
                    toProto(message: _176.ConsensusState): Uint8Array;
                    toProtoMsg(message: _176.ConsensusState): _176.ConsensusStateProtoMsg;
                };
                ClientMessage: {
                    typeUrl: "/ibc.lightclients.wasm.v1.ClientMessage";
                    encode(message: _176.ClientMessage, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.ClientMessage;
                    fromJSON(object: any): _176.ClientMessage;
                    toJSON(message: _176.ClientMessage): import("../json-safe.ts").JsonSafe<_176.ClientMessage>;
                    fromPartial(object: Partial<_176.ClientMessage>): _176.ClientMessage;
                    fromProtoMsg(message: _176.ClientMessageProtoMsg): _176.ClientMessage;
                    toProto(message: _176.ClientMessage): Uint8Array;
                    toProtoMsg(message: _176.ClientMessage): _176.ClientMessageProtoMsg;
                };
                Checksums: {
                    typeUrl: "/ibc.lightclients.wasm.v1.Checksums";
                    encode(message: _176.Checksums, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _176.Checksums;
                    fromJSON(object: any): _176.Checksums;
                    toJSON(message: _176.Checksums): import("../json-safe.ts").JsonSafe<_176.Checksums>;
                    fromPartial(object: Partial<_176.Checksums>): _176.Checksums;
                    fromProtoMsg(message: _176.ChecksumsProtoMsg): _176.Checksums;
                    toProto(message: _176.Checksums): Uint8Array;
                    toProtoMsg(message: _176.Checksums): _176.ChecksumsProtoMsg;
                };
                MsgStoreCode: {
                    typeUrl: "/ibc.lightclients.wasm.v1.MsgStoreCode";
                    encode(message: _175.MsgStoreCode, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.MsgStoreCode;
                    fromJSON(object: any): _175.MsgStoreCode;
                    toJSON(message: _175.MsgStoreCode): import("../json-safe.ts").JsonSafe<_175.MsgStoreCode>;
                    fromPartial(object: Partial<_175.MsgStoreCode>): _175.MsgStoreCode;
                    fromProtoMsg(message: _175.MsgStoreCodeProtoMsg): _175.MsgStoreCode;
                    toProto(message: _175.MsgStoreCode): Uint8Array;
                    toProtoMsg(message: _175.MsgStoreCode): _175.MsgStoreCodeProtoMsg;
                };
                MsgStoreCodeResponse: {
                    typeUrl: "/ibc.lightclients.wasm.v1.MsgStoreCodeResponse";
                    encode(message: _175.MsgStoreCodeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.MsgStoreCodeResponse;
                    fromJSON(object: any): _175.MsgStoreCodeResponse;
                    toJSON(message: _175.MsgStoreCodeResponse): import("../json-safe.ts").JsonSafe<_175.MsgStoreCodeResponse>;
                    fromPartial(object: Partial<_175.MsgStoreCodeResponse>): _175.MsgStoreCodeResponse;
                    fromProtoMsg(message: _175.MsgStoreCodeResponseProtoMsg): _175.MsgStoreCodeResponse;
                    toProto(message: _175.MsgStoreCodeResponse): Uint8Array;
                    toProtoMsg(message: _175.MsgStoreCodeResponse): _175.MsgStoreCodeResponseProtoMsg;
                };
                MsgRemoveChecksum: {
                    typeUrl: "/ibc.lightclients.wasm.v1.MsgRemoveChecksum";
                    encode(message: _175.MsgRemoveChecksum, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.MsgRemoveChecksum;
                    fromJSON(object: any): _175.MsgRemoveChecksum;
                    toJSON(message: _175.MsgRemoveChecksum): import("../json-safe.ts").JsonSafe<_175.MsgRemoveChecksum>;
                    fromPartial(object: Partial<_175.MsgRemoveChecksum>): _175.MsgRemoveChecksum;
                    fromProtoMsg(message: _175.MsgRemoveChecksumProtoMsg): _175.MsgRemoveChecksum;
                    toProto(message: _175.MsgRemoveChecksum): Uint8Array;
                    toProtoMsg(message: _175.MsgRemoveChecksum): _175.MsgRemoveChecksumProtoMsg;
                };
                MsgRemoveChecksumResponse: {
                    typeUrl: "/ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse";
                    encode(_: _175.MsgRemoveChecksumResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.MsgRemoveChecksumResponse;
                    fromJSON(_: any): _175.MsgRemoveChecksumResponse;
                    toJSON(_: _175.MsgRemoveChecksumResponse): import("../json-safe.ts").JsonSafe<_175.MsgRemoveChecksumResponse>;
                    fromPartial(_: Partial<_175.MsgRemoveChecksumResponse>): _175.MsgRemoveChecksumResponse;
                    fromProtoMsg(message: _175.MsgRemoveChecksumResponseProtoMsg): _175.MsgRemoveChecksumResponse;
                    toProto(message: _175.MsgRemoveChecksumResponse): Uint8Array;
                    toProtoMsg(message: _175.MsgRemoveChecksumResponse): _175.MsgRemoveChecksumResponseProtoMsg;
                };
                MsgMigrateContract: {
                    typeUrl: "/ibc.lightclients.wasm.v1.MsgMigrateContract";
                    encode(message: _175.MsgMigrateContract, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.MsgMigrateContract;
                    fromJSON(object: any): _175.MsgMigrateContract;
                    toJSON(message: _175.MsgMigrateContract): import("../json-safe.ts").JsonSafe<_175.MsgMigrateContract>;
                    fromPartial(object: Partial<_175.MsgMigrateContract>): _175.MsgMigrateContract;
                    fromProtoMsg(message: _175.MsgMigrateContractProtoMsg): _175.MsgMigrateContract;
                    toProto(message: _175.MsgMigrateContract): Uint8Array;
                    toProtoMsg(message: _175.MsgMigrateContract): _175.MsgMigrateContractProtoMsg;
                };
                MsgMigrateContractResponse: {
                    typeUrl: "/ibc.lightclients.wasm.v1.MsgMigrateContractResponse";
                    encode(_: _175.MsgMigrateContractResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _175.MsgMigrateContractResponse;
                    fromJSON(_: any): _175.MsgMigrateContractResponse;
                    toJSON(_: _175.MsgMigrateContractResponse): import("../json-safe.ts").JsonSafe<_175.MsgMigrateContractResponse>;
                    fromPartial(_: Partial<_175.MsgMigrateContractResponse>): _175.MsgMigrateContractResponse;
                    fromProtoMsg(message: _175.MsgMigrateContractResponseProtoMsg): _175.MsgMigrateContractResponse;
                    toProto(message: _175.MsgMigrateContractResponse): Uint8Array;
                    toProtoMsg(message: _175.MsgMigrateContractResponse): _175.MsgMigrateContractResponseProtoMsg;
                };
                QueryChecksumsRequest: {
                    typeUrl: "/ibc.lightclients.wasm.v1.QueryChecksumsRequest";
                    encode(message: _174.QueryChecksumsRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryChecksumsRequest;
                    fromJSON(object: any): _174.QueryChecksumsRequest;
                    toJSON(message: _174.QueryChecksumsRequest): import("../json-safe.ts").JsonSafe<_174.QueryChecksumsRequest>;
                    fromPartial(object: Partial<_174.QueryChecksumsRequest>): _174.QueryChecksumsRequest;
                    fromProtoMsg(message: _174.QueryChecksumsRequestProtoMsg): _174.QueryChecksumsRequest;
                    toProto(message: _174.QueryChecksumsRequest): Uint8Array;
                    toProtoMsg(message: _174.QueryChecksumsRequest): _174.QueryChecksumsRequestProtoMsg;
                };
                QueryChecksumsResponse: {
                    typeUrl: "/ibc.lightclients.wasm.v1.QueryChecksumsResponse";
                    encode(message: _174.QueryChecksumsResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryChecksumsResponse;
                    fromJSON(object: any): _174.QueryChecksumsResponse;
                    toJSON(message: _174.QueryChecksumsResponse): import("../json-safe.ts").JsonSafe<_174.QueryChecksumsResponse>;
                    fromPartial(object: Partial<_174.QueryChecksumsResponse>): _174.QueryChecksumsResponse;
                    fromProtoMsg(message: _174.QueryChecksumsResponseProtoMsg): _174.QueryChecksumsResponse;
                    toProto(message: _174.QueryChecksumsResponse): Uint8Array;
                    toProtoMsg(message: _174.QueryChecksumsResponse): _174.QueryChecksumsResponseProtoMsg;
                };
                QueryCodeRequest: {
                    typeUrl: "/ibc.lightclients.wasm.v1.QueryCodeRequest";
                    encode(message: _174.QueryCodeRequest, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryCodeRequest;
                    fromJSON(object: any): _174.QueryCodeRequest;
                    toJSON(message: _174.QueryCodeRequest): import("../json-safe.ts").JsonSafe<_174.QueryCodeRequest>;
                    fromPartial(object: Partial<_174.QueryCodeRequest>): _174.QueryCodeRequest;
                    fromProtoMsg(message: _174.QueryCodeRequestProtoMsg): _174.QueryCodeRequest;
                    toProto(message: _174.QueryCodeRequest): Uint8Array;
                    toProtoMsg(message: _174.QueryCodeRequest): _174.QueryCodeRequestProtoMsg;
                };
                QueryCodeResponse: {
                    typeUrl: "/ibc.lightclients.wasm.v1.QueryCodeResponse";
                    encode(message: _174.QueryCodeResponse, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _174.QueryCodeResponse;
                    fromJSON(object: any): _174.QueryCodeResponse;
                    toJSON(message: _174.QueryCodeResponse): import("../json-safe.ts").JsonSafe<_174.QueryCodeResponse>;
                    fromPartial(object: Partial<_174.QueryCodeResponse>): _174.QueryCodeResponse;
                    fromProtoMsg(message: _174.QueryCodeResponseProtoMsg): _174.QueryCodeResponse;
                    toProto(message: _174.QueryCodeResponse): Uint8Array;
                    toProtoMsg(message: _174.QueryCodeResponse): _174.QueryCodeResponseProtoMsg;
                };
                GenesisState: {
                    typeUrl: "/ibc.lightclients.wasm.v1.GenesisState";
                    encode(message: _173.GenesisState, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _173.GenesisState;
                    fromJSON(object: any): _173.GenesisState;
                    toJSON(message: _173.GenesisState): import("../json-safe.ts").JsonSafe<_173.GenesisState>;
                    fromPartial(object: Partial<_173.GenesisState>): _173.GenesisState;
                    fromProtoMsg(message: _173.GenesisStateProtoMsg): _173.GenesisState;
                    toProto(message: _173.GenesisState): Uint8Array;
                    toProtoMsg(message: _173.GenesisState): _173.GenesisStateProtoMsg;
                };
                Contract: {
                    typeUrl: "/ibc.lightclients.wasm.v1.Contract";
                    encode(message: _173.Contract, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
                    decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _173.Contract;
                    fromJSON(object: any): _173.Contract;
                    toJSON(message: _173.Contract): import("../json-safe.ts").JsonSafe<_173.Contract>;
                    fromPartial(object: Partial<_173.Contract>): _173.Contract;
                    fromProtoMsg(message: _173.ContractProtoMsg): _173.Contract;
                    toProto(message: _173.Contract): Uint8Array;
                    toProtoMsg(message: _173.Contract): _173.ContractProtoMsg;
                };
            };
        }
    }
}
//# sourceMappingURL=bundle.d.ts.map