injectivejs 0.1.0 → 0.3.0

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

@@ -0,0 +1,4077 @@
+import * as _111 from "./applications/transfer/v1/genesis";
+import * as _112 from "./applications/transfer/v1/query";
+import * as _113 from "./applications/transfer/v1/transfer";
+import * as _114 from "./applications/transfer/v1/tx";
+import * as _115 from "./applications/transfer/v2/packet";
+import * as _116 from "./core/channel/v1/channel";
+import * as _117 from "./core/channel/v1/genesis";
+import * as _118 from "./core/channel/v1/query";
+import * as _119 from "./core/channel/v1/tx";
+import * as _120 from "./core/client/v1/client";
+import * as _121 from "./core/client/v1/genesis";
+import * as _122 from "./core/client/v1/query";
+import * as _123 from "./core/client/v1/tx";
+import * as _124 from "./core/commitment/v1/commitment";
+import * as _125 from "./core/connection/v1/connection";
+import * as _126 from "./core/connection/v1/genesis";
+import * as _127 from "./core/connection/v1/query";
+import * as _128 from "./core/connection/v1/tx";
+import * as _129 from "./core/port/v1/query";
+import * as _130 from "./core/types/v1/genesis";
+import * as _131 from "./lightclients/localhost/v1/localhost";
+import * as _132 from "./lightclients/solomachine/v1/solomachine";
+import * as _133 from "./lightclients/solomachine/v2/solomachine";
+import * as _134 from "./lightclients/tendermint/v1/tendermint";
+import * as _278 from "./applications/transfer/v1/query.lcd";
+import * as _279 from "./core/channel/v1/query.lcd";
+import * as _280 from "./core/client/v1/query.lcd";
+import * as _281 from "./core/connection/v1/query.lcd";
+import * as _282 from "./applications/transfer/v1/query.rpc.query";
+import * as _283 from "./core/channel/v1/query.rpc.query";
+import * as _284 from "./core/client/v1/query.rpc.query";
+import * as _285 from "./core/connection/v1/query.rpc.query";
+import * as _286 from "./core/port/v1/query.rpc.query";
+import * as _287 from "./applications/transfer/v1/tx.rpc.msg";
+import * as _288 from "./core/channel/v1/tx.rpc.msg";
+import * as _289 from "./core/client/v1/tx.rpc.msg";
+import * as _290 from "./core/connection/v1/tx.rpc.msg";
+export declare namespace ibc {
+    namespace applications {
+        namespace transfer {
+            const v1: {
+                MsgClientImpl: typeof _287.MsgClientImpl;
+                QueryClientImpl: typeof _282.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    denomTrace(request: _112.QueryDenomTraceRequest): Promise<_112.QueryDenomTraceResponse>;
+                    denomTraces(request?: _112.QueryDenomTracesRequest): Promise<_112.QueryDenomTracesResponse>;
+                    params(request?: _112.QueryParamsRequest): Promise<_112.QueryParamsResponse>;
+                };
+                LCDQueryClient: typeof _278.LCDQueryClient;
+                registry: readonly [string, import("@cosmjs/proto-signing").GeneratedType][];
+                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+                MessageComposer: {
+                    encoded: {
+                        transfer(value: _114.MsgTransfer): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                    };
+                    withTypeUrl: {
+                        transfer(value: _114.MsgTransfer): {
+                            typeUrl: string;
+                            value: _114.MsgTransfer;
+                        };
+                    };
+                    fromPartial: {
+                        transfer(value: _114.MsgTransfer): {
+                            typeUrl: string;
+                            value: _114.MsgTransfer;
+                        };
+                    };
+                };
+                AminoConverter: {
+                    "/ibc.applications.transfer.v1.MsgTransfer": {
+                        aminoType: string;
+                        toAmino: ({ sourcePort, sourceChannel, token, sender, receiver, timeoutHeight, timeoutTimestamp }: _114.MsgTransfer) => {
+                            source_port: string;
+                            source_channel: string;
+                            token: {
+                                denom: string;
+                                amount: string;
+                            };
+                            sender: string;
+                            receiver: string;
+                            timeout_height: import("@osmonauts/helpers").AminoHeight;
+                            timeout_timestamp: string;
+                        };
+                        fromAmino: ({ source_port, source_channel, token, sender, receiver, timeout_height, timeout_timestamp }: {
+                            source_port: string;
+                            source_channel: string;
+                            token: {
+                                denom: string;
+                                amount: string;
+                            };
+                            sender: string;
+                            receiver: string;
+                            timeout_height: import("@osmonauts/helpers").AminoHeight;
+                            timeout_timestamp: string;
+                        }) => _114.MsgTransfer;
+                    };
+                };
+                MsgTransfer: {
+                    encode(message: _114.MsgTransfer, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _114.MsgTransfer;
+                    fromPartial(object: {
+                        sourcePort?: string;
+                        sourceChannel?: string;
+                        token?: {
+                            denom?: string;
+                            amount?: string;
+                        };
+                        sender?: string;
+                        receiver?: string;
+                        timeoutHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        timeoutTimestamp?: any;
+                    }): _114.MsgTransfer;
+                };
+                MsgTransferResponse: {
+                    encode(_: _114.MsgTransferResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _114.MsgTransferResponse;
+                    fromPartial(_: {}): _114.MsgTransferResponse;
+                };
+                DenomTrace: {
+                    encode(message: _113.DenomTrace, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _113.DenomTrace;
+                    fromPartial(object: {
+                        path?: string;
+                        baseDenom?: string;
+                    }): _113.DenomTrace;
+                };
+                Params: {
+                    encode(message: _113.Params, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _113.Params;
+                    fromPartial(object: {
+                        sendEnabled?: boolean;
+                        receiveEnabled?: boolean;
+                    }): _113.Params;
+                };
+                QueryDenomTraceRequest: {
+                    encode(message: _112.QueryDenomTraceRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _112.QueryDenomTraceRequest;
+                    fromPartial(object: {
+                        hash?: string;
+                    }): _112.QueryDenomTraceRequest;
+                };
+                QueryDenomTraceResponse: {
+                    encode(message: _112.QueryDenomTraceResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _112.QueryDenomTraceResponse;
+                    fromPartial(object: {
+                        denomTrace?: {
+                            path?: string;
+                            baseDenom?: string;
+                        };
+                    }): _112.QueryDenomTraceResponse;
+                };
+                QueryDenomTracesRequest: {
+                    encode(message: _112.QueryDenomTracesRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _112.QueryDenomTracesRequest;
+                    fromPartial(object: {
+                        pagination?: {
+                            key?: Uint8Array;
+                            offset?: any;
+                            limit?: any;
+                            countTotal?: boolean;
+                            reverse?: boolean;
+                        };
+                    }): _112.QueryDenomTracesRequest;
+                };
+                QueryDenomTracesResponse: {
+                    encode(message: _112.QueryDenomTracesResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _112.QueryDenomTracesResponse;
+                    fromPartial(object: {
+                        denomTraces?: {
+                            path?: string;
+                            baseDenom?: string;
+                        }[];
+                        pagination?: {
+                            nextKey?: Uint8Array;
+                            total?: any;
+                        };
+                    }): _112.QueryDenomTracesResponse;
+                };
+                QueryParamsRequest: {
+                    encode(_: _112.QueryParamsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _112.QueryParamsRequest;
+                    fromPartial(_: {}): _112.QueryParamsRequest;
+                };
+                QueryParamsResponse: {
+                    encode(message: _112.QueryParamsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _112.QueryParamsResponse;
+                    fromPartial(object: {
+                        params?: {
+                            sendEnabled?: boolean;
+                            receiveEnabled?: boolean;
+                        };
+                    }): _112.QueryParamsResponse;
+                };
+                GenesisState: {
+                    encode(message: _111.GenesisState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _111.GenesisState;
+                    fromPartial(object: {
+                        portId?: string;
+                        denomTraces?: {
+                            path?: string;
+                            baseDenom?: string;
+                        }[];
+                        params?: {
+                            sendEnabled?: boolean;
+                            receiveEnabled?: boolean;
+                        };
+                    }): _111.GenesisState;
+                };
+            };
+            const v2: {
+                FungibleTokenPacketData: {
+                    encode(message: _115.FungibleTokenPacketData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _115.FungibleTokenPacketData;
+                    fromPartial(object: {
+                        denom?: string;
+                        amount?: string;
+                        sender?: string;
+                        receiver?: string;
+                    }): _115.FungibleTokenPacketData;
+                };
+            };
+        }
+    }
+    namespace core {
+        namespace channel {
+            const v1: {
+                MsgClientImpl: typeof _288.MsgClientImpl;
+                QueryClientImpl: typeof _283.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    channel(request: _118.QueryChannelRequest): Promise<_118.QueryChannelResponse>;
+                    channels(request?: _118.QueryChannelsRequest): Promise<_118.QueryChannelsResponse>;
+                    connectionChannels(request: _118.QueryConnectionChannelsRequest): Promise<_118.QueryConnectionChannelsResponse>;
+                    channelClientState(request: _118.QueryChannelClientStateRequest): Promise<_118.QueryChannelClientStateResponse>;
+                    channelConsensusState(request: _118.QueryChannelConsensusStateRequest): Promise<_118.QueryChannelConsensusStateResponse>;
+                    packetCommitment(request: _118.QueryPacketCommitmentRequest): Promise<_118.QueryPacketCommitmentResponse>;
+                    packetCommitments(request: _118.QueryPacketCommitmentsRequest): Promise<_118.QueryPacketCommitmentsResponse>;
+                    packetReceipt(request: _118.QueryPacketReceiptRequest): Promise<_118.QueryPacketReceiptResponse>;
+                    packetAcknowledgement(request: _118.QueryPacketAcknowledgementRequest): Promise<_118.QueryPacketAcknowledgementResponse>;
+                    packetAcknowledgements(request: _118.QueryPacketAcknowledgementsRequest): Promise<_118.QueryPacketAcknowledgementsResponse>;
+                    unreceivedPackets(request: _118.QueryUnreceivedPacketsRequest): Promise<_118.QueryUnreceivedPacketsResponse>;
+                    unreceivedAcks(request: _118.QueryUnreceivedAcksRequest): Promise<_118.QueryUnreceivedAcksResponse>;
+                    nextSequenceReceive(request: _118.QueryNextSequenceReceiveRequest): Promise<_118.QueryNextSequenceReceiveResponse>;
+                };
+                LCDQueryClient: typeof _279.LCDQueryClient;
+                registry: readonly [string, import("@cosmjs/proto-signing").GeneratedType][];
+                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+                MessageComposer: {
+                    encoded: {
+                        channelOpenInit(value: _119.MsgChannelOpenInit): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        channelOpenTry(value: _119.MsgChannelOpenTry): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        channelOpenAck(value: _119.MsgChannelOpenAck): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        channelOpenConfirm(value: _119.MsgChannelOpenConfirm): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        channelCloseInit(value: _119.MsgChannelCloseInit): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        channelCloseConfirm(value: _119.MsgChannelCloseConfirm): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        recvPacket(value: _119.MsgRecvPacket): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        timeout(value: _119.MsgTimeout): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        timeoutOnClose(value: _119.MsgTimeoutOnClose): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        acknowledgement(value: _119.MsgAcknowledgement): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                    };
+                    withTypeUrl: {
+                        channelOpenInit(value: _119.MsgChannelOpenInit): {
+                            typeUrl: string;
+                            value: _119.MsgChannelOpenInit;
+                        };
+                        channelOpenTry(value: _119.MsgChannelOpenTry): {
+                            typeUrl: string;
+                            value: _119.MsgChannelOpenTry;
+                        };
+                        channelOpenAck(value: _119.MsgChannelOpenAck): {
+                            typeUrl: string;
+                            value: _119.MsgChannelOpenAck;
+                        };
+                        channelOpenConfirm(value: _119.MsgChannelOpenConfirm): {
+                            typeUrl: string;
+                            value: _119.MsgChannelOpenConfirm;
+                        };
+                        channelCloseInit(value: _119.MsgChannelCloseInit): {
+                            typeUrl: string;
+                            value: _119.MsgChannelCloseInit;
+                        };
+                        channelCloseConfirm(value: _119.MsgChannelCloseConfirm): {
+                            typeUrl: string;
+                            value: _119.MsgChannelCloseConfirm;
+                        };
+                        recvPacket(value: _119.MsgRecvPacket): {
+                            typeUrl: string;
+                            value: _119.MsgRecvPacket;
+                        };
+                        timeout(value: _119.MsgTimeout): {
+                            typeUrl: string;
+                            value: _119.MsgTimeout;
+                        };
+                        timeoutOnClose(value: _119.MsgTimeoutOnClose): {
+                            typeUrl: string;
+                            value: _119.MsgTimeoutOnClose;
+                        };
+                        acknowledgement(value: _119.MsgAcknowledgement): {
+                            typeUrl: string;
+                            value: _119.MsgAcknowledgement;
+                        };
+                    };
+                    fromPartial: {
+                        channelOpenInit(value: _119.MsgChannelOpenInit): {
+                            typeUrl: string;
+                            value: _119.MsgChannelOpenInit;
+                        };
+                        channelOpenTry(value: _119.MsgChannelOpenTry): {
+                            typeUrl: string;
+                            value: _119.MsgChannelOpenTry;
+                        };
+                        channelOpenAck(value: _119.MsgChannelOpenAck): {
+                            typeUrl: string;
+                            value: _119.MsgChannelOpenAck;
+                        };
+                        channelOpenConfirm(value: _119.MsgChannelOpenConfirm): {
+                            typeUrl: string;
+                            value: _119.MsgChannelOpenConfirm;
+                        };
+                        channelCloseInit(value: _119.MsgChannelCloseInit): {
+                            typeUrl: string;
+                            value: _119.MsgChannelCloseInit;
+                        };
+                        channelCloseConfirm(value: _119.MsgChannelCloseConfirm): {
+                            typeUrl: string;
+                            value: _119.MsgChannelCloseConfirm;
+                        };
+                        recvPacket(value: _119.MsgRecvPacket): {
+                            typeUrl: string;
+                            value: _119.MsgRecvPacket;
+                        };
+                        timeout(value: _119.MsgTimeout): {
+                            typeUrl: string;
+                            value: _119.MsgTimeout;
+                        };
+                        timeoutOnClose(value: _119.MsgTimeoutOnClose): {
+                            typeUrl: string;
+                            value: _119.MsgTimeoutOnClose;
+                        };
+                        acknowledgement(value: _119.MsgAcknowledgement): {
+                            typeUrl: string;
+                            value: _119.MsgAcknowledgement;
+                        };
+                    };
+                };
+                AminoConverter: {
+                    "/ibc.core.channel.v1.MsgChannelOpenInit": {
+                        aminoType: string;
+                        toAmino: ({ portId, channel, signer }: _119.MsgChannelOpenInit) => {
+                            port_id: string;
+                            channel: {
+                                state: number;
+                                ordering: number;
+                                counterparty: {
+                                    port_id: string;
+                                    channel_id: string;
+                                };
+                                connection_hops: string[];
+                                version: string;
+                            };
+                            signer: string;
+                        };
+                        fromAmino: ({ port_id, channel, signer }: {
+                            port_id: string;
+                            channel: {
+                                state: number;
+                                ordering: number;
+                                counterparty: {
+                                    port_id: string;
+                                    channel_id: string;
+                                };
+                                connection_hops: string[];
+                                version: string;
+                            };
+                            signer: string;
+                        }) => _119.MsgChannelOpenInit;
+                    };
+                    "/ibc.core.channel.v1.MsgChannelOpenTry": {
+                        aminoType: string;
+                        toAmino: ({ portId, previousChannelId, channel, counterpartyVersion, proofInit, proofHeight, signer }: _119.MsgChannelOpenTry) => {
+                            port_id: string;
+                            previous_channel_id: string;
+                            channel: {
+                                state: number;
+                                ordering: number;
+                                counterparty: {
+                                    port_id: string;
+                                    channel_id: string;
+                                };
+                                connection_hops: string[];
+                                version: string;
+                            };
+                            counterparty_version: string;
+                            proof_init: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ port_id, previous_channel_id, channel, counterparty_version, proof_init, proof_height, signer }: {
+                            port_id: string;
+                            previous_channel_id: string;
+                            channel: {
+                                state: number;
+                                ordering: number;
+                                counterparty: {
+                                    port_id: string;
+                                    channel_id: string;
+                                };
+                                connection_hops: string[];
+                                version: string;
+                            };
+                            counterparty_version: string;
+                            proof_init: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _119.MsgChannelOpenTry;
+                    };
+                    "/ibc.core.channel.v1.MsgChannelOpenAck": {
+                        aminoType: string;
+                        toAmino: ({ portId, channelId, counterpartyChannelId, counterpartyVersion, proofTry, proofHeight, signer }: _119.MsgChannelOpenAck) => {
+                            port_id: string;
+                            channel_id: string;
+                            counterparty_channel_id: string;
+                            counterparty_version: string;
+                            proof_try: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ port_id, channel_id, counterparty_channel_id, counterparty_version, proof_try, proof_height, signer }: {
+                            port_id: string;
+                            channel_id: string;
+                            counterparty_channel_id: string;
+                            counterparty_version: string;
+                            proof_try: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _119.MsgChannelOpenAck;
+                    };
+                    "/ibc.core.channel.v1.MsgChannelOpenConfirm": {
+                        aminoType: string;
+                        toAmino: ({ portId, channelId, proofAck, proofHeight, signer }: _119.MsgChannelOpenConfirm) => {
+                            port_id: string;
+                            channel_id: string;
+                            proof_ack: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ port_id, channel_id, proof_ack, proof_height, signer }: {
+                            port_id: string;
+                            channel_id: string;
+                            proof_ack: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _119.MsgChannelOpenConfirm;
+                    };
+                    "/ibc.core.channel.v1.MsgChannelCloseInit": {
+                        aminoType: string;
+                        toAmino: ({ portId, channelId, signer }: _119.MsgChannelCloseInit) => {
+                            port_id: string;
+                            channel_id: string;
+                            signer: string;
+                        };
+                        fromAmino: ({ port_id, channel_id, signer }: {
+                            port_id: string;
+                            channel_id: string;
+                            signer: string;
+                        }) => _119.MsgChannelCloseInit;
+                    };
+                    "/ibc.core.channel.v1.MsgChannelCloseConfirm": {
+                        aminoType: string;
+                        toAmino: ({ portId, channelId, proofInit, proofHeight, signer }: _119.MsgChannelCloseConfirm) => {
+                            port_id: string;
+                            channel_id: string;
+                            proof_init: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ port_id, channel_id, proof_init, proof_height, signer }: {
+                            port_id: string;
+                            channel_id: string;
+                            proof_init: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _119.MsgChannelCloseConfirm;
+                    };
+                    "/ibc.core.channel.v1.MsgRecvPacket": {
+                        aminoType: string;
+                        toAmino: ({ packet, proofCommitment, proofHeight, signer }: _119.MsgRecvPacket) => {
+                            packet: {
+                                sequence: string;
+                                source_port: string;
+                                source_channel: string;
+                                destination_port: string;
+                                destination_channel: string;
+                                data: Uint8Array;
+                                timeout_height: import("@osmonauts/helpers").AminoHeight;
+                                timeout_timestamp: string;
+                            };
+                            proof_commitment: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ packet, proof_commitment, proof_height, signer }: {
+                            packet: {
+                                sequence: string;
+                                source_port: string;
+                                source_channel: string;
+                                destination_port: string;
+                                destination_channel: string;
+                                data: Uint8Array;
+                                timeout_height: import("@osmonauts/helpers").AminoHeight;
+                                timeout_timestamp: string;
+                            };
+                            proof_commitment: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _119.MsgRecvPacket;
+                    };
+                    "/ibc.core.channel.v1.MsgTimeout": {
+                        aminoType: string;
+                        toAmino: ({ packet, proofUnreceived, proofHeight, nextSequenceRecv, signer }: _119.MsgTimeout) => {
+                            packet: {
+                                sequence: string;
+                                source_port: string;
+                                source_channel: string;
+                                destination_port: string;
+                                destination_channel: string;
+                                data: Uint8Array;
+                                timeout_height: import("@osmonauts/helpers").AminoHeight;
+                                timeout_timestamp: string;
+                            };
+                            proof_unreceived: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            next_sequence_recv: string;
+                            signer: string;
+                        };
+                        fromAmino: ({ packet, proof_unreceived, proof_height, next_sequence_recv, signer }: {
+                            packet: {
+                                sequence: string;
+                                source_port: string;
+                                source_channel: string;
+                                destination_port: string;
+                                destination_channel: string;
+                                data: Uint8Array;
+                                timeout_height: import("@osmonauts/helpers").AminoHeight;
+                                timeout_timestamp: string;
+                            };
+                            proof_unreceived: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            next_sequence_recv: string;
+                            signer: string;
+                        }) => _119.MsgTimeout;
+                    };
+                    "/ibc.core.channel.v1.MsgTimeoutOnClose": {
+                        aminoType: string;
+                        toAmino: ({ packet, proofUnreceived, proofClose, proofHeight, nextSequenceRecv, signer }: _119.MsgTimeoutOnClose) => {
+                            packet: {
+                                sequence: string;
+                                source_port: string;
+                                source_channel: string;
+                                destination_port: string;
+                                destination_channel: string;
+                                data: Uint8Array;
+                                timeout_height: import("@osmonauts/helpers").AminoHeight;
+                                timeout_timestamp: string;
+                            };
+                            proof_unreceived: Uint8Array;
+                            proof_close: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            next_sequence_recv: string;
+                            signer: string;
+                        };
+                        fromAmino: ({ packet, proof_unreceived, proof_close, proof_height, next_sequence_recv, signer }: {
+                            packet: {
+                                sequence: string;
+                                source_port: string;
+                                source_channel: string;
+                                destination_port: string;
+                                destination_channel: string;
+                                data: Uint8Array;
+                                timeout_height: import("@osmonauts/helpers").AminoHeight;
+                                timeout_timestamp: string;
+                            };
+                            proof_unreceived: Uint8Array;
+                            proof_close: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            next_sequence_recv: string;
+                            signer: string;
+                        }) => _119.MsgTimeoutOnClose;
+                    };
+                    "/ibc.core.channel.v1.MsgAcknowledgement": {
+                        aminoType: string;
+                        toAmino: ({ packet, acknowledgement, proofAcked, proofHeight, signer }: _119.MsgAcknowledgement) => {
+                            packet: {
+                                sequence: string;
+                                source_port: string;
+                                source_channel: string;
+                                destination_port: string;
+                                destination_channel: string;
+                                data: Uint8Array;
+                                timeout_height: import("@osmonauts/helpers").AminoHeight;
+                                timeout_timestamp: string;
+                            };
+                            acknowledgement: Uint8Array;
+                            proof_acked: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ packet, acknowledgement, proof_acked, proof_height, signer }: {
+                            packet: {
+                                sequence: string;
+                                source_port: string;
+                                source_channel: string;
+                                destination_port: string;
+                                destination_channel: string;
+                                data: Uint8Array;
+                                timeout_height: import("@osmonauts/helpers").AminoHeight;
+                                timeout_timestamp: string;
+                            };
+                            acknowledgement: Uint8Array;
+                            proof_acked: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _119.MsgAcknowledgement;
+                    };
+                };
+                MsgChannelOpenInit: {
+                    encode(message: _119.MsgChannelOpenInit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelOpenInit;
+                    fromPartial(object: {
+                        portId?: string;
+                        channel?: {
+                            state?: _116.State;
+                            ordering?: _116.Order;
+                            counterparty?: {
+                                portId?: string;
+                                channelId?: string;
+                            };
+                            connectionHops?: string[];
+                            version?: string;
+                        };
+                        signer?: string;
+                    }): _119.MsgChannelOpenInit;
+                };
+                MsgChannelOpenInitResponse: {
+                    encode(_: _119.MsgChannelOpenInitResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelOpenInitResponse;
+                    fromPartial(_: {}): _119.MsgChannelOpenInitResponse;
+                };
+                MsgChannelOpenTry: {
+                    encode(message: _119.MsgChannelOpenTry, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelOpenTry;
+                    fromPartial(object: {
+                        portId?: string;
+                        previousChannelId?: string;
+                        channel?: {
+                            state?: _116.State;
+                            ordering?: _116.Order;
+                            counterparty?: {
+                                portId?: string;
+                                channelId?: string;
+                            };
+                            connectionHops?: string[];
+                            version?: string;
+                        };
+                        counterpartyVersion?: string;
+                        proofInit?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _119.MsgChannelOpenTry;
+                };
+                MsgChannelOpenTryResponse: {
+                    encode(_: _119.MsgChannelOpenTryResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelOpenTryResponse;
+                    fromPartial(_: {}): _119.MsgChannelOpenTryResponse;
+                };
+                MsgChannelOpenAck: {
+                    encode(message: _119.MsgChannelOpenAck, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelOpenAck;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        counterpartyChannelId?: string;
+                        counterpartyVersion?: string;
+                        proofTry?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _119.MsgChannelOpenAck;
+                };
+                MsgChannelOpenAckResponse: {
+                    encode(_: _119.MsgChannelOpenAckResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelOpenAckResponse;
+                    fromPartial(_: {}): _119.MsgChannelOpenAckResponse;
+                };
+                MsgChannelOpenConfirm: {
+                    encode(message: _119.MsgChannelOpenConfirm, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelOpenConfirm;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        proofAck?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _119.MsgChannelOpenConfirm;
+                };
+                MsgChannelOpenConfirmResponse: {
+                    encode(_: _119.MsgChannelOpenConfirmResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelOpenConfirmResponse;
+                    fromPartial(_: {}): _119.MsgChannelOpenConfirmResponse;
+                };
+                MsgChannelCloseInit: {
+                    encode(message: _119.MsgChannelCloseInit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelCloseInit;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        signer?: string;
+                    }): _119.MsgChannelCloseInit;
+                };
+                MsgChannelCloseInitResponse: {
+                    encode(_: _119.MsgChannelCloseInitResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelCloseInitResponse;
+                    fromPartial(_: {}): _119.MsgChannelCloseInitResponse;
+                };
+                MsgChannelCloseConfirm: {
+                    encode(message: _119.MsgChannelCloseConfirm, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelCloseConfirm;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        proofInit?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _119.MsgChannelCloseConfirm;
+                };
+                MsgChannelCloseConfirmResponse: {
+                    encode(_: _119.MsgChannelCloseConfirmResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgChannelCloseConfirmResponse;
+                    fromPartial(_: {}): _119.MsgChannelCloseConfirmResponse;
+                };
+                MsgRecvPacket: {
+                    encode(message: _119.MsgRecvPacket, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgRecvPacket;
+                    fromPartial(object: {
+                        packet?: {
+                            sequence?: any;
+                            sourcePort?: string;
+                            sourceChannel?: string;
+                            destinationPort?: string;
+                            destinationChannel?: string;
+                            data?: Uint8Array;
+                            timeoutHeight?: {
+                                revisionNumber?: any;
+                                revisionHeight?: any;
+                            };
+                            timeoutTimestamp?: any;
+                        };
+                        proofCommitment?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _119.MsgRecvPacket;
+                };
+                MsgRecvPacketResponse: {
+                    encode(_: _119.MsgRecvPacketResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgRecvPacketResponse;
+                    fromPartial(_: {}): _119.MsgRecvPacketResponse;
+                };
+                MsgTimeout: {
+                    encode(message: _119.MsgTimeout, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgTimeout;
+                    fromPartial(object: {
+                        packet?: {
+                            sequence?: any;
+                            sourcePort?: string;
+                            sourceChannel?: string;
+                            destinationPort?: string;
+                            destinationChannel?: string;
+                            data?: Uint8Array;
+                            timeoutHeight?: {
+                                revisionNumber?: any;
+                                revisionHeight?: any;
+                            };
+                            timeoutTimestamp?: any;
+                        };
+                        proofUnreceived?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        nextSequenceRecv?: any;
+                        signer?: string;
+                    }): _119.MsgTimeout;
+                };
+                MsgTimeoutResponse: {
+                    encode(_: _119.MsgTimeoutResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgTimeoutResponse;
+                    fromPartial(_: {}): _119.MsgTimeoutResponse;
+                };
+                MsgTimeoutOnClose: {
+                    encode(message: _119.MsgTimeoutOnClose, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgTimeoutOnClose;
+                    fromPartial(object: {
+                        packet?: {
+                            sequence?: any;
+                            sourcePort?: string;
+                            sourceChannel?: string;
+                            destinationPort?: string;
+                            destinationChannel?: string;
+                            data?: Uint8Array;
+                            timeoutHeight?: {
+                                revisionNumber?: any;
+                                revisionHeight?: any;
+                            };
+                            timeoutTimestamp?: any;
+                        };
+                        proofUnreceived?: Uint8Array;
+                        proofClose?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        nextSequenceRecv?: any;
+                        signer?: string;
+                    }): _119.MsgTimeoutOnClose;
+                };
+                MsgTimeoutOnCloseResponse: {
+                    encode(_: _119.MsgTimeoutOnCloseResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgTimeoutOnCloseResponse;
+                    fromPartial(_: {}): _119.MsgTimeoutOnCloseResponse;
+                };
+                MsgAcknowledgement: {
+                    encode(message: _119.MsgAcknowledgement, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgAcknowledgement;
+                    fromPartial(object: {
+                        packet?: {
+                            sequence?: any;
+                            sourcePort?: string;
+                            sourceChannel?: string;
+                            destinationPort?: string;
+                            destinationChannel?: string;
+                            data?: Uint8Array;
+                            timeoutHeight?: {
+                                revisionNumber?: any;
+                                revisionHeight?: any;
+                            };
+                            timeoutTimestamp?: any;
+                        };
+                        acknowledgement?: Uint8Array;
+                        proofAcked?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _119.MsgAcknowledgement;
+                };
+                MsgAcknowledgementResponse: {
+                    encode(_: _119.MsgAcknowledgementResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _119.MsgAcknowledgementResponse;
+                    fromPartial(_: {}): _119.MsgAcknowledgementResponse;
+                };
+                QueryChannelRequest: {
+                    encode(message: _118.QueryChannelRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryChannelRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                    }): _118.QueryChannelRequest;
+                };
+                QueryChannelResponse: {
+                    encode(message: _118.QueryChannelResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryChannelResponse;
+                    fromPartial(object: {
+                        channel?: {
+                            state?: _116.State;
+                            ordering?: _116.Order;
+                            counterparty?: {
+                                portId?: string;
+                                channelId?: string;
+                            };
+                            connectionHops?: string[];
+                            version?: string;
+                        };
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryChannelResponse;
+                };
+                QueryChannelsRequest: {
+                    encode(message: _118.QueryChannelsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryChannelsRequest;
+                    fromPartial(object: {
+                        pagination?: {
+                            key?: Uint8Array;
+                            offset?: any;
+                            limit?: any;
+                            countTotal?: boolean;
+                            reverse?: boolean;
+                        };
+                    }): _118.QueryChannelsRequest;
+                };
+                QueryChannelsResponse: {
+                    encode(message: _118.QueryChannelsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryChannelsResponse;
+                    fromPartial(object: {
+                        channels?: {
+                            state?: _116.State;
+                            ordering?: _116.Order;
+                            counterparty?: {
+                                portId?: string;
+                                channelId?: string;
+                            };
+                            connectionHops?: string[];
+                            version?: string;
+                            portId?: string;
+                            channelId?: string;
+                        }[];
+                        pagination?: {
+                            nextKey?: Uint8Array;
+                            total?: any;
+                        };
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryChannelsResponse;
+                };
+                QueryConnectionChannelsRequest: {
+                    encode(message: _118.QueryConnectionChannelsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryConnectionChannelsRequest;
+                    fromPartial(object: {
+                        connection?: string;
+                        pagination?: {
+                            key?: Uint8Array;
+                            offset?: any;
+                            limit?: any;
+                            countTotal?: boolean;
+                            reverse?: boolean;
+                        };
+                    }): _118.QueryConnectionChannelsRequest;
+                };
+                QueryConnectionChannelsResponse: {
+                    encode(message: _118.QueryConnectionChannelsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryConnectionChannelsResponse;
+                    fromPartial(object: {
+                        channels?: {
+                            state?: _116.State;
+                            ordering?: _116.Order;
+                            counterparty?: {
+                                portId?: string;
+                                channelId?: string;
+                            };
+                            connectionHops?: string[];
+                            version?: string;
+                            portId?: string;
+                            channelId?: string;
+                        }[];
+                        pagination?: {
+                            nextKey?: Uint8Array;
+                            total?: any;
+                        };
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryConnectionChannelsResponse;
+                };
+                QueryChannelClientStateRequest: {
+                    encode(message: _118.QueryChannelClientStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryChannelClientStateRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                    }): _118.QueryChannelClientStateRequest;
+                };
+                QueryChannelClientStateResponse: {
+                    encode(message: _118.QueryChannelClientStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryChannelClientStateResponse;
+                    fromPartial(object: {
+                        identifiedClientState?: {
+                            clientId?: string;
+                            clientState?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                        };
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryChannelClientStateResponse;
+                };
+                QueryChannelConsensusStateRequest: {
+                    encode(message: _118.QueryChannelConsensusStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryChannelConsensusStateRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        revisionNumber?: any;
+                        revisionHeight?: any;
+                    }): _118.QueryChannelConsensusStateRequest;
+                };
+                QueryChannelConsensusStateResponse: {
+                    encode(message: _118.QueryChannelConsensusStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryChannelConsensusStateResponse;
+                    fromPartial(object: {
+                        consensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        clientId?: string;
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryChannelConsensusStateResponse;
+                };
+                QueryPacketCommitmentRequest: {
+                    encode(message: _118.QueryPacketCommitmentRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketCommitmentRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        sequence?: any;
+                    }): _118.QueryPacketCommitmentRequest;
+                };
+                QueryPacketCommitmentResponse: {
+                    encode(message: _118.QueryPacketCommitmentResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketCommitmentResponse;
+                    fromPartial(object: {
+                        commitment?: Uint8Array;
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryPacketCommitmentResponse;
+                };
+                QueryPacketCommitmentsRequest: {
+                    encode(message: _118.QueryPacketCommitmentsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketCommitmentsRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        pagination?: {
+                            key?: Uint8Array;
+                            offset?: any;
+                            limit?: any;
+                            countTotal?: boolean;
+                            reverse?: boolean;
+                        };
+                    }): _118.QueryPacketCommitmentsRequest;
+                };
+                QueryPacketCommitmentsResponse: {
+                    encode(message: _118.QueryPacketCommitmentsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketCommitmentsResponse;
+                    fromPartial(object: {
+                        commitments?: {
+                            portId?: string;
+                            channelId?: string;
+                            sequence?: any;
+                            data?: Uint8Array;
+                        }[];
+                        pagination?: {
+                            nextKey?: Uint8Array;
+                            total?: any;
+                        };
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryPacketCommitmentsResponse;
+                };
+                QueryPacketReceiptRequest: {
+                    encode(message: _118.QueryPacketReceiptRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketReceiptRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        sequence?: any;
+                    }): _118.QueryPacketReceiptRequest;
+                };
+                QueryPacketReceiptResponse: {
+                    encode(message: _118.QueryPacketReceiptResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketReceiptResponse;
+                    fromPartial(object: {
+                        received?: boolean;
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryPacketReceiptResponse;
+                };
+                QueryPacketAcknowledgementRequest: {
+                    encode(message: _118.QueryPacketAcknowledgementRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketAcknowledgementRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        sequence?: any;
+                    }): _118.QueryPacketAcknowledgementRequest;
+                };
+                QueryPacketAcknowledgementResponse: {
+                    encode(message: _118.QueryPacketAcknowledgementResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketAcknowledgementResponse;
+                    fromPartial(object: {
+                        acknowledgement?: Uint8Array;
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryPacketAcknowledgementResponse;
+                };
+                QueryPacketAcknowledgementsRequest: {
+                    encode(message: _118.QueryPacketAcknowledgementsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketAcknowledgementsRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        pagination?: {
+                            key?: Uint8Array;
+                            offset?: any;
+                            limit?: any;
+                            countTotal?: boolean;
+                            reverse?: boolean;
+                        };
+                        packetCommitmentSequences?: any[];
+                    }): _118.QueryPacketAcknowledgementsRequest;
+                };
+                QueryPacketAcknowledgementsResponse: {
+                    encode(message: _118.QueryPacketAcknowledgementsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryPacketAcknowledgementsResponse;
+                    fromPartial(object: {
+                        acknowledgements?: {
+                            portId?: string;
+                            channelId?: string;
+                            sequence?: any;
+                            data?: Uint8Array;
+                        }[];
+                        pagination?: {
+                            nextKey?: Uint8Array;
+                            total?: any;
+                        };
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryPacketAcknowledgementsResponse;
+                };
+                QueryUnreceivedPacketsRequest: {
+                    encode(message: _118.QueryUnreceivedPacketsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryUnreceivedPacketsRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        packetCommitmentSequences?: any[];
+                    }): _118.QueryUnreceivedPacketsRequest;
+                };
+                QueryUnreceivedPacketsResponse: {
+                    encode(message: _118.QueryUnreceivedPacketsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryUnreceivedPacketsResponse;
+                    fromPartial(object: {
+                        sequences?: any[];
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryUnreceivedPacketsResponse;
+                };
+                QueryUnreceivedAcksRequest: {
+                    encode(message: _118.QueryUnreceivedAcksRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryUnreceivedAcksRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        packetAckSequences?: any[];
+                    }): _118.QueryUnreceivedAcksRequest;
+                };
+                QueryUnreceivedAcksResponse: {
+                    encode(message: _118.QueryUnreceivedAcksResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryUnreceivedAcksResponse;
+                    fromPartial(object: {
+                        sequences?: any[];
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryUnreceivedAcksResponse;
+                };
+                QueryNextSequenceReceiveRequest: {
+                    encode(message: _118.QueryNextSequenceReceiveRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryNextSequenceReceiveRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                    }): _118.QueryNextSequenceReceiveRequest;
+                };
+                QueryNextSequenceReceiveResponse: {
+                    encode(message: _118.QueryNextSequenceReceiveResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _118.QueryNextSequenceReceiveResponse;
+                    fromPartial(object: {
+                        nextSequenceReceive?: any;
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _118.QueryNextSequenceReceiveResponse;
+                };
+                GenesisState: {
+                    encode(message: _117.GenesisState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _117.GenesisState;
+                    fromPartial(object: {
+                        channels?: {
+                            state?: _116.State;
+                            ordering?: _116.Order;
+                            counterparty?: {
+                                portId?: string;
+                                channelId?: string;
+                            };
+                            connectionHops?: string[];
+                            version?: string;
+                            portId?: string;
+                            channelId?: string;
+                        }[];
+                        acknowledgements?: {
+                            portId?: string;
+                            channelId?: string;
+                            sequence?: any;
+                            data?: Uint8Array;
+                        }[];
+                        commitments?: {
+                            portId?: string;
+                            channelId?: string;
+                            sequence?: any;
+                            data?: Uint8Array;
+                        }[];
+                        receipts?: {
+                            portId?: string;
+                            channelId?: string;
+                            sequence?: any;
+                            data?: Uint8Array;
+                        }[];
+                        sendSequences?: {
+                            portId?: string;
+                            channelId?: string;
+                            sequence?: any;
+                        }[];
+                        recvSequences?: {
+                            portId?: string;
+                            channelId?: string;
+                            sequence?: any;
+                        }[];
+                        ackSequences?: {
+                            portId?: string;
+                            channelId?: string;
+                            sequence?: any;
+                        }[];
+                        nextChannelSequence?: any;
+                    }): _117.GenesisState;
+                };
+                PacketSequence: {
+                    encode(message: _117.PacketSequence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _117.PacketSequence;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        sequence?: any;
+                    }): _117.PacketSequence;
+                };
+                stateFromJSON(object: any): _116.State;
+                stateToJSON(object: _116.State): string;
+                orderFromJSON(object: any): _116.Order;
+                orderToJSON(object: _116.Order): string;
+                State: typeof _116.State;
+                StateSDKType: typeof _116.StateSDKType;
+                Order: typeof _116.Order;
+                OrderSDKType: typeof _116.OrderSDKType;
+                Channel: {
+                    encode(message: _116.Channel, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _116.Channel;
+                    fromPartial(object: {
+                        state?: _116.State;
+                        ordering?: _116.Order;
+                        counterparty?: {
+                            portId?: string;
+                            channelId?: string;
+                        };
+                        connectionHops?: string[];
+                        version?: string;
+                    }): _116.Channel;
+                };
+                IdentifiedChannel: {
+                    encode(message: _116.IdentifiedChannel, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _116.IdentifiedChannel;
+                    fromPartial(object: {
+                        state?: _116.State;
+                        ordering?: _116.Order;
+                        counterparty?: {
+                            portId?: string;
+                            channelId?: string;
+                        };
+                        connectionHops?: string[];
+                        version?: string;
+                        portId?: string;
+                        channelId?: string;
+                    }): _116.IdentifiedChannel;
+                };
+                Counterparty: {
+                    encode(message: _116.Counterparty, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _116.Counterparty;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                    }): _116.Counterparty;
+                };
+                Packet: {
+                    encode(message: _116.Packet, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _116.Packet;
+                    fromPartial(object: {
+                        sequence?: any;
+                        sourcePort?: string;
+                        sourceChannel?: string;
+                        destinationPort?: string;
+                        destinationChannel?: string;
+                        data?: Uint8Array;
+                        timeoutHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        timeoutTimestamp?: any;
+                    }): _116.Packet;
+                };
+                PacketState: {
+                    encode(message: _116.PacketState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _116.PacketState;
+                    fromPartial(object: {
+                        portId?: string;
+                        channelId?: string;
+                        sequence?: any;
+                        data?: Uint8Array;
+                    }): _116.PacketState;
+                };
+                Acknowledgement: {
+                    encode(message: _116.Acknowledgement, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _116.Acknowledgement;
+                    fromPartial(object: {
+                        result?: Uint8Array;
+                        error?: string;
+                    }): _116.Acknowledgement;
+                };
+            };
+        }
+        namespace client {
+            const v1: {
+                MsgClientImpl: typeof _289.MsgClientImpl;
+                QueryClientImpl: typeof _284.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    clientState(request: _122.QueryClientStateRequest): Promise<_122.QueryClientStateResponse>;
+                    clientStates(request?: _122.QueryClientStatesRequest): Promise<_122.QueryClientStatesResponse>;
+                    consensusState(request: _122.QueryConsensusStateRequest): Promise<_122.QueryConsensusStateResponse>;
+                    consensusStates(request: _122.QueryConsensusStatesRequest): Promise<_122.QueryConsensusStatesResponse>;
+                    clientStatus(request: _122.QueryClientStatusRequest): Promise<_122.QueryClientStatusResponse>;
+                    clientParams(request?: _122.QueryClientParamsRequest): Promise<_122.QueryClientParamsResponse>;
+                    upgradedClientState(request?: _122.QueryUpgradedClientStateRequest): Promise<_122.QueryUpgradedClientStateResponse>;
+                    upgradedConsensusState(request?: _122.QueryUpgradedConsensusStateRequest): Promise<_122.QueryUpgradedConsensusStateResponse>;
+                };
+                LCDQueryClient: typeof _280.LCDQueryClient;
+                registry: readonly [string, import("@cosmjs/proto-signing").GeneratedType][];
+                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+                MessageComposer: {
+                    encoded: {
+                        createClient(value: _123.MsgCreateClient): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        updateClient(value: _123.MsgUpdateClient): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        upgradeClient(value: _123.MsgUpgradeClient): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        submitMisbehaviour(value: _123.MsgSubmitMisbehaviour): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                    };
+                    withTypeUrl: {
+                        createClient(value: _123.MsgCreateClient): {
+                            typeUrl: string;
+                            value: _123.MsgCreateClient;
+                        };
+                        updateClient(value: _123.MsgUpdateClient): {
+                            typeUrl: string;
+                            value: _123.MsgUpdateClient;
+                        };
+                        upgradeClient(value: _123.MsgUpgradeClient): {
+                            typeUrl: string;
+                            value: _123.MsgUpgradeClient;
+                        };
+                        submitMisbehaviour(value: _123.MsgSubmitMisbehaviour): {
+                            typeUrl: string;
+                            value: _123.MsgSubmitMisbehaviour;
+                        };
+                    };
+                    fromPartial: {
+                        createClient(value: _123.MsgCreateClient): {
+                            typeUrl: string;
+                            value: _123.MsgCreateClient;
+                        };
+                        updateClient(value: _123.MsgUpdateClient): {
+                            typeUrl: string;
+                            value: _123.MsgUpdateClient;
+                        };
+                        upgradeClient(value: _123.MsgUpgradeClient): {
+                            typeUrl: string;
+                            value: _123.MsgUpgradeClient;
+                        };
+                        submitMisbehaviour(value: _123.MsgSubmitMisbehaviour): {
+                            typeUrl: string;
+                            value: _123.MsgSubmitMisbehaviour;
+                        };
+                    };
+                };
+                AminoConverter: {
+                    "/ibc.core.client.v1.MsgCreateClient": {
+                        aminoType: string;
+                        toAmino: ({ clientState, consensusState, signer }: _123.MsgCreateClient) => {
+                            client_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            consensus_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            signer: string;
+                        };
+                        fromAmino: ({ client_state, consensus_state, signer }: {
+                            client_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            consensus_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            signer: string;
+                        }) => _123.MsgCreateClient;
+                    };
+                    "/ibc.core.client.v1.MsgUpdateClient": {
+                        aminoType: string;
+                        toAmino: ({ clientId, header, signer }: _123.MsgUpdateClient) => {
+                            client_id: string;
+                            header: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            signer: string;
+                        };
+                        fromAmino: ({ client_id, header, signer }: {
+                            client_id: string;
+                            header: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            signer: string;
+                        }) => _123.MsgUpdateClient;
+                    };
+                    "/ibc.core.client.v1.MsgUpgradeClient": {
+                        aminoType: string;
+                        toAmino: ({ clientId, clientState, consensusState, proofUpgradeClient, proofUpgradeConsensusState, signer }: _123.MsgUpgradeClient) => {
+                            client_id: string;
+                            client_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            consensus_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            proof_upgrade_client: Uint8Array;
+                            proof_upgrade_consensus_state: Uint8Array;
+                            signer: string;
+                        };
+                        fromAmino: ({ client_id, client_state, consensus_state, proof_upgrade_client, proof_upgrade_consensus_state, signer }: {
+                            client_id: string;
+                            client_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            consensus_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            proof_upgrade_client: Uint8Array;
+                            proof_upgrade_consensus_state: Uint8Array;
+                            signer: string;
+                        }) => _123.MsgUpgradeClient;
+                    };
+                    "/ibc.core.client.v1.MsgSubmitMisbehaviour": {
+                        aminoType: string;
+                        toAmino: ({ clientId, misbehaviour, signer }: _123.MsgSubmitMisbehaviour) => {
+                            client_id: string;
+                            misbehaviour: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            signer: string;
+                        };
+                        fromAmino: ({ client_id, misbehaviour, signer }: {
+                            client_id: string;
+                            misbehaviour: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            signer: string;
+                        }) => _123.MsgSubmitMisbehaviour;
+                    };
+                };
+                MsgCreateClient: {
+                    encode(message: _123.MsgCreateClient, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _123.MsgCreateClient;
+                    fromPartial(object: {
+                        clientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        consensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        signer?: string;
+                    }): _123.MsgCreateClient;
+                };
+                MsgCreateClientResponse: {
+                    encode(_: _123.MsgCreateClientResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _123.MsgCreateClientResponse;
+                    fromPartial(_: {}): _123.MsgCreateClientResponse;
+                };
+                MsgUpdateClient: {
+                    encode(message: _123.MsgUpdateClient, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _123.MsgUpdateClient;
+                    fromPartial(object: {
+                        clientId?: string;
+                        header?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        signer?: string;
+                    }): _123.MsgUpdateClient;
+                };
+                MsgUpdateClientResponse: {
+                    encode(_: _123.MsgUpdateClientResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _123.MsgUpdateClientResponse;
+                    fromPartial(_: {}): _123.MsgUpdateClientResponse;
+                };
+                MsgUpgradeClient: {
+                    encode(message: _123.MsgUpgradeClient, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _123.MsgUpgradeClient;
+                    fromPartial(object: {
+                        clientId?: string;
+                        clientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        consensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        proofUpgradeClient?: Uint8Array;
+                        proofUpgradeConsensusState?: Uint8Array;
+                        signer?: string;
+                    }): _123.MsgUpgradeClient;
+                };
+                MsgUpgradeClientResponse: {
+                    encode(_: _123.MsgUpgradeClientResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _123.MsgUpgradeClientResponse;
+                    fromPartial(_: {}): _123.MsgUpgradeClientResponse;
+                };
+                MsgSubmitMisbehaviour: {
+                    encode(message: _123.MsgSubmitMisbehaviour, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _123.MsgSubmitMisbehaviour;
+                    fromPartial(object: {
+                        clientId?: string;
+                        misbehaviour?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        signer?: string;
+                    }): _123.MsgSubmitMisbehaviour;
+                };
+                MsgSubmitMisbehaviourResponse: {
+                    encode(_: _123.MsgSubmitMisbehaviourResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _123.MsgSubmitMisbehaviourResponse;
+                    fromPartial(_: {}): _123.MsgSubmitMisbehaviourResponse;
+                };
+                QueryClientStateRequest: {
+                    encode(message: _122.QueryClientStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryClientStateRequest;
+                    fromPartial(object: {
+                        clientId?: string;
+                    }): _122.QueryClientStateRequest;
+                };
+                QueryClientStateResponse: {
+                    encode(message: _122.QueryClientStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryClientStateResponse;
+                    fromPartial(object: {
+                        clientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _122.QueryClientStateResponse;
+                };
+                QueryClientStatesRequest: {
+                    encode(message: _122.QueryClientStatesRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryClientStatesRequest;
+                    fromPartial(object: {
+                        pagination?: {
+                            key?: Uint8Array;
+                            offset?: any;
+                            limit?: any;
+                            countTotal?: boolean;
+                            reverse?: boolean;
+                        };
+                    }): _122.QueryClientStatesRequest;
+                };
+                QueryClientStatesResponse: {
+                    encode(message: _122.QueryClientStatesResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryClientStatesResponse;
+                    fromPartial(object: {
+                        clientStates?: {
+                            clientId?: string;
+                            clientState?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                        }[];
+                        pagination?: {
+                            nextKey?: Uint8Array;
+                            total?: any;
+                        };
+                    }): _122.QueryClientStatesResponse;
+                };
+                QueryConsensusStateRequest: {
+                    encode(message: _122.QueryConsensusStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryConsensusStateRequest;
+                    fromPartial(object: {
+                        clientId?: string;
+                        revisionNumber?: any;
+                        revisionHeight?: any;
+                        latestHeight?: boolean;
+                    }): _122.QueryConsensusStateRequest;
+                };
+                QueryConsensusStateResponse: {
+                    encode(message: _122.QueryConsensusStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryConsensusStateResponse;
+                    fromPartial(object: {
+                        consensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _122.QueryConsensusStateResponse;
+                };
+                QueryConsensusStatesRequest: {
+                    encode(message: _122.QueryConsensusStatesRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryConsensusStatesRequest;
+                    fromPartial(object: {
+                        clientId?: string;
+                        pagination?: {
+                            key?: Uint8Array;
+                            offset?: any;
+                            limit?: any;
+                            countTotal?: boolean;
+                            reverse?: boolean;
+                        };
+                    }): _122.QueryConsensusStatesRequest;
+                };
+                QueryConsensusStatesResponse: {
+                    encode(message: _122.QueryConsensusStatesResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryConsensusStatesResponse;
+                    fromPartial(object: {
+                        consensusStates?: {
+                            height?: {
+                                revisionNumber?: any;
+                                revisionHeight?: any;
+                            };
+                            consensusState?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                        }[];
+                        pagination?: {
+                            nextKey?: Uint8Array;
+                            total?: any;
+                        };
+                    }): _122.QueryConsensusStatesResponse;
+                };
+                QueryClientStatusRequest: {
+                    encode(message: _122.QueryClientStatusRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryClientStatusRequest;
+                    fromPartial(object: {
+                        clientId?: string;
+                    }): _122.QueryClientStatusRequest;
+                };
+                QueryClientStatusResponse: {
+                    encode(message: _122.QueryClientStatusResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryClientStatusResponse;
+                    fromPartial(object: {
+                        status?: string;
+                    }): _122.QueryClientStatusResponse;
+                };
+                QueryClientParamsRequest: {
+                    encode(_: _122.QueryClientParamsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryClientParamsRequest;
+                    fromPartial(_: {}): _122.QueryClientParamsRequest;
+                };
+                QueryClientParamsResponse: {
+                    encode(message: _122.QueryClientParamsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryClientParamsResponse;
+                    fromPartial(object: {
+                        params?: {
+                            allowedClients?: string[];
+                        };
+                    }): _122.QueryClientParamsResponse;
+                };
+                QueryUpgradedClientStateRequest: {
+                    encode(_: _122.QueryUpgradedClientStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryUpgradedClientStateRequest;
+                    fromPartial(_: {}): _122.QueryUpgradedClientStateRequest;
+                };
+                QueryUpgradedClientStateResponse: {
+                    encode(message: _122.QueryUpgradedClientStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryUpgradedClientStateResponse;
+                    fromPartial(object: {
+                        upgradedClientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _122.QueryUpgradedClientStateResponse;
+                };
+                QueryUpgradedConsensusStateRequest: {
+                    encode(_: _122.QueryUpgradedConsensusStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryUpgradedConsensusStateRequest;
+                    fromPartial(_: {}): _122.QueryUpgradedConsensusStateRequest;
+                };
+                QueryUpgradedConsensusStateResponse: {
+                    encode(message: _122.QueryUpgradedConsensusStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _122.QueryUpgradedConsensusStateResponse;
+                    fromPartial(object: {
+                        upgradedConsensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _122.QueryUpgradedConsensusStateResponse;
+                };
+                GenesisState: {
+                    encode(message: _121.GenesisState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _121.GenesisState;
+                    fromPartial(object: {
+                        clients?: {
+                            clientId?: string;
+                            clientState?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                        }[];
+                        clientsConsensus?: {
+                            clientId?: string;
+                            consensusStates?: {
+                                height?: {
+                                    revisionNumber?: any;
+                                    revisionHeight?: any;
+                                };
+                                consensusState?: {
+                                    typeUrl?: string;
+                                    value?: Uint8Array;
+                                };
+                            }[];
+                        }[];
+                        clientsMetadata?: {
+                            clientId?: string;
+                            clientMetadata?: {
+                                key?: Uint8Array;
+                                value?: Uint8Array;
+                            }[];
+                        }[];
+                        params?: {
+                            allowedClients?: string[];
+                        };
+                        createLocalhost?: boolean;
+                        nextClientSequence?: any;
+                    }): _121.GenesisState;
+                };
+                GenesisMetadata: {
+                    encode(message: _121.GenesisMetadata, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _121.GenesisMetadata;
+                    fromPartial(object: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                    }): _121.GenesisMetadata;
+                };
+                IdentifiedGenesisMetadata: {
+                    encode(message: _121.IdentifiedGenesisMetadata, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _121.IdentifiedGenesisMetadata;
+                    fromPartial(object: {
+                        clientId?: string;
+                        clientMetadata?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                        }[];
+                    }): _121.IdentifiedGenesisMetadata;
+                };
+                IdentifiedClientState: {
+                    encode(message: _120.IdentifiedClientState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _120.IdentifiedClientState;
+                    fromPartial(object: {
+                        clientId?: string;
+                        clientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _120.IdentifiedClientState;
+                };
+                ConsensusStateWithHeight: {
+                    encode(message: _120.ConsensusStateWithHeight, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _120.ConsensusStateWithHeight;
+                    fromPartial(object: {
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        consensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _120.ConsensusStateWithHeight;
+                };
+                ClientConsensusStates: {
+                    encode(message: _120.ClientConsensusStates, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _120.ClientConsensusStates;
+                    fromPartial(object: {
+                        clientId?: string;
+                        consensusStates?: {
+                            height?: {
+                                revisionNumber?: any;
+                                revisionHeight?: any;
+                            };
+                            consensusState?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                        }[];
+                    }): _120.ClientConsensusStates;
+                };
+                ClientUpdateProposal: {
+                    encode(message: _120.ClientUpdateProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _120.ClientUpdateProposal;
+                    fromPartial(object: {
+                        title?: string;
+                        description?: string;
+                        subjectClientId?: string;
+                        substituteClientId?: string;
+                    }): _120.ClientUpdateProposal;
+                };
+                UpgradeProposal: {
+                    encode(message: _120.UpgradeProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _120.UpgradeProposal;
+                    fromPartial(object: {
+                        title?: string;
+                        description?: string;
+                        plan?: {
+                            name?: string;
+                            time?: Date;
+                            height?: any;
+                            info?: string;
+                            upgradedClientState?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                        };
+                        upgradedClientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _120.UpgradeProposal;
+                };
+                Height: {
+                    encode(message: _120.Height, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _120.Height;
+                    fromPartial(object: {
+                        revisionNumber?: any;
+                        revisionHeight?: any;
+                    }): _120.Height;
+                };
+                Params: {
+                    encode(message: _120.Params, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _120.Params;
+                    fromPartial(object: {
+                        allowedClients?: string[];
+                    }): _120.Params;
+                };
+            };
+        }
+        namespace commitment {
+            const v1: {
+                MerkleRoot: {
+                    encode(message: _124.MerkleRoot, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _124.MerkleRoot;
+                    fromPartial(object: {
+                        hash?: Uint8Array;
+                    }): _124.MerkleRoot;
+                };
+                MerklePrefix: {
+                    encode(message: _124.MerklePrefix, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _124.MerklePrefix;
+                    fromPartial(object: {
+                        keyPrefix?: Uint8Array;
+                    }): _124.MerklePrefix;
+                };
+                MerklePath: {
+                    encode(message: _124.MerklePath, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _124.MerklePath;
+                    fromPartial(object: {
+                        keyPath?: string[];
+                    }): _124.MerklePath;
+                };
+                MerkleProof: {
+                    encode(message: _124.MerkleProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _124.MerkleProof;
+                    fromPartial(object: {
+                        proofs?: {
+                            exist?: {
+                                key?: Uint8Array;
+                                value?: Uint8Array;
+                                leaf?: {
+                                    hash?: import("../confio/proofs").HashOp;
+                                    prehashKey?: import("../confio/proofs").HashOp;
+                                    prehashValue?: import("../confio/proofs").HashOp;
+                                    length?: import("../confio/proofs").LengthOp;
+                                    prefix?: Uint8Array;
+                                };
+                                path?: {
+                                    hash?: import("../confio/proofs").HashOp;
+                                    prefix?: Uint8Array;
+                                    suffix?: Uint8Array;
+                                }[];
+                            };
+                            nonexist?: {
+                                key?: Uint8Array;
+                                left?: {
+                                    key?: Uint8Array;
+                                    value?: Uint8Array;
+                                    leaf?: {
+                                        hash?: import("../confio/proofs").HashOp;
+                                        prehashKey?: import("../confio/proofs").HashOp;
+                                        prehashValue?: import("../confio/proofs").HashOp;
+                                        length?: import("../confio/proofs").LengthOp;
+                                        prefix?: Uint8Array;
+                                    };
+                                    path?: {
+                                        hash?: import("../confio/proofs").HashOp;
+                                        prefix?: Uint8Array;
+                                        suffix?: Uint8Array;
+                                    }[];
+                                };
+                                right?: {
+                                    key?: Uint8Array;
+                                    value?: Uint8Array;
+                                    leaf?: {
+                                        hash?: import("../confio/proofs").HashOp;
+                                        prehashKey?: import("../confio/proofs").HashOp;
+                                        prehashValue?: import("../confio/proofs").HashOp;
+                                        length?: import("../confio/proofs").LengthOp;
+                                        prefix?: Uint8Array;
+                                    };
+                                    path?: {
+                                        hash?: import("../confio/proofs").HashOp;
+                                        prefix?: Uint8Array;
+                                        suffix?: Uint8Array;
+                                    }[];
+                                };
+                            };
+                            batch?: {
+                                entries?: {
+                                    exist?: {
+                                        key?: Uint8Array;
+                                        value?: Uint8Array;
+                                        leaf?: {
+                                            hash?: import("../confio/proofs").HashOp;
+                                            prehashKey?: import("../confio/proofs").HashOp;
+                                            prehashValue?: import("../confio/proofs").HashOp;
+                                            length?: import("../confio/proofs").LengthOp;
+                                            prefix?: Uint8Array;
+                                        };
+                                        path?: {
+                                            hash?: import("../confio/proofs").HashOp;
+                                            prefix?: Uint8Array;
+                                            suffix?: Uint8Array;
+                                        }[];
+                                    };
+                                    nonexist?: {
+                                        key?: Uint8Array;
+                                        left?: {
+                                            key?: Uint8Array;
+                                            value?: Uint8Array;
+                                            leaf?: {
+                                                hash?: import("../confio/proofs").HashOp;
+                                                prehashKey?: import("../confio/proofs").HashOp;
+                                                prehashValue?: import("../confio/proofs").HashOp;
+                                                length?: import("../confio/proofs").LengthOp;
+                                                prefix?: Uint8Array;
+                                            };
+                                            path?: {
+                                                hash?: import("../confio/proofs").HashOp;
+                                                prefix?: Uint8Array;
+                                                suffix?: Uint8Array;
+                                            }[];
+                                        };
+                                        right?: {
+                                            key?: Uint8Array;
+                                            value?: Uint8Array;
+                                            leaf?: {
+                                                hash?: import("../confio/proofs").HashOp;
+                                                prehashKey?: import("../confio/proofs").HashOp;
+                                                prehashValue?: import("../confio/proofs").HashOp;
+                                                length?: import("../confio/proofs").LengthOp;
+                                                prefix?: Uint8Array;
+                                            };
+                                            path?: {
+                                                hash?: import("../confio/proofs").HashOp;
+                                                prefix?: Uint8Array;
+                                                suffix?: Uint8Array;
+                                            }[];
+                                        };
+                                    };
+                                }[];
+                            };
+                            compressed?: {
+                                entries?: {
+                                    exist?: {
+                                        key?: Uint8Array;
+                                        value?: Uint8Array;
+                                        leaf?: {
+                                            hash?: import("../confio/proofs").HashOp;
+                                            prehashKey?: import("../confio/proofs").HashOp;
+                                            prehashValue?: import("../confio/proofs").HashOp;
+                                            length?: import("../confio/proofs").LengthOp;
+                                            prefix?: Uint8Array;
+                                        };
+                                        path?: number[];
+                                    };
+                                    nonexist?: {
+                                        key?: Uint8Array;
+                                        left?: {
+                                            key?: Uint8Array;
+                                            value?: Uint8Array;
+                                            leaf?: {
+                                                hash?: import("../confio/proofs").HashOp;
+                                                prehashKey?: import("../confio/proofs").HashOp;
+                                                prehashValue?: import("../confio/proofs").HashOp;
+                                                length?: import("../confio/proofs").LengthOp;
+                                                prefix?: Uint8Array;
+                                            };
+                                            path?: number[];
+                                        };
+                                        right?: {
+                                            key?: Uint8Array;
+                                            value?: Uint8Array;
+                                            leaf?: {
+                                                hash?: import("../confio/proofs").HashOp;
+                                                prehashKey?: import("../confio/proofs").HashOp;
+                                                prehashValue?: import("../confio/proofs").HashOp;
+                                                length?: import("../confio/proofs").LengthOp;
+                                                prefix?: Uint8Array;
+                                            };
+                                            path?: number[];
+                                        };
+                                    };
+                                }[];
+                                lookupInners?: {
+                                    hash?: import("../confio/proofs").HashOp;
+                                    prefix?: Uint8Array;
+                                    suffix?: Uint8Array;
+                                }[];
+                            };
+                        }[];
+                    }): _124.MerkleProof;
+                };
+            };
+        }
+        namespace connection {
+            const v1: {
+                MsgClientImpl: typeof _290.MsgClientImpl;
+                QueryClientImpl: typeof _285.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    connection(request: _127.QueryConnectionRequest): Promise<_127.QueryConnectionResponse>;
+                    connections(request?: _127.QueryConnectionsRequest): Promise<_127.QueryConnectionsResponse>;
+                    clientConnections(request: _127.QueryClientConnectionsRequest): Promise<_127.QueryClientConnectionsResponse>;
+                    connectionClientState(request: _127.QueryConnectionClientStateRequest): Promise<_127.QueryConnectionClientStateResponse>;
+                    connectionConsensusState(request: _127.QueryConnectionConsensusStateRequest): Promise<_127.QueryConnectionConsensusStateResponse>;
+                };
+                LCDQueryClient: typeof _281.LCDQueryClient;
+                registry: readonly [string, import("@cosmjs/proto-signing").GeneratedType][];
+                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+                MessageComposer: {
+                    encoded: {
+                        connectionOpenInit(value: _128.MsgConnectionOpenInit): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        connectionOpenTry(value: _128.MsgConnectionOpenTry): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        connectionOpenAck(value: _128.MsgConnectionOpenAck): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                        connectionOpenConfirm(value: _128.MsgConnectionOpenConfirm): {
+                            typeUrl: string;
+                            value: Uint8Array;
+                        };
+                    };
+                    withTypeUrl: {
+                        connectionOpenInit(value: _128.MsgConnectionOpenInit): {
+                            typeUrl: string;
+                            value: _128.MsgConnectionOpenInit;
+                        };
+                        connectionOpenTry(value: _128.MsgConnectionOpenTry): {
+                            typeUrl: string;
+                            value: _128.MsgConnectionOpenTry;
+                        };
+                        connectionOpenAck(value: _128.MsgConnectionOpenAck): {
+                            typeUrl: string;
+                            value: _128.MsgConnectionOpenAck;
+                        };
+                        connectionOpenConfirm(value: _128.MsgConnectionOpenConfirm): {
+                            typeUrl: string;
+                            value: _128.MsgConnectionOpenConfirm;
+                        };
+                    };
+                    fromPartial: {
+                        connectionOpenInit(value: _128.MsgConnectionOpenInit): {
+                            typeUrl: string;
+                            value: _128.MsgConnectionOpenInit;
+                        };
+                        connectionOpenTry(value: _128.MsgConnectionOpenTry): {
+                            typeUrl: string;
+                            value: _128.MsgConnectionOpenTry;
+                        };
+                        connectionOpenAck(value: _128.MsgConnectionOpenAck): {
+                            typeUrl: string;
+                            value: _128.MsgConnectionOpenAck;
+                        };
+                        connectionOpenConfirm(value: _128.MsgConnectionOpenConfirm): {
+                            typeUrl: string;
+                            value: _128.MsgConnectionOpenConfirm;
+                        };
+                    };
+                };
+                AminoConverter: {
+                    "/ibc.core.connection.v1.MsgConnectionOpenInit": {
+                        aminoType: string;
+                        toAmino: ({ clientId, counterparty, version, delayPeriod, signer }: _128.MsgConnectionOpenInit) => {
+                            client_id: string;
+                            counterparty: {
+                                client_id: string;
+                                connection_id: string;
+                                prefix: {
+                                    key_prefix: Uint8Array;
+                                };
+                            };
+                            version: {
+                                identifier: string;
+                                features: string[];
+                            };
+                            delay_period: string;
+                            signer: string;
+                        };
+                        fromAmino: ({ client_id, counterparty, version, delay_period, signer }: {
+                            client_id: string;
+                            counterparty: {
+                                client_id: string;
+                                connection_id: string;
+                                prefix: {
+                                    key_prefix: Uint8Array;
+                                };
+                            };
+                            version: {
+                                identifier: string;
+                                features: string[];
+                            };
+                            delay_period: string;
+                            signer: string;
+                        }) => _128.MsgConnectionOpenInit;
+                    };
+                    "/ibc.core.connection.v1.MsgConnectionOpenTry": {
+                        aminoType: string;
+                        toAmino: ({ clientId, previousConnectionId, clientState, counterparty, delayPeriod, counterpartyVersions, proofHeight, proofInit, proofClient, proofConsensus, consensusHeight, signer }: _128.MsgConnectionOpenTry) => {
+                            client_id: string;
+                            previous_connection_id: string;
+                            client_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            counterparty: {
+                                client_id: string;
+                                connection_id: string;
+                                prefix: {
+                                    key_prefix: Uint8Array;
+                                };
+                            };
+                            delay_period: string;
+                            counterparty_versions: {
+                                identifier: string;
+                                features: string[];
+                            }[];
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            proof_init: Uint8Array;
+                            proof_client: Uint8Array;
+                            proof_consensus: Uint8Array;
+                            consensus_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ client_id, previous_connection_id, client_state, counterparty, delay_period, counterparty_versions, proof_height, proof_init, proof_client, proof_consensus, consensus_height, signer }: {
+                            client_id: string;
+                            previous_connection_id: string;
+                            client_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            counterparty: {
+                                client_id: string;
+                                connection_id: string;
+                                prefix: {
+                                    key_prefix: Uint8Array;
+                                };
+                            };
+                            delay_period: string;
+                            counterparty_versions: {
+                                identifier: string;
+                                features: string[];
+                            }[];
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            proof_init: Uint8Array;
+                            proof_client: Uint8Array;
+                            proof_consensus: Uint8Array;
+                            consensus_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _128.MsgConnectionOpenTry;
+                    };
+                    "/ibc.core.connection.v1.MsgConnectionOpenAck": {
+                        aminoType: string;
+                        toAmino: ({ connectionId, counterpartyConnectionId, version, clientState, proofHeight, proofTry, proofClient, proofConsensus, consensusHeight, signer }: _128.MsgConnectionOpenAck) => {
+                            connection_id: string;
+                            counterparty_connection_id: string;
+                            version: {
+                                identifier: string;
+                                features: string[];
+                            };
+                            client_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            proof_try: Uint8Array;
+                            proof_client: Uint8Array;
+                            proof_consensus: Uint8Array;
+                            consensus_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ connection_id, counterparty_connection_id, version, client_state, proof_height, proof_try, proof_client, proof_consensus, consensus_height, signer }: {
+                            connection_id: string;
+                            counterparty_connection_id: string;
+                            version: {
+                                identifier: string;
+                                features: string[];
+                            };
+                            client_state: {
+                                type_url: string;
+                                value: Uint8Array;
+                            };
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            proof_try: Uint8Array;
+                            proof_client: Uint8Array;
+                            proof_consensus: Uint8Array;
+                            consensus_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _128.MsgConnectionOpenAck;
+                    };
+                    "/ibc.core.connection.v1.MsgConnectionOpenConfirm": {
+                        aminoType: string;
+                        toAmino: ({ connectionId, proofAck, proofHeight, signer }: _128.MsgConnectionOpenConfirm) => {
+                            connection_id: string;
+                            proof_ack: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        };
+                        fromAmino: ({ connection_id, proof_ack, proof_height, signer }: {
+                            connection_id: string;
+                            proof_ack: Uint8Array;
+                            proof_height: import("@osmonauts/helpers").AminoHeight;
+                            signer: string;
+                        }) => _128.MsgConnectionOpenConfirm;
+                    };
+                };
+                MsgConnectionOpenInit: {
+                    encode(message: _128.MsgConnectionOpenInit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _128.MsgConnectionOpenInit;
+                    fromPartial(object: {
+                        clientId?: string;
+                        counterparty?: {
+                            clientId?: string;
+                            connectionId?: string;
+                            prefix?: {
+                                keyPrefix?: Uint8Array;
+                            };
+                        };
+                        version?: {
+                            identifier?: string;
+                            features?: string[];
+                        };
+                        delayPeriod?: any;
+                        signer?: string;
+                    }): _128.MsgConnectionOpenInit;
+                };
+                MsgConnectionOpenInitResponse: {
+                    encode(_: _128.MsgConnectionOpenInitResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _128.MsgConnectionOpenInitResponse;
+                    fromPartial(_: {}): _128.MsgConnectionOpenInitResponse;
+                };
+                MsgConnectionOpenTry: {
+                    encode(message: _128.MsgConnectionOpenTry, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _128.MsgConnectionOpenTry;
+                    fromPartial(object: {
+                        clientId?: string;
+                        previousConnectionId?: string;
+                        clientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        counterparty?: {
+                            clientId?: string;
+                            connectionId?: string;
+                            prefix?: {
+                                keyPrefix?: Uint8Array;
+                            };
+                        };
+                        delayPeriod?: any;
+                        counterpartyVersions?: {
+                            identifier?: string;
+                            features?: string[];
+                        }[];
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        proofInit?: Uint8Array;
+                        proofClient?: Uint8Array;
+                        proofConsensus?: Uint8Array;
+                        consensusHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _128.MsgConnectionOpenTry;
+                };
+                MsgConnectionOpenTryResponse: {
+                    encode(_: _128.MsgConnectionOpenTryResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _128.MsgConnectionOpenTryResponse;
+                    fromPartial(_: {}): _128.MsgConnectionOpenTryResponse;
+                };
+                MsgConnectionOpenAck: {
+                    encode(message: _128.MsgConnectionOpenAck, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _128.MsgConnectionOpenAck;
+                    fromPartial(object: {
+                        connectionId?: string;
+                        counterpartyConnectionId?: string;
+                        version?: {
+                            identifier?: string;
+                            features?: string[];
+                        };
+                        clientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        proofTry?: Uint8Array;
+                        proofClient?: Uint8Array;
+                        proofConsensus?: Uint8Array;
+                        consensusHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _128.MsgConnectionOpenAck;
+                };
+                MsgConnectionOpenAckResponse: {
+                    encode(_: _128.MsgConnectionOpenAckResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _128.MsgConnectionOpenAckResponse;
+                    fromPartial(_: {}): _128.MsgConnectionOpenAckResponse;
+                };
+                MsgConnectionOpenConfirm: {
+                    encode(message: _128.MsgConnectionOpenConfirm, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _128.MsgConnectionOpenConfirm;
+                    fromPartial(object: {
+                        connectionId?: string;
+                        proofAck?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        signer?: string;
+                    }): _128.MsgConnectionOpenConfirm;
+                };
+                MsgConnectionOpenConfirmResponse: {
+                    encode(_: _128.MsgConnectionOpenConfirmResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _128.MsgConnectionOpenConfirmResponse;
+                    fromPartial(_: {}): _128.MsgConnectionOpenConfirmResponse;
+                };
+                QueryConnectionRequest: {
+                    encode(message: _127.QueryConnectionRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryConnectionRequest;
+                    fromPartial(object: {
+                        connectionId?: string;
+                    }): _127.QueryConnectionRequest;
+                };
+                QueryConnectionResponse: {
+                    encode(message: _127.QueryConnectionResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryConnectionResponse;
+                    fromPartial(object: {
+                        connection?: {
+                            clientId?: string;
+                            versions?: {
+                                identifier?: string;
+                                features?: string[];
+                            }[];
+                            state?: _125.State;
+                            counterparty?: {
+                                clientId?: string;
+                                connectionId?: string;
+                                prefix?: {
+                                    keyPrefix?: Uint8Array;
+                                };
+                            };
+                            delayPeriod?: any;
+                        };
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _127.QueryConnectionResponse;
+                };
+                QueryConnectionsRequest: {
+                    encode(message: _127.QueryConnectionsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryConnectionsRequest;
+                    fromPartial(object: {
+                        pagination?: {
+                            key?: Uint8Array;
+                            offset?: any;
+                            limit?: any;
+                            countTotal?: boolean;
+                            reverse?: boolean;
+                        };
+                    }): _127.QueryConnectionsRequest;
+                };
+                QueryConnectionsResponse: {
+                    encode(message: _127.QueryConnectionsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryConnectionsResponse;
+                    fromPartial(object: {
+                        connections?: {
+                            id?: string;
+                            clientId?: string;
+                            versions?: {
+                                identifier?: string;
+                                features?: string[];
+                            }[];
+                            state?: _125.State;
+                            counterparty?: {
+                                clientId?: string;
+                                connectionId?: string;
+                                prefix?: {
+                                    keyPrefix?: Uint8Array;
+                                };
+                            };
+                            delayPeriod?: any;
+                        }[];
+                        pagination?: {
+                            nextKey?: Uint8Array;
+                            total?: any;
+                        };
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _127.QueryConnectionsResponse;
+                };
+                QueryClientConnectionsRequest: {
+                    encode(message: _127.QueryClientConnectionsRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryClientConnectionsRequest;
+                    fromPartial(object: {
+                        clientId?: string;
+                    }): _127.QueryClientConnectionsRequest;
+                };
+                QueryClientConnectionsResponse: {
+                    encode(message: _127.QueryClientConnectionsResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryClientConnectionsResponse;
+                    fromPartial(object: {
+                        connectionPaths?: string[];
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _127.QueryClientConnectionsResponse;
+                };
+                QueryConnectionClientStateRequest: {
+                    encode(message: _127.QueryConnectionClientStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryConnectionClientStateRequest;
+                    fromPartial(object: {
+                        connectionId?: string;
+                    }): _127.QueryConnectionClientStateRequest;
+                };
+                QueryConnectionClientStateResponse: {
+                    encode(message: _127.QueryConnectionClientStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryConnectionClientStateResponse;
+                    fromPartial(object: {
+                        identifiedClientState?: {
+                            clientId?: string;
+                            clientState?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                        };
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _127.QueryConnectionClientStateResponse;
+                };
+                QueryConnectionConsensusStateRequest: {
+                    encode(message: _127.QueryConnectionConsensusStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryConnectionConsensusStateRequest;
+                    fromPartial(object: {
+                        connectionId?: string;
+                        revisionNumber?: any;
+                        revisionHeight?: any;
+                    }): _127.QueryConnectionConsensusStateRequest;
+                };
+                QueryConnectionConsensusStateResponse: {
+                    encode(message: _127.QueryConnectionConsensusStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _127.QueryConnectionConsensusStateResponse;
+                    fromPartial(object: {
+                        consensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        clientId?: string;
+                        proof?: Uint8Array;
+                        proofHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _127.QueryConnectionConsensusStateResponse;
+                };
+                GenesisState: {
+                    encode(message: _126.GenesisState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _126.GenesisState;
+                    fromPartial(object: {
+                        connections?: {
+                            id?: string;
+                            clientId?: string;
+                            versions?: {
+                                identifier?: string;
+                                features?: string[];
+                            }[];
+                            state?: _125.State;
+                            counterparty?: {
+                                clientId?: string;
+                                connectionId?: string;
+                                prefix?: {
+                                    keyPrefix?: Uint8Array;
+                                };
+                            };
+                            delayPeriod?: any;
+                        }[];
+                        clientConnectionPaths?: {
+                            clientId?: string;
+                            paths?: string[];
+                        }[];
+                        nextConnectionSequence?: any;
+                        params?: {
+                            maxExpectedTimePerBlock?: any;
+                        };
+                    }): _126.GenesisState;
+                };
+                stateFromJSON(object: any): _125.State;
+                stateToJSON(object: _125.State): string;
+                State: typeof _125.State;
+                StateSDKType: typeof _125.StateSDKType;
+                ConnectionEnd: {
+                    encode(message: _125.ConnectionEnd, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _125.ConnectionEnd;
+                    fromPartial(object: {
+                        clientId?: string;
+                        versions?: {
+                            identifier?: string;
+                            features?: string[];
+                        }[];
+                        state?: _125.State;
+                        counterparty?: {
+                            clientId?: string;
+                            connectionId?: string;
+                            prefix?: {
+                                keyPrefix?: Uint8Array;
+                            };
+                        };
+                        delayPeriod?: any;
+                    }): _125.ConnectionEnd;
+                };
+                IdentifiedConnection: {
+                    encode(message: _125.IdentifiedConnection, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _125.IdentifiedConnection;
+                    fromPartial(object: {
+                        id?: string;
+                        clientId?: string;
+                        versions?: {
+                            identifier?: string;
+                            features?: string[];
+                        }[];
+                        state?: _125.State;
+                        counterparty?: {
+                            clientId?: string;
+                            connectionId?: string;
+                            prefix?: {
+                                keyPrefix?: Uint8Array;
+                            };
+                        };
+                        delayPeriod?: any;
+                    }): _125.IdentifiedConnection;
+                };
+                Counterparty: {
+                    encode(message: _125.Counterparty, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _125.Counterparty;
+                    fromPartial(object: {
+                        clientId?: string;
+                        connectionId?: string;
+                        prefix?: {
+                            keyPrefix?: Uint8Array;
+                        };
+                    }): _125.Counterparty;
+                };
+                ClientPaths: {
+                    encode(message: _125.ClientPaths, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _125.ClientPaths;
+                    fromPartial(object: {
+                        paths?: string[];
+                    }): _125.ClientPaths;
+                };
+                ConnectionPaths: {
+                    encode(message: _125.ConnectionPaths, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _125.ConnectionPaths;
+                    fromPartial(object: {
+                        clientId?: string;
+                        paths?: string[];
+                    }): _125.ConnectionPaths;
+                };
+                Version: {
+                    encode(message: _125.Version, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _125.Version;
+                    fromPartial(object: {
+                        identifier?: string;
+                        features?: string[];
+                    }): _125.Version;
+                };
+                Params: {
+                    encode(message: _125.Params, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _125.Params;
+                    fromPartial(object: {
+                        maxExpectedTimePerBlock?: any;
+                    }): _125.Params;
+                };
+            };
+        }
+        namespace port {
+            const v1: {
+                QueryClientImpl: typeof _286.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    appVersion(request: _129.QueryAppVersionRequest): Promise<_129.QueryAppVersionResponse>;
+                };
+                QueryAppVersionRequest: {
+                    encode(message: _129.QueryAppVersionRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _129.QueryAppVersionRequest;
+                    fromPartial(object: {
+                        portId?: string;
+                        connectionId?: string;
+                        ordering?: _116.Order;
+                        counterparty?: {
+                            portId?: string;
+                            channelId?: string;
+                        };
+                        proposedVersion?: string;
+                    }): _129.QueryAppVersionRequest;
+                };
+                QueryAppVersionResponse: {
+                    encode(message: _129.QueryAppVersionResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _129.QueryAppVersionResponse;
+                    fromPartial(object: {
+                        portId?: string;
+                        version?: string;
+                    }): _129.QueryAppVersionResponse;
+                };
+            };
+        }
+        namespace types {
+            const v1: {
+                GenesisState: {
+                    encode(message: _130.GenesisState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _130.GenesisState;
+                    fromPartial(object: {
+                        clientGenesis?: {
+                            clients?: {
+                                clientId?: string;
+                                clientState?: {
+                                    typeUrl?: string;
+                                    value?: Uint8Array;
+                                };
+                            }[];
+                            clientsConsensus?: {
+                                clientId?: string;
+                                consensusStates?: {
+                                    height?: {
+                                        revisionNumber?: any;
+                                        revisionHeight?: any;
+                                    };
+                                    consensusState?: {
+                                        typeUrl?: string;
+                                        value?: Uint8Array;
+                                    };
+                                }[];
+                            }[];
+                            clientsMetadata?: {
+                                clientId?: string;
+                                clientMetadata?: {
+                                    key?: Uint8Array;
+                                    value?: Uint8Array;
+                                }[];
+                            }[];
+                            params?: {
+                                allowedClients?: string[];
+                            };
+                            createLocalhost?: boolean;
+                            nextClientSequence?: any;
+                        };
+                        connectionGenesis?: {
+                            connections?: {
+                                id?: string;
+                                clientId?: string;
+                                versions?: {
+                                    identifier?: string;
+                                    features?: string[];
+                                }[];
+                                state?: _125.State;
+                                counterparty?: {
+                                    clientId?: string;
+                                    connectionId?: string;
+                                    prefix?: {
+                                        keyPrefix?: Uint8Array;
+                                    };
+                                };
+                                delayPeriod?: any;
+                            }[];
+                            clientConnectionPaths?: {
+                                clientId?: string;
+                                paths?: string[];
+                            }[];
+                            nextConnectionSequence?: any;
+                            params?: {
+                                maxExpectedTimePerBlock?: any;
+                            };
+                        };
+                        channelGenesis?: {
+                            channels?: {
+                                state?: _116.State;
+                                ordering?: _116.Order;
+                                counterparty?: {
+                                    portId?: string;
+                                    channelId?: string;
+                                };
+                                connectionHops?: string[];
+                                version?: string;
+                                portId?: string;
+                                channelId?: string;
+                            }[];
+                            acknowledgements?: {
+                                portId?: string;
+                                channelId?: string;
+                                sequence?: any;
+                                data?: Uint8Array;
+                            }[];
+                            commitments?: {
+                                portId?: string;
+                                channelId?: string;
+                                sequence?: any;
+                                data?: Uint8Array;
+                            }[];
+                            receipts?: {
+                                portId?: string;
+                                channelId?: string;
+                                sequence?: any;
+                                data?: Uint8Array;
+                            }[];
+                            sendSequences?: {
+                                portId?: string;
+                                channelId?: string;
+                                sequence?: any;
+                            }[];
+                            recvSequences?: {
+                                portId?: string;
+                                channelId?: string;
+                                sequence?: any;
+                            }[];
+                            ackSequences?: {
+                                portId?: string;
+                                channelId?: string;
+                                sequence?: any;
+                            }[];
+                            nextChannelSequence?: any;
+                        };
+                    }): _130.GenesisState;
+                };
+            };
+        }
+    }
+    namespace lightclients {
+        namespace localhost {
+            const v1: {
+                ClientState: {
+                    encode(message: _131.ClientState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _131.ClientState;
+                    fromPartial(object: {
+                        chainId?: string;
+                        height?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                    }): _131.ClientState;
+                };
+            };
+        }
+        namespace solomachine {
+            const v1: {
+                dataTypeFromJSON(object: any): _132.DataType;
+                dataTypeToJSON(object: _132.DataType): string;
+                DataType: typeof _132.DataType;
+                DataTypeSDKType: typeof _132.DataTypeSDKType;
+                ClientState: {
+                    encode(message: _132.ClientState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.ClientState;
+                    fromPartial(object: {
+                        sequence?: any;
+                        frozenSequence?: any;
+                        consensusState?: {
+                            publicKey?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                            diversifier?: string;
+                            timestamp?: any;
+                        };
+                        allowUpdateAfterProposal?: boolean;
+                    }): _132.ClientState;
+                };
+                ConsensusState: {
+                    encode(message: _132.ConsensusState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.ConsensusState;
+                    fromPartial(object: {
+                        publicKey?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        diversifier?: string;
+                        timestamp?: any;
+                    }): _132.ConsensusState;
+                };
+                Header: {
+                    encode(message: _132.Header, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.Header;
+                    fromPartial(object: {
+                        sequence?: any;
+                        timestamp?: any;
+                        signature?: Uint8Array;
+                        newPublicKey?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        newDiversifier?: string;
+                    }): _132.Header;
+                };
+                Misbehaviour: {
+                    encode(message: _132.Misbehaviour, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.Misbehaviour;
+                    fromPartial(object: {
+                        clientId?: string;
+                        sequence?: any;
+                        signatureOne?: {
+                            signature?: Uint8Array;
+                            dataType?: _132.DataType;
+                            data?: Uint8Array;
+                            timestamp?: any;
+                        };
+                        signatureTwo?: {
+                            signature?: Uint8Array;
+                            dataType?: _132.DataType;
+                            data?: Uint8Array;
+                            timestamp?: any;
+                        };
+                    }): _132.Misbehaviour;
+                };
+                SignatureAndData: {
+                    encode(message: _132.SignatureAndData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.SignatureAndData;
+                    fromPartial(object: {
+                        signature?: Uint8Array;
+                        dataType?: _132.DataType;
+                        data?: Uint8Array;
+                        timestamp?: any;
+                    }): _132.SignatureAndData;
+                };
+                TimestampedSignatureData: {
+                    encode(message: _132.TimestampedSignatureData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.TimestampedSignatureData;
+                    fromPartial(object: {
+                        signatureData?: Uint8Array;
+                        timestamp?: any;
+                    }): _132.TimestampedSignatureData;
+                };
+                SignBytes: {
+                    encode(message: _132.SignBytes, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.SignBytes;
+                    fromPartial(object: {
+                        sequence?: any;
+                        timestamp?: any;
+                        diversifier?: string;
+                        dataType?: _132.DataType;
+                        data?: Uint8Array;
+                    }): _132.SignBytes;
+                };
+                HeaderData: {
+                    encode(message: _132.HeaderData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.HeaderData;
+                    fromPartial(object: {
+                        newPubKey?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        newDiversifier?: string;
+                    }): _132.HeaderData;
+                };
+                ClientStateData: {
+                    encode(message: _132.ClientStateData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.ClientStateData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        clientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _132.ClientStateData;
+                };
+                ConsensusStateData: {
+                    encode(message: _132.ConsensusStateData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.ConsensusStateData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        consensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _132.ConsensusStateData;
+                };
+                ConnectionStateData: {
+                    encode(message: _132.ConnectionStateData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.ConnectionStateData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        connection?: {
+                            clientId?: string;
+                            versions?: {
+                                identifier?: string;
+                                features?: string[];
+                            }[];
+                            state?: _125.State;
+                            counterparty?: {
+                                clientId?: string;
+                                connectionId?: string;
+                                prefix?: {
+                                    keyPrefix?: Uint8Array;
+                                };
+                            };
+                            delayPeriod?: any;
+                        };
+                    }): _132.ConnectionStateData;
+                };
+                ChannelStateData: {
+                    encode(message: _132.ChannelStateData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.ChannelStateData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        channel?: {
+                            state?: _116.State;
+                            ordering?: _116.Order;
+                            counterparty?: {
+                                portId?: string;
+                                channelId?: string;
+                            };
+                            connectionHops?: string[];
+                            version?: string;
+                        };
+                    }): _132.ChannelStateData;
+                };
+                PacketCommitmentData: {
+                    encode(message: _132.PacketCommitmentData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.PacketCommitmentData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        commitment?: Uint8Array;
+                    }): _132.PacketCommitmentData;
+                };
+                PacketAcknowledgementData: {
+                    encode(message: _132.PacketAcknowledgementData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.PacketAcknowledgementData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        acknowledgement?: Uint8Array;
+                    }): _132.PacketAcknowledgementData;
+                };
+                PacketReceiptAbsenceData: {
+                    encode(message: _132.PacketReceiptAbsenceData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.PacketReceiptAbsenceData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                    }): _132.PacketReceiptAbsenceData;
+                };
+                NextSequenceRecvData: {
+                    encode(message: _132.NextSequenceRecvData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _132.NextSequenceRecvData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        nextSeqRecv?: any;
+                    }): _132.NextSequenceRecvData;
+                };
+            };
+            const v2: {
+                dataTypeFromJSON(object: any): _133.DataType;
+                dataTypeToJSON(object: _133.DataType): string;
+                DataType: typeof _133.DataType;
+                DataTypeSDKType: typeof _133.DataTypeSDKType;
+                ClientState: {
+                    encode(message: _133.ClientState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.ClientState;
+                    fromPartial(object: {
+                        sequence?: any;
+                        isFrozen?: boolean;
+                        consensusState?: {
+                            publicKey?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                            diversifier?: string;
+                            timestamp?: any;
+                        };
+                        allowUpdateAfterProposal?: boolean;
+                    }): _133.ClientState;
+                };
+                ConsensusState: {
+                    encode(message: _133.ConsensusState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.ConsensusState;
+                    fromPartial(object: {
+                        publicKey?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        diversifier?: string;
+                        timestamp?: any;
+                    }): _133.ConsensusState;
+                };
+                Header: {
+                    encode(message: _133.Header, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.Header;
+                    fromPartial(object: {
+                        sequence?: any;
+                        timestamp?: any;
+                        signature?: Uint8Array;
+                        newPublicKey?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        newDiversifier?: string;
+                    }): _133.Header;
+                };
+                Misbehaviour: {
+                    encode(message: _133.Misbehaviour, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.Misbehaviour;
+                    fromPartial(object: {
+                        clientId?: string;
+                        sequence?: any;
+                        signatureOne?: {
+                            signature?: Uint8Array;
+                            dataType?: _133.DataType;
+                            data?: Uint8Array;
+                            timestamp?: any;
+                        };
+                        signatureTwo?: {
+                            signature?: Uint8Array;
+                            dataType?: _133.DataType;
+                            data?: Uint8Array;
+                            timestamp?: any;
+                        };
+                    }): _133.Misbehaviour;
+                };
+                SignatureAndData: {
+                    encode(message: _133.SignatureAndData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.SignatureAndData;
+                    fromPartial(object: {
+                        signature?: Uint8Array;
+                        dataType?: _133.DataType;
+                        data?: Uint8Array;
+                        timestamp?: any;
+                    }): _133.SignatureAndData;
+                };
+                TimestampedSignatureData: {
+                    encode(message: _133.TimestampedSignatureData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.TimestampedSignatureData;
+                    fromPartial(object: {
+                        signatureData?: Uint8Array;
+                        timestamp?: any;
+                    }): _133.TimestampedSignatureData;
+                };
+                SignBytes: {
+                    encode(message: _133.SignBytes, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.SignBytes;
+                    fromPartial(object: {
+                        sequence?: any;
+                        timestamp?: any;
+                        diversifier?: string;
+                        dataType?: _133.DataType;
+                        data?: Uint8Array;
+                    }): _133.SignBytes;
+                };
+                HeaderData: {
+                    encode(message: _133.HeaderData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.HeaderData;
+                    fromPartial(object: {
+                        newPubKey?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                        newDiversifier?: string;
+                    }): _133.HeaderData;
+                };
+                ClientStateData: {
+                    encode(message: _133.ClientStateData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.ClientStateData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        clientState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _133.ClientStateData;
+                };
+                ConsensusStateData: {
+                    encode(message: _133.ConsensusStateData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.ConsensusStateData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        consensusState?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    }): _133.ConsensusStateData;
+                };
+                ConnectionStateData: {
+                    encode(message: _133.ConnectionStateData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.ConnectionStateData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        connection?: {
+                            clientId?: string;
+                            versions?: {
+                                identifier?: string;
+                                features?: string[];
+                            }[];
+                            state?: _125.State;
+                            counterparty?: {
+                                clientId?: string;
+                                connectionId?: string;
+                                prefix?: {
+                                    keyPrefix?: Uint8Array;
+                                };
+                            };
+                            delayPeriod?: any;
+                        };
+                    }): _133.ConnectionStateData;
+                };
+                ChannelStateData: {
+                    encode(message: _133.ChannelStateData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.ChannelStateData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        channel?: {
+                            state?: _116.State;
+                            ordering?: _116.Order;
+                            counterparty?: {
+                                portId?: string;
+                                channelId?: string;
+                            };
+                            connectionHops?: string[];
+                            version?: string;
+                        };
+                    }): _133.ChannelStateData;
+                };
+                PacketCommitmentData: {
+                    encode(message: _133.PacketCommitmentData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.PacketCommitmentData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        commitment?: Uint8Array;
+                    }): _133.PacketCommitmentData;
+                };
+                PacketAcknowledgementData: {
+                    encode(message: _133.PacketAcknowledgementData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.PacketAcknowledgementData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        acknowledgement?: Uint8Array;
+                    }): _133.PacketAcknowledgementData;
+                };
+                PacketReceiptAbsenceData: {
+                    encode(message: _133.PacketReceiptAbsenceData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.PacketReceiptAbsenceData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                    }): _133.PacketReceiptAbsenceData;
+                };
+                NextSequenceRecvData: {
+                    encode(message: _133.NextSequenceRecvData, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _133.NextSequenceRecvData;
+                    fromPartial(object: {
+                        path?: Uint8Array;
+                        nextSeqRecv?: any;
+                    }): _133.NextSequenceRecvData;
+                };
+            };
+        }
+        namespace tendermint {
+            const v1: {
+                ClientState: {
+                    encode(message: _134.ClientState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _134.ClientState;
+                    fromPartial(object: {
+                        chainId?: string;
+                        trustLevel?: {
+                            numerator?: any;
+                            denominator?: any;
+                        };
+                        trustingPeriod?: {
+                            seconds?: any;
+                            nanos?: number;
+                        };
+                        unbondingPeriod?: {
+                            seconds?: any;
+                            nanos?: number;
+                        };
+                        maxClockDrift?: {
+                            seconds?: any;
+                            nanos?: number;
+                        };
+                        frozenHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        latestHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        proofSpecs?: {
+                            leafSpec?: {
+                                hash?: import("../confio/proofs").HashOp;
+                                prehashKey?: import("../confio/proofs").HashOp;
+                                prehashValue?: import("../confio/proofs").HashOp;
+                                length?: import("../confio/proofs").LengthOp;
+                                prefix?: Uint8Array;
+                            };
+                            innerSpec?: {
+                                childOrder?: number[];
+                                childSize?: number;
+                                minPrefixLength?: number;
+                                maxPrefixLength?: number;
+                                emptyChild?: Uint8Array;
+                                hash?: import("../confio/proofs").HashOp;
+                            };
+                            maxDepth?: number;
+                            minDepth?: number;
+                        }[];
+                        upgradePath?: string[];
+                        allowUpdateAfterExpiry?: boolean;
+                        allowUpdateAfterMisbehaviour?: boolean;
+                    }): _134.ClientState;
+                };
+                ConsensusState: {
+                    encode(message: _134.ConsensusState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _134.ConsensusState;
+                    fromPartial(object: {
+                        timestamp?: Date;
+                        root?: {
+                            hash?: Uint8Array;
+                        };
+                        nextValidatorsHash?: Uint8Array;
+                    }): _134.ConsensusState;
+                };
+                Misbehaviour: {
+                    encode(message: _134.Misbehaviour, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _134.Misbehaviour;
+                    fromPartial(object: {
+                        clientId?: string;
+                        header_1?: {
+                            signedHeader?: {
+                                header?: {
+                                    version?: {
+                                        block?: any;
+                                        app?: any;
+                                    };
+                                    chainId?: string;
+                                    height?: any;
+                                    time?: Date;
+                                    lastBlockId?: {
+                                        hash?: Uint8Array;
+                                        partSetHeader?: {
+                                            total?: number;
+                                            hash?: Uint8Array;
+                                        };
+                                    };
+                                    lastCommitHash?: Uint8Array;
+                                    dataHash?: Uint8Array;
+                                    validatorsHash?: Uint8Array;
+                                    nextValidatorsHash?: Uint8Array;
+                                    consensusHash?: Uint8Array;
+                                    appHash?: Uint8Array;
+                                    lastResultsHash?: Uint8Array;
+                                    evidenceHash?: Uint8Array;
+                                    proposerAddress?: Uint8Array;
+                                };
+                                commit?: {
+                                    height?: any;
+                                    round?: number;
+                                    blockId?: {
+                                        hash?: Uint8Array;
+                                        partSetHeader?: {
+                                            total?: number;
+                                            hash?: Uint8Array;
+                                        };
+                                    };
+                                    signatures?: {
+                                        blockIdFlag?: import("../tendermint/types/types").BlockIDFlag;
+                                        validatorAddress?: Uint8Array;
+                                        timestamp?: Date;
+                                        signature?: Uint8Array;
+                                    }[];
+                                };
+                            };
+                            validatorSet?: {
+                                validators?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                }[];
+                                proposer?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                };
+                                totalVotingPower?: any;
+                            };
+                            trustedHeight?: {
+                                revisionNumber?: any;
+                                revisionHeight?: any;
+                            };
+                            trustedValidators?: {
+                                validators?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                }[];
+                                proposer?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                };
+                                totalVotingPower?: any;
+                            };
+                        };
+                        header_2?: {
+                            signedHeader?: {
+                                header?: {
+                                    version?: {
+                                        block?: any;
+                                        app?: any;
+                                    };
+                                    chainId?: string;
+                                    height?: any;
+                                    time?: Date;
+                                    lastBlockId?: {
+                                        hash?: Uint8Array;
+                                        partSetHeader?: {
+                                            total?: number;
+                                            hash?: Uint8Array;
+                                        };
+                                    };
+                                    lastCommitHash?: Uint8Array;
+                                    dataHash?: Uint8Array;
+                                    validatorsHash?: Uint8Array;
+                                    nextValidatorsHash?: Uint8Array;
+                                    consensusHash?: Uint8Array;
+                                    appHash?: Uint8Array;
+                                    lastResultsHash?: Uint8Array;
+                                    evidenceHash?: Uint8Array;
+                                    proposerAddress?: Uint8Array;
+                                };
+                                commit?: {
+                                    height?: any;
+                                    round?: number;
+                                    blockId?: {
+                                        hash?: Uint8Array;
+                                        partSetHeader?: {
+                                            total?: number;
+                                            hash?: Uint8Array;
+                                        };
+                                    };
+                                    signatures?: {
+                                        blockIdFlag?: import("../tendermint/types/types").BlockIDFlag;
+                                        validatorAddress?: Uint8Array;
+                                        timestamp?: Date;
+                                        signature?: Uint8Array;
+                                    }[];
+                                };
+                            };
+                            validatorSet?: {
+                                validators?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                }[];
+                                proposer?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                };
+                                totalVotingPower?: any;
+                            };
+                            trustedHeight?: {
+                                revisionNumber?: any;
+                                revisionHeight?: any;
+                            };
+                            trustedValidators?: {
+                                validators?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                }[];
+                                proposer?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                };
+                                totalVotingPower?: any;
+                            };
+                        };
+                    }): _134.Misbehaviour;
+                };
+                Header: {
+                    encode(message: _134.Header, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _134.Header;
+                    fromPartial(object: {
+                        signedHeader?: {
+                            header?: {
+                                version?: {
+                                    block?: any;
+                                    app?: any;
+                                };
+                                chainId?: string;
+                                height?: any;
+                                time?: Date;
+                                lastBlockId?: {
+                                    hash?: Uint8Array;
+                                    partSetHeader?: {
+                                        total?: number;
+                                        hash?: Uint8Array;
+                                    };
+                                };
+                                lastCommitHash?: Uint8Array;
+                                dataHash?: Uint8Array;
+                                validatorsHash?: Uint8Array;
+                                nextValidatorsHash?: Uint8Array;
+                                consensusHash?: Uint8Array;
+                                appHash?: Uint8Array;
+                                lastResultsHash?: Uint8Array;
+                                evidenceHash?: Uint8Array;
+                                proposerAddress?: Uint8Array;
+                            };
+                            commit?: {
+                                height?: any;
+                                round?: number;
+                                blockId?: {
+                                    hash?: Uint8Array;
+                                    partSetHeader?: {
+                                        total?: number;
+                                        hash?: Uint8Array;
+                                    };
+                                };
+                                signatures?: {
+                                    blockIdFlag?: import("../tendermint/types/types").BlockIDFlag;
+                                    validatorAddress?: Uint8Array;
+                                    timestamp?: Date;
+                                    signature?: Uint8Array;
+                                }[];
+                            };
+                        };
+                        validatorSet?: {
+                            validators?: {
+                                address?: Uint8Array;
+                                pubKey?: {
+                                    ed25519?: Uint8Array;
+                                    secp256k1?: Uint8Array;
+                                };
+                                votingPower?: any;
+                                proposerPriority?: any;
+                            }[];
+                            proposer?: {
+                                address?: Uint8Array;
+                                pubKey?: {
+                                    ed25519?: Uint8Array;
+                                    secp256k1?: Uint8Array;
+                                };
+                                votingPower?: any;
+                                proposerPriority?: any;
+                            };
+                            totalVotingPower?: any;
+                        };
+                        trustedHeight?: {
+                            revisionNumber?: any;
+                            revisionHeight?: any;
+                        };
+                        trustedValidators?: {
+                            validators?: {
+                                address?: Uint8Array;
+                                pubKey?: {
+                                    ed25519?: Uint8Array;
+                                    secp256k1?: Uint8Array;
+                                };
+                                votingPower?: any;
+                                proposerPriority?: any;
+                            }[];
+                            proposer?: {
+                                address?: Uint8Array;
+                                pubKey?: {
+                                    ed25519?: Uint8Array;
+                                    secp256k1?: Uint8Array;
+                                };
+                                votingPower?: any;
+                                proposerPriority?: any;
+                            };
+                            totalVotingPower?: any;
+                        };
+                    }): _134.Header;
+                };
+                Fraction: {
+                    encode(message: _134.Fraction, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                    decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _134.Fraction;
+                    fromPartial(object: {
+                        numerator?: any;
+                        denominator?: any;
+                    }): _134.Fraction;
+                };
+            };
+        }
+    }
+    const ClientFactory: {
+        createRPCMsgClient: ({ rpc }: {
+            rpc: import("@osmonauts/helpers").Rpc;
+        }) => Promise<{
+            cosmos: {
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                crisis: {
+                    v1beta1: import("../cosmos/crisis/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                evidence: {
+                    v1beta1: import("../cosmos/evidence/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/tx.rpc.msg").MsgClientImpl;
+                    v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                nft: {
+                    v1beta1: import("../cosmos/nft/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                slashing: {
+                    v1beta1: import("../cosmos/slashing/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                vesting: {
+                    v1beta1: import("../cosmos/vesting/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+            };
+            ibc: {
+                applications: {
+                    transfer: {
+                        v1: _287.MsgClientImpl;
+                    };
+                };
+                core: {
+                    channel: {
+                        v1: _288.MsgClientImpl;
+                    };
+                    client: {
+                        v1: _289.MsgClientImpl;
+                    };
+                    connection: {
+                        v1: _290.MsgClientImpl;
+                    };
+                };
+            };
+        }>;
+        createRPCQueryClient: ({ rpcEndpoint }: {
+            rpcEndpoint: string;
+        }) => Promise<{
+            cosmos: {
+                app: {
+                    v1alpha1: {
+                        config(request?: import("../cosmos/app/v1alpha1/query").QueryConfigRequest): Promise<import("../cosmos/app/v1alpha1/query").QueryConfigResponse>;
+                    };
+                };
+                auth: {
+                    v1beta1: {
+                        accounts(request?: import("../cosmos/auth/v1beta1/query").QueryAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountsResponse>;
+                        account(request: import("../cosmos/auth/v1beta1/query").QueryAccountRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountResponse>;
+                        params(request?: import("../cosmos/auth/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryParamsResponse>;
+                        moduleAccounts(request?: import("../cosmos/auth/v1beta1/query").QueryModuleAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryModuleAccountsResponse>;
+                        bech32Prefix(request?: import("../cosmos/auth/v1beta1/query").Bech32PrefixRequest): Promise<import("../cosmos/auth/v1beta1/query").Bech32PrefixResponse>;
+                        addressBytesToString(request: import("../cosmos/auth/v1beta1/query").AddressBytesToStringRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressBytesToStringResponse>;
+                        addressStringToBytes(request: import("../cosmos/auth/v1beta1/query").AddressStringToBytesRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressStringToBytesResponse>;
+                    };
+                };
+                authz: {
+                    v1beta1: {
+                        grants(request: import("../cosmos/authz/v1beta1/query").QueryGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGrantsResponse>;
+                        granterGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranterGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranterGrantsResponse>;
+                        granteeGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsResponse>;
+                    };
+                };
+                bank: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/bank/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryBalanceResponse>;
+                        allBalances(request: import("../cosmos/bank/v1beta1/query").QueryAllBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryAllBalancesResponse>;
+                        spendableBalances(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesResponse>;
+                        totalSupply(request?: import("../cosmos/bank/v1beta1/query").QueryTotalSupplyRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryTotalSupplyResponse>;
+                        supplyOf(request: import("../cosmos/bank/v1beta1/query").QuerySupplyOfRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySupplyOfResponse>;
+                        params(request?: import("../cosmos/bank/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryParamsResponse>;
+                        denomMetadata(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataResponse>;
+                        denomsMetadata(request?: import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataResponse>;
+                        denomOwners(request: import("../cosmos/bank/v1beta1/query").QueryDenomOwnersRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomOwnersResponse>;
+                    };
+                };
+                base: {
+                    tendermint: {
+                        v1beta1: {
+                            getNodeInfo(request?: import("../cosmos/base/tendermint/v1beta1/query").GetNodeInfoRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetNodeInfoResponse>;
+                            getSyncing(request?: import("../cosmos/base/tendermint/v1beta1/query").GetSyncingRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetSyncingResponse>;
+                            getLatestBlock(request?: import("../cosmos/base/tendermint/v1beta1/query").GetLatestBlockRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetLatestBlockResponse>;
+                            getBlockByHeight(request: import("../cosmos/base/tendermint/v1beta1/query").GetBlockByHeightRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetBlockByHeightResponse>;
+                            getLatestValidatorSet(request?: import("../cosmos/base/tendermint/v1beta1/query").GetLatestValidatorSetRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetLatestValidatorSetResponse>;
+                            getValidatorSetByHeight(request: import("../cosmos/base/tendermint/v1beta1/query").GetValidatorSetByHeightRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetValidatorSetByHeightResponse>;
+                        };
+                    };
+                };
+                distribution: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/distribution/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryParamsResponse>;
+                        validatorOutstandingRewards(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsResponse>;
+                        validatorCommission(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionResponse>;
+                        validatorSlashes(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesResponse>;
+                        delegationRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsResponse>;
+                        delegationTotalRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsResponse>;
+                        delegatorValidators(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsResponse>;
+                        delegatorWithdrawAddress(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressResponse>;
+                        communityPool(request?: import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolResponse>;
+                    };
+                };
+                evidence: {
+                    v1beta1: {
+                        evidence(request: import("../cosmos/evidence/v1beta1/query").QueryEvidenceRequest): Promise<import("../cosmos/evidence/v1beta1/query").QueryEvidenceResponse>;
+                        allEvidence(request?: import("../cosmos/evidence/v1beta1/query").QueryAllEvidenceRequest): Promise<import("../cosmos/evidence/v1beta1/query").QueryAllEvidenceResponse>;
+                    };
+                };
+                feegrant: {
+                    v1beta1: {
+                        allowance(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowanceRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowanceResponse>;
+                        allowances(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesResponse>;
+                        allowancesByGranter(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterResponse>;
+                    };
+                };
+                gov: {
+                    v1: {
+                        proposal(request: import("../cosmos/gov/v1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1/query").QueryTallyResultResponse>;
+                    };
+                    v1beta1: {
+                        proposal(request: import("../cosmos/gov/v1beta1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1beta1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1beta1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1beta1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1beta1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1beta1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1beta1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryTallyResultResponse>;
+                    };
+                };
+                group: {
+                    v1: {
+                        groupInfo(request: import("../cosmos/group/v1/query").QueryGroupInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupInfoResponse>;
+                        groupPolicyInfo(request: import("../cosmos/group/v1/query").QueryGroupPolicyInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPolicyInfoResponse>;
+                        groupMembers(request: import("../cosmos/group/v1/query").QueryGroupMembersRequest): Promise<import("../cosmos/group/v1/query").QueryGroupMembersResponse>;
+                        groupsByAdmin(request: import("../cosmos/group/v1/query").QueryGroupsByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByAdminResponse>;
+                        groupPoliciesByGroup(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupResponse>;
+                        groupPoliciesByAdmin(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminResponse>;
+                        proposal(request: import("../cosmos/group/v1/query").QueryProposalRequest): Promise<import("../cosmos/group/v1/query").QueryProposalResponse>;
+                        proposalsByGroupPolicy(request: import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyRequest): Promise<import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyResponse>;
+                        voteByProposalVoter(request: import("../cosmos/group/v1/query").QueryVoteByProposalVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVoteByProposalVoterResponse>;
+                        votesByProposal(request: import("../cosmos/group/v1/query").QueryVotesByProposalRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByProposalResponse>;
+                        votesByVoter(request: import("../cosmos/group/v1/query").QueryVotesByVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByVoterResponse>;
+                        groupsByMember(request: import("../cosmos/group/v1/query").QueryGroupsByMemberRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByMemberResponse>;
+                        tallyResult(request: import("../cosmos/group/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/group/v1/query").QueryTallyResultResponse>;
+                    };
+                };
+                mint: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/mint/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryParamsResponse>;
+                        inflation(request?: import("../cosmos/mint/v1beta1/query").QueryInflationRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryInflationResponse>;
+                        annualProvisions(request?: import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsResponse>;
+                    };
+                };
+                nft: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/nft/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryBalanceResponse>;
+                        owner(request: import("../cosmos/nft/v1beta1/query").QueryOwnerRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryOwnerResponse>;
+                        supply(request: import("../cosmos/nft/v1beta1/query").QuerySupplyRequest): Promise<import("../cosmos/nft/v1beta1/query").QuerySupplyResponse>;
+                        nFTs(request: import("../cosmos/nft/v1beta1/query").QueryNFTsRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryNFTsResponse>;
+                        nFT(request: import("../cosmos/nft/v1beta1/query").QueryNFTRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryNFTResponse>;
+                        class(request: import("../cosmos/nft/v1beta1/query").QueryClassRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryClassResponse>;
+                        classes(request?: import("../cosmos/nft/v1beta1/query").QueryClassesRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryClassesResponse>;
+                    };
+                };
+                params: {
+                    v1beta1: {
+                        params(request: import("../cosmos/params/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/params/v1beta1/query").QueryParamsResponse>;
+                        subspaces(request?: import("../cosmos/params/v1beta1/query").QuerySubspacesRequest): Promise<import("../cosmos/params/v1beta1/query").QuerySubspacesResponse>;
+                    };
+                };
+                slashing: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/slashing/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/slashing/v1beta1/query").QueryParamsResponse>;
+                        signingInfo(request: import("../cosmos/slashing/v1beta1/query").QuerySigningInfoRequest): Promise<import("../cosmos/slashing/v1beta1/query").QuerySigningInfoResponse>;
+                        signingInfos(request?: import("../cosmos/slashing/v1beta1/query").QuerySigningInfosRequest): Promise<import("../cosmos/slashing/v1beta1/query").QuerySigningInfosResponse>;
+                    };
+                };
+                staking: {
+                    v1beta1: {
+                        validators(request: import("../cosmos/staking/v1beta1/query").QueryValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorsResponse>;
+                        validator(request: import("../cosmos/staking/v1beta1/query").QueryValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorResponse>;
+                        validatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsResponse>;
+                        validatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsResponse>;
+                        delegation(request: import("../cosmos/staking/v1beta1/query").QueryDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegationResponse>;
+                        unbondingDelegation(request: import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationResponse>;
+                        delegatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsResponse>;
+                        delegatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsResponse>;
+                        redelegations(request: import("../cosmos/staking/v1beta1/query").QueryRedelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryRedelegationsResponse>;
+                        delegatorValidators(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsResponse>;
+                        delegatorValidator(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorResponse>;
+                        historicalInfo(request: import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoResponse>;
+                        pool(request?: import("../cosmos/staking/v1beta1/query").QueryPoolRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryPoolResponse>;
+                        params(request?: import("../cosmos/staking/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryParamsResponse>;
+                    };
+                };
+                tx: {
+                    v1beta1: {
+                        simulate(request: import("../cosmos/tx/v1beta1/service").SimulateRequest): Promise<import("../cosmos/tx/v1beta1/service").SimulateResponse>;
+                        getTx(request: import("../cosmos/tx/v1beta1/service").GetTxRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxResponse>;
+                        broadcastTx(request: import("../cosmos/tx/v1beta1/service").BroadcastTxRequest): Promise<import("../cosmos/tx/v1beta1/service").BroadcastTxResponse>;
+                        getTxsEvent(request: import("../cosmos/tx/v1beta1/service").GetTxsEventRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxsEventResponse>;
+                        getBlockWithTxs(request: import("../cosmos/tx/v1beta1/service").GetBlockWithTxsRequest): Promise<import("../cosmos/tx/v1beta1/service").GetBlockWithTxsResponse>;
+                    };
+                };
+                upgrade: {
+                    v1beta1: {
+                        currentPlan(request?: import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanResponse>;
+                        appliedPlan(request: import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanResponse>;
+                        upgradedConsensusState(request: import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateResponse>;
+                        moduleVersions(request: import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsResponse>;
+                        authority(request?: import("../cosmos/upgrade/v1beta1/query").QueryAuthorityRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAuthorityResponse>;
+                    };
+                };
+            };
+            ibc: {
+                applications: {
+                    transfer: {
+                        v1: {
+                            denomTrace(request: _112.QueryDenomTraceRequest): Promise<_112.QueryDenomTraceResponse>;
+                            denomTraces(request?: _112.QueryDenomTracesRequest): Promise<_112.QueryDenomTracesResponse>;
+                            params(request?: _112.QueryParamsRequest): Promise<_112.QueryParamsResponse>;
+                        };
+                    };
+                };
+                core: {
+                    channel: {
+                        v1: {
+                            channel(request: _118.QueryChannelRequest): Promise<_118.QueryChannelResponse>;
+                            channels(request?: _118.QueryChannelsRequest): Promise<_118.QueryChannelsResponse>;
+                            connectionChannels(request: _118.QueryConnectionChannelsRequest): Promise<_118.QueryConnectionChannelsResponse>;
+                            channelClientState(request: _118.QueryChannelClientStateRequest): Promise<_118.QueryChannelClientStateResponse>;
+                            channelConsensusState(request: _118.QueryChannelConsensusStateRequest): Promise<_118.QueryChannelConsensusStateResponse>;
+                            packetCommitment(request: _118.QueryPacketCommitmentRequest): Promise<_118.QueryPacketCommitmentResponse>;
+                            packetCommitments(request: _118.QueryPacketCommitmentsRequest): Promise<_118.QueryPacketCommitmentsResponse>;
+                            packetReceipt(request: _118.QueryPacketReceiptRequest): Promise<_118.QueryPacketReceiptResponse>;
+                            packetAcknowledgement(request: _118.QueryPacketAcknowledgementRequest): Promise<_118.QueryPacketAcknowledgementResponse>;
+                            packetAcknowledgements(request: _118.QueryPacketAcknowledgementsRequest): Promise<_118.QueryPacketAcknowledgementsResponse>;
+                            unreceivedPackets(request: _118.QueryUnreceivedPacketsRequest): Promise<_118.QueryUnreceivedPacketsResponse>;
+                            unreceivedAcks(request: _118.QueryUnreceivedAcksRequest): Promise<_118.QueryUnreceivedAcksResponse>;
+                            nextSequenceReceive(request: _118.QueryNextSequenceReceiveRequest): Promise<_118.QueryNextSequenceReceiveResponse>;
+                        };
+                    };
+                    client: {
+                        v1: {
+                            clientState(request: _122.QueryClientStateRequest): Promise<_122.QueryClientStateResponse>;
+                            clientStates(request?: _122.QueryClientStatesRequest): Promise<_122.QueryClientStatesResponse>;
+                            consensusState(request: _122.QueryConsensusStateRequest): Promise<_122.QueryConsensusStateResponse>;
+                            consensusStates(request: _122.QueryConsensusStatesRequest): Promise<_122.QueryConsensusStatesResponse>;
+                            clientStatus(request: _122.QueryClientStatusRequest): Promise<_122.QueryClientStatusResponse>;
+                            clientParams(request?: _122.QueryClientParamsRequest): Promise<_122.QueryClientParamsResponse>;
+                            upgradedClientState(request?: _122.QueryUpgradedClientStateRequest): Promise<_122.QueryUpgradedClientStateResponse>;
+                            upgradedConsensusState(request?: _122.QueryUpgradedConsensusStateRequest): Promise<_122.QueryUpgradedConsensusStateResponse>;
+                        };
+                    };
+                    connection: {
+                        v1: {
+                            connection(request: _127.QueryConnectionRequest): Promise<_127.QueryConnectionResponse>;
+                            connections(request?: _127.QueryConnectionsRequest): Promise<_127.QueryConnectionsResponse>;
+                            clientConnections(request: _127.QueryClientConnectionsRequest): Promise<_127.QueryClientConnectionsResponse>;
+                            connectionClientState(request: _127.QueryConnectionClientStateRequest): Promise<_127.QueryConnectionClientStateResponse>;
+                            connectionConsensusState(request: _127.QueryConnectionConsensusStateRequest): Promise<_127.QueryConnectionConsensusStateResponse>;
+                        };
+                    };
+                    port: {
+                        v1: {
+                            appVersion(request: _129.QueryAppVersionRequest): Promise<_129.QueryAppVersionResponse>;
+                        };
+                    };
+                };
+            };
+        }>;
+        createLCDClient: ({ restEndpoint }: {
+            restEndpoint: string;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/query.lcd").LCDQueryClient;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/query.lcd").LCDQueryClient;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/query.lcd").LCDQueryClient;
+                };
+                base: {
+                    tendermint: {
+                        v1beta1: import("../cosmos/base/tendermint/v1beta1/query.lcd").LCDQueryClient;
+                    };
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/query.lcd").LCDQueryClient;
+                };
+                evidence: {
+                    v1beta1: import("../cosmos/evidence/v1beta1/query.lcd").LCDQueryClient;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/query.lcd").LCDQueryClient;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/query.lcd").LCDQueryClient;
+                    v1beta1: import("../cosmos/gov/v1beta1/query.lcd").LCDQueryClient;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/query.lcd").LCDQueryClient;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/query.lcd").LCDQueryClient;
+                };
+                nft: {
+                    v1beta1: import("../cosmos/nft/v1beta1/query.lcd").LCDQueryClient;
+                };
+                params: {
+                    v1beta1: import("../cosmos/params/v1beta1/query.lcd").LCDQueryClient;
+                };
+                slashing: {
+                    v1beta1: import("../cosmos/slashing/v1beta1/query.lcd").LCDQueryClient;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/query.lcd").LCDQueryClient;
+                };
+                tx: {
+                    v1beta1: import("../cosmos/tx/v1beta1/service.lcd").LCDQueryClient;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/query.lcd").LCDQueryClient;
+                };
+            };
+            ibc: {
+                applications: {
+                    transfer: {
+                        v1: _278.LCDQueryClient;
+                    };
+                };
+                core: {
+                    channel: {
+                        v1: _279.LCDQueryClient;
+                    };
+                    client: {
+                        v1: _280.LCDQueryClient;
+                    };
+                    connection: {
+                        v1: _281.LCDQueryClient;
+                    };
+                };
+            };
+        }>;
+    };
+}