import * as _76 from "./abci/types";
import * as _77 from "./crypto/keys";
import * as _78 from "./crypto/proof";
import * as _79 from "./p2p/types";
import * as _80 from "./types/block";
import * as _81 from "./types/evidence";
import * as _82 from "./types/params";
import * as _83 from "./types/types";
import * as _84 from "./types/validator";
import * as _85 from "./version/types";
export declare namespace tendermint {
    const abci: {
        checkTxTypeFromJSON(object: any): _76.CheckTxType;
        checkTxTypeToJSON(object: _76.CheckTxType): string;
        responseOfferSnapshot_ResultFromJSON(object: any): _76.ResponseOfferSnapshot_Result;
        responseOfferSnapshot_ResultToJSON(object: _76.ResponseOfferSnapshot_Result): string;
        responseApplySnapshotChunk_ResultFromJSON(object: any): _76.ResponseApplySnapshotChunk_Result;
        responseApplySnapshotChunk_ResultToJSON(object: _76.ResponseApplySnapshotChunk_Result): string;
        evidenceTypeFromJSON(object: any): _76.EvidenceType;
        evidenceTypeToJSON(object: _76.EvidenceType): string;
        protobufPackage: "tendermint.abci";
        CheckTxType: typeof _76.CheckTxType;
        CheckTxTypeSDKType: typeof _76.CheckTxType;
        ResponseOfferSnapshot_Result: typeof _76.ResponseOfferSnapshot_Result;
        ResponseOfferSnapshot_ResultSDKType: typeof _76.ResponseOfferSnapshot_Result;
        ResponseApplySnapshotChunk_Result: typeof _76.ResponseApplySnapshotChunk_Result;
        ResponseApplySnapshotChunk_ResultSDKType: typeof _76.ResponseApplySnapshotChunk_Result;
        EvidenceType: typeof _76.EvidenceType;
        EvidenceTypeSDKType: typeof _76.EvidenceType;
        Request: {
            typeUrl: string;
            encode(message: _76.Request, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.Request;
            fromJSON(object: any): _76.Request;
            toJSON(message: _76.Request): unknown;
            fromPartial<I extends Partial<_76.Request> & {
                echo?: _76.RequestEcho & {
                    message: string;
                } & Record<Exclude<keyof I["echo"], "message">, never>;
                flush?: _76.RequestFlush & {} & Record<Exclude<keyof I["flush"], never>, never>;
                info?: _76.RequestInfo & {
                    version: string;
                    blockVersion: bigint;
                    p2pVersion: bigint;
                } & Record<Exclude<keyof I["info"], keyof _76.RequestInfo>, never>;
                setOption?: _76.RequestSetOption & {
                    key: string;
                    value: string;
                } & Record<Exclude<keyof I["setOption"], keyof _76.RequestSetOption>, never>;
                initChain?: _76.RequestInitChain & {
                    time: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I["initChain"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    chainId: string;
                    consensusParams?: _76.ConsensusParams & {
                        block?: _76.BlockParams & {
                            maxBytes: bigint;
                            maxGas: bigint;
                        } & Record<Exclude<keyof I["initChain"]["consensusParams"]["block"], keyof _76.BlockParams>, never>;
                        evidence?: _82.EvidenceParams & {
                            maxAgeNumBlocks: bigint;
                            maxAgeDuration: import("../google/protobuf/duration").Duration & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I["initChain"]["consensusParams"]["evidence"]["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                            maxBytes: bigint;
                        } & Record<Exclude<keyof I["initChain"]["consensusParams"]["evidence"], keyof _82.EvidenceParams>, never>;
                        validator?: _82.ValidatorParams & {
                            pubKeyTypes: string[] & Record<Exclude<keyof I["initChain"]["consensusParams"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                        } & Record<Exclude<keyof I["initChain"]["consensusParams"]["validator"], "pubKeyTypes">, never>;
                        version?: _82.VersionParams & {
                            appVersion: bigint;
                        } & Record<Exclude<keyof I["initChain"]["consensusParams"]["version"], "appVersion">, never>;
                    } & Record<Exclude<keyof I["initChain"]["consensusParams"], keyof _76.ConsensusParams>, never>;
                    validators: _76.ValidatorUpdate[] & (_76.ValidatorUpdate & {
                        pubKey: _77.PublicKey & {
                            ed25519?: Uint8Array;
                            secp256k1?: Uint8Array;
                        } & Record<Exclude<keyof I["initChain"]["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                        power: bigint;
                    } & Record<Exclude<keyof I["initChain"]["validators"][number], keyof _76.ValidatorUpdate>, never>)[] & Record<Exclude<keyof I["initChain"]["validators"], keyof _76.ValidatorUpdate[]>, never>;
                    appStateBytes: Uint8Array;
                    initialHeight: bigint;
                } & Record<Exclude<keyof I["initChain"], keyof _76.RequestInitChain>, never>;
                query?: _76.RequestQuery & {
                    data: Uint8Array;
                    path: string;
                    height: bigint;
                    prove: boolean;
                } & Record<Exclude<keyof I["query"], keyof _76.RequestQuery>, never>;
                beginBlock?: _76.RequestBeginBlock & {
                    hash: Uint8Array;
                    header: _83.Header & {
                        version: _85.Consensus & {
                            block: bigint;
                            app: bigint;
                        } & Record<Exclude<keyof I["beginBlock"]["header"]["version"], keyof _85.Consensus>, never>;
                        chainId: string;
                        height: bigint;
                        time: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I["beginBlock"]["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        lastBlockId: _83.BlockID & {
                            hash: Uint8Array;
                            partSetHeader: _83.PartSetHeader & {
                                total: number;
                                hash: Uint8Array;
                            } & Record<Exclude<keyof I["beginBlock"]["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                        } & Record<Exclude<keyof I["beginBlock"]["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                        lastCommitHash: Uint8Array;
                        dataHash: Uint8Array;
                        validatorsHash: Uint8Array;
                        nextValidatorsHash: Uint8Array;
                        consensusHash: Uint8Array;
                        appHash: Uint8Array;
                        lastResultsHash: Uint8Array;
                        evidenceHash: Uint8Array;
                        proposerAddress: Uint8Array;
                    } & Record<Exclude<keyof I["beginBlock"]["header"], keyof _83.Header>, never>;
                    lastCommitInfo: _76.LastCommitInfo & {
                        round: number;
                        votes: _76.VoteInfo[] & (_76.VoteInfo & {
                            validator: _76.Validator & {
                                address: Uint8Array;
                                power: bigint;
                            } & Record<Exclude<keyof I["beginBlock"]["lastCommitInfo"]["votes"][number]["validator"], keyof _76.Validator>, never>;
                            signedLastBlock: boolean;
                        } & Record<Exclude<keyof I["beginBlock"]["lastCommitInfo"]["votes"][number], keyof _76.VoteInfo>, never>)[] & Record<Exclude<keyof I["beginBlock"]["lastCommitInfo"]["votes"], keyof _76.VoteInfo[]>, never>;
                    } & Record<Exclude<keyof I["beginBlock"]["lastCommitInfo"], keyof _76.LastCommitInfo>, never>;
                    byzantineValidators: _76.Evidence[] & (_76.Evidence & {
                        type: _76.EvidenceType;
                        validator: _76.Validator & {
                            address: Uint8Array;
                            power: bigint;
                        } & Record<Exclude<keyof I["beginBlock"]["byzantineValidators"][number]["validator"], keyof _76.Validator>, never>;
                        height: bigint;
                        time: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I["beginBlock"]["byzantineValidators"][number]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        totalVotingPower: bigint;
                    } & Record<Exclude<keyof I["beginBlock"]["byzantineValidators"][number], keyof _76.Evidence>, never>)[] & Record<Exclude<keyof I["beginBlock"]["byzantineValidators"], keyof _76.Evidence[]>, never>;
                } & Record<Exclude<keyof I["beginBlock"], keyof _76.RequestBeginBlock>, never>;
                checkTx?: _76.RequestCheckTx & {
                    tx: Uint8Array;
                    type: _76.CheckTxType;
                } & Record<Exclude<keyof I["checkTx"], keyof _76.RequestCheckTx>, never>;
                deliverTx?: _76.RequestDeliverTx & {
                    tx: Uint8Array;
                } & Record<Exclude<keyof I["deliverTx"], "tx">, never>;
                endBlock?: _76.RequestEndBlock & {
                    height: bigint;
                } & Record<Exclude<keyof I["endBlock"], "height">, never>;
                commit?: _76.RequestCommit & {} & Record<Exclude<keyof I["commit"], never>, never>;
                listSnapshots?: _76.RequestListSnapshots & {} & Record<Exclude<keyof I["listSnapshots"], never>, never>;
                offerSnapshot?: _76.RequestOfferSnapshot & {
                    snapshot?: _76.Snapshot & {
                        height: bigint;
                        format: number;
                        chunks: number;
                        hash: Uint8Array;
                        metadata: Uint8Array;
                    } & Record<Exclude<keyof I["offerSnapshot"]["snapshot"], keyof _76.Snapshot>, never>;
                    appHash: Uint8Array;
                } & Record<Exclude<keyof I["offerSnapshot"], keyof _76.RequestOfferSnapshot>, never>;
                loadSnapshotChunk?: _76.RequestLoadSnapshotChunk & {
                    height: bigint;
                    format: number;
                    chunk: number;
                } & Record<Exclude<keyof I["loadSnapshotChunk"], keyof _76.RequestLoadSnapshotChunk>, never>;
                applySnapshotChunk?: _76.RequestApplySnapshotChunk & {
                    index: number;
                    chunk: Uint8Array;
                    sender: string;
                } & Record<Exclude<keyof I["applySnapshotChunk"], keyof _76.RequestApplySnapshotChunk>, never>;
            } & Record<Exclude<keyof I, keyof _76.Request>, never>>(object: I): _76.Request;
        };
        RequestEcho: {
            typeUrl: string;
            encode(message: _76.RequestEcho, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestEcho;
            fromJSON(object: any): _76.RequestEcho;
            toJSON(message: _76.RequestEcho): unknown;
            fromPartial<I_1 extends Partial<_76.RequestEcho> & {
                message?: string;
            } & Record<Exclude<keyof I_1, "message">, never>>(object: I_1): _76.RequestEcho;
        };
        RequestFlush: {
            typeUrl: string;
            encode(_: _76.RequestFlush, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestFlush;
            fromJSON(_: any): _76.RequestFlush;
            toJSON(_: _76.RequestFlush): unknown;
            fromPartial<I_2 extends Partial<_76.RequestFlush> & {} & Record<Exclude<keyof I_2, never>, never>>(_: I_2): _76.RequestFlush;
        };
        RequestInfo: {
            typeUrl: string;
            encode(message: _76.RequestInfo, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestInfo;
            fromJSON(object: any): _76.RequestInfo;
            toJSON(message: _76.RequestInfo): unknown;
            fromPartial<I_3 extends Partial<_76.RequestInfo> & {
                version?: string;
                blockVersion?: bigint;
                p2pVersion?: bigint;
            } & Record<Exclude<keyof I_3, keyof _76.RequestInfo>, never>>(object: I_3): _76.RequestInfo;
        };
        RequestSetOption: {
            typeUrl: string;
            encode(message: _76.RequestSetOption, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestSetOption;
            fromJSON(object: any): _76.RequestSetOption;
            toJSON(message: _76.RequestSetOption): unknown;
            fromPartial<I_4 extends Partial<_76.RequestSetOption> & {
                key?: string;
                value?: string;
            } & Record<Exclude<keyof I_4, keyof _76.RequestSetOption>, never>>(object: I_4): _76.RequestSetOption;
        };
        RequestInitChain: {
            typeUrl: string;
            encode(message: _76.RequestInitChain, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestInitChain;
            fromJSON(object: any): _76.RequestInitChain;
            toJSON(message: _76.RequestInitChain): unknown;
            fromPartial<I_5 extends Partial<_76.RequestInitChain> & {
                time?: import("../google/protobuf/timestamp").Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_5["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                chainId?: string;
                consensusParams?: _76.ConsensusParams & {
                    block?: _76.BlockParams & {
                        maxBytes: bigint;
                        maxGas: bigint;
                    } & Record<Exclude<keyof I_5["consensusParams"]["block"], keyof _76.BlockParams>, never>;
                    evidence?: _82.EvidenceParams & {
                        maxAgeNumBlocks: bigint;
                        maxAgeDuration: import("../google/protobuf/duration").Duration & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_5["consensusParams"]["evidence"]["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                        maxBytes: bigint;
                    } & Record<Exclude<keyof I_5["consensusParams"]["evidence"], keyof _82.EvidenceParams>, never>;
                    validator?: _82.ValidatorParams & {
                        pubKeyTypes: string[] & Record<Exclude<keyof I_5["consensusParams"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                    } & Record<Exclude<keyof I_5["consensusParams"]["validator"], "pubKeyTypes">, never>;
                    version?: _82.VersionParams & {
                        appVersion: bigint;
                    } & Record<Exclude<keyof I_5["consensusParams"]["version"], "appVersion">, never>;
                } & Record<Exclude<keyof I_5["consensusParams"], keyof _76.ConsensusParams>, never>;
                validators?: _76.ValidatorUpdate[] & (_76.ValidatorUpdate & {
                    pubKey: _77.PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I_5["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                    power: bigint;
                } & Record<Exclude<keyof I_5["validators"][number], keyof _76.ValidatorUpdate>, never>)[] & Record<Exclude<keyof I_5["validators"], keyof _76.ValidatorUpdate[]>, never>;
                appStateBytes?: Uint8Array;
                initialHeight?: bigint;
            } & Record<Exclude<keyof I_5, keyof _76.RequestInitChain>, never>>(object: I_5): _76.RequestInitChain;
        };
        RequestQuery: {
            typeUrl: string;
            encode(message: _76.RequestQuery, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestQuery;
            fromJSON(object: any): _76.RequestQuery;
            toJSON(message: _76.RequestQuery): unknown;
            fromPartial<I_6 extends Partial<_76.RequestQuery> & {
                data?: Uint8Array;
                path?: string;
                height?: bigint;
                prove?: boolean;
            } & Record<Exclude<keyof I_6, keyof _76.RequestQuery>, never>>(object: I_6): _76.RequestQuery;
        };
        RequestBeginBlock: {
            typeUrl: string;
            encode(message: _76.RequestBeginBlock, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestBeginBlock;
            fromJSON(object: any): _76.RequestBeginBlock;
            toJSON(message: _76.RequestBeginBlock): unknown;
            fromPartial<I_7 extends Partial<_76.RequestBeginBlock> & {
                hash?: Uint8Array;
                header?: _83.Header & {
                    version: _85.Consensus & {
                        block: bigint;
                        app: bigint;
                    } & Record<Exclude<keyof I_7["header"]["version"], keyof _85.Consensus>, never>;
                    chainId: string;
                    height: bigint;
                    time: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_7["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    lastBlockId: _83.BlockID & {
                        hash: Uint8Array;
                        partSetHeader: _83.PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I_7["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                    } & Record<Exclude<keyof I_7["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                    lastCommitHash: Uint8Array;
                    dataHash: Uint8Array;
                    validatorsHash: Uint8Array;
                    nextValidatorsHash: Uint8Array;
                    consensusHash: Uint8Array;
                    appHash: Uint8Array;
                    lastResultsHash: Uint8Array;
                    evidenceHash: Uint8Array;
                    proposerAddress: Uint8Array;
                } & Record<Exclude<keyof I_7["header"], keyof _83.Header>, never>;
                lastCommitInfo?: _76.LastCommitInfo & {
                    round: number;
                    votes: _76.VoteInfo[] & (_76.VoteInfo & {
                        validator: _76.Validator & {
                            address: Uint8Array;
                            power: bigint;
                        } & Record<Exclude<keyof I_7["lastCommitInfo"]["votes"][number]["validator"], keyof _76.Validator>, never>;
                        signedLastBlock: boolean;
                    } & Record<Exclude<keyof I_7["lastCommitInfo"]["votes"][number], keyof _76.VoteInfo>, never>)[] & Record<Exclude<keyof I_7["lastCommitInfo"]["votes"], keyof _76.VoteInfo[]>, never>;
                } & Record<Exclude<keyof I_7["lastCommitInfo"], keyof _76.LastCommitInfo>, never>;
                byzantineValidators?: _76.Evidence[] & (_76.Evidence & {
                    type: _76.EvidenceType;
                    validator: _76.Validator & {
                        address: Uint8Array;
                        power: bigint;
                    } & Record<Exclude<keyof I_7["byzantineValidators"][number]["validator"], keyof _76.Validator>, never>;
                    height: bigint;
                    time: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_7["byzantineValidators"][number]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    totalVotingPower: bigint;
                } & Record<Exclude<keyof I_7["byzantineValidators"][number], keyof _76.Evidence>, never>)[] & Record<Exclude<keyof I_7["byzantineValidators"], keyof _76.Evidence[]>, never>;
            } & Record<Exclude<keyof I_7, keyof _76.RequestBeginBlock>, never>>(object: I_7): _76.RequestBeginBlock;
        };
        RequestCheckTx: {
            typeUrl: string;
            encode(message: _76.RequestCheckTx, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestCheckTx;
            fromJSON(object: any): _76.RequestCheckTx;
            toJSON(message: _76.RequestCheckTx): unknown;
            fromPartial<I_8 extends Partial<_76.RequestCheckTx> & {
                tx?: Uint8Array;
                type?: _76.CheckTxType;
            } & Record<Exclude<keyof I_8, keyof _76.RequestCheckTx>, never>>(object: I_8): _76.RequestCheckTx;
        };
        RequestDeliverTx: {
            typeUrl: string;
            encode(message: _76.RequestDeliverTx, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestDeliverTx;
            fromJSON(object: any): _76.RequestDeliverTx;
            toJSON(message: _76.RequestDeliverTx): unknown;
            fromPartial<I_9 extends Partial<_76.RequestDeliverTx> & {
                tx?: Uint8Array;
            } & Record<Exclude<keyof I_9, "tx">, never>>(object: I_9): _76.RequestDeliverTx;
        };
        RequestEndBlock: {
            typeUrl: string;
            encode(message: _76.RequestEndBlock, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestEndBlock;
            fromJSON(object: any): _76.RequestEndBlock;
            toJSON(message: _76.RequestEndBlock): unknown;
            fromPartial<I_10 extends Partial<_76.RequestEndBlock> & {
                height?: bigint;
            } & Record<Exclude<keyof I_10, "height">, never>>(object: I_10): _76.RequestEndBlock;
        };
        RequestCommit: {
            typeUrl: string;
            encode(_: _76.RequestCommit, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestCommit;
            fromJSON(_: any): _76.RequestCommit;
            toJSON(_: _76.RequestCommit): unknown;
            fromPartial<I_11 extends Partial<_76.RequestCommit> & {} & Record<Exclude<keyof I_11, never>, never>>(_: I_11): _76.RequestCommit;
        };
        RequestListSnapshots: {
            typeUrl: string;
            encode(_: _76.RequestListSnapshots, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestListSnapshots;
            fromJSON(_: any): _76.RequestListSnapshots;
            toJSON(_: _76.RequestListSnapshots): unknown;
            fromPartial<I_12 extends Partial<_76.RequestListSnapshots> & {} & Record<Exclude<keyof I_12, never>, never>>(_: I_12): _76.RequestListSnapshots;
        };
        RequestOfferSnapshot: {
            typeUrl: string;
            encode(message: _76.RequestOfferSnapshot, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestOfferSnapshot;
            fromJSON(object: any): _76.RequestOfferSnapshot;
            toJSON(message: _76.RequestOfferSnapshot): unknown;
            fromPartial<I_13 extends Partial<_76.RequestOfferSnapshot> & {
                snapshot?: _76.Snapshot & {
                    height: bigint;
                    format: number;
                    chunks: number;
                    hash: Uint8Array;
                    metadata: Uint8Array;
                } & Record<Exclude<keyof I_13["snapshot"], keyof _76.Snapshot>, never>;
                appHash?: Uint8Array;
            } & Record<Exclude<keyof I_13, keyof _76.RequestOfferSnapshot>, never>>(object: I_13): _76.RequestOfferSnapshot;
        };
        RequestLoadSnapshotChunk: {
            typeUrl: string;
            encode(message: _76.RequestLoadSnapshotChunk, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestLoadSnapshotChunk;
            fromJSON(object: any): _76.RequestLoadSnapshotChunk;
            toJSON(message: _76.RequestLoadSnapshotChunk): unknown;
            fromPartial<I_14 extends Partial<_76.RequestLoadSnapshotChunk> & {
                height?: bigint;
                format?: number;
                chunk?: number;
            } & Record<Exclude<keyof I_14, keyof _76.RequestLoadSnapshotChunk>, never>>(object: I_14): _76.RequestLoadSnapshotChunk;
        };
        RequestApplySnapshotChunk: {
            typeUrl: string;
            encode(message: _76.RequestApplySnapshotChunk, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.RequestApplySnapshotChunk;
            fromJSON(object: any): _76.RequestApplySnapshotChunk;
            toJSON(message: _76.RequestApplySnapshotChunk): unknown;
            fromPartial<I_15 extends Partial<_76.RequestApplySnapshotChunk> & {
                index?: number;
                chunk?: Uint8Array;
                sender?: string;
            } & Record<Exclude<keyof I_15, keyof _76.RequestApplySnapshotChunk>, never>>(object: I_15): _76.RequestApplySnapshotChunk;
        };
        Response: {
            typeUrl: string;
            encode(message: _76.Response, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.Response;
            fromJSON(object: any): _76.Response;
            toJSON(message: _76.Response): unknown;
            fromPartial<I_16 extends Partial<_76.Response> & {
                exception?: _76.ResponseException & {
                    error: string;
                } & Record<Exclude<keyof I_16["exception"], "error">, never>;
                echo?: _76.ResponseEcho & {
                    message: string;
                } & Record<Exclude<keyof I_16["echo"], "message">, never>;
                flush?: _76.ResponseFlush & {} & Record<Exclude<keyof I_16["flush"], never>, never>;
                info?: _76.ResponseInfo & {
                    data: string;
                    version: string;
                    appVersion: bigint;
                    lastBlockHeight: bigint;
                    lastBlockAppHash: Uint8Array;
                } & Record<Exclude<keyof I_16["info"], keyof _76.ResponseInfo>, never>;
                setOption?: _76.ResponseSetOption & {
                    code: number;
                    log: string;
                    info: string;
                } & Record<Exclude<keyof I_16["setOption"], keyof _76.ResponseSetOption>, never>;
                initChain?: _76.ResponseInitChain & {
                    consensusParams?: _76.ConsensusParams & {
                        block?: _76.BlockParams & {
                            maxBytes: bigint;
                            maxGas: bigint;
                        } & Record<Exclude<keyof I_16["initChain"]["consensusParams"]["block"], keyof _76.BlockParams>, never>;
                        evidence?: _82.EvidenceParams & {
                            maxAgeNumBlocks: bigint;
                            maxAgeDuration: import("../google/protobuf/duration").Duration & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I_16["initChain"]["consensusParams"]["evidence"]["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                            maxBytes: bigint;
                        } & Record<Exclude<keyof I_16["initChain"]["consensusParams"]["evidence"], keyof _82.EvidenceParams>, never>;
                        validator?: _82.ValidatorParams & {
                            pubKeyTypes: string[] & Record<Exclude<keyof I_16["initChain"]["consensusParams"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                        } & Record<Exclude<keyof I_16["initChain"]["consensusParams"]["validator"], "pubKeyTypes">, never>;
                        version?: _82.VersionParams & {
                            appVersion: bigint;
                        } & Record<Exclude<keyof I_16["initChain"]["consensusParams"]["version"], "appVersion">, never>;
                    } & Record<Exclude<keyof I_16["initChain"]["consensusParams"], keyof _76.ConsensusParams>, never>;
                    validators: _76.ValidatorUpdate[] & (_76.ValidatorUpdate & {
                        pubKey: _77.PublicKey & {
                            ed25519?: Uint8Array;
                            secp256k1?: Uint8Array;
                        } & Record<Exclude<keyof I_16["initChain"]["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                        power: bigint;
                    } & Record<Exclude<keyof I_16["initChain"]["validators"][number], keyof _76.ValidatorUpdate>, never>)[] & Record<Exclude<keyof I_16["initChain"]["validators"], keyof _76.ValidatorUpdate[]>, never>;
                    appHash: Uint8Array;
                } & Record<Exclude<keyof I_16["initChain"], keyof _76.ResponseInitChain>, never>;
                query?: _76.ResponseQuery & {
                    code: number;
                    log: string;
                    info: string;
                    index: bigint;
                    key: Uint8Array;
                    value: Uint8Array;
                    proofOps?: _78.ProofOps & {
                        ops: _78.ProofOp[] & (_78.ProofOp & {
                            type: string;
                            key: Uint8Array;
                            data: Uint8Array;
                        } & Record<Exclude<keyof I_16["query"]["proofOps"]["ops"][number], keyof _78.ProofOp>, never>)[] & Record<Exclude<keyof I_16["query"]["proofOps"]["ops"], keyof _78.ProofOp[]>, never>;
                    } & Record<Exclude<keyof I_16["query"]["proofOps"], "ops">, never>;
                    height: bigint;
                    codespace: string;
                } & Record<Exclude<keyof I_16["query"], keyof _76.ResponseQuery>, never>;
                beginBlock?: _76.ResponseBeginBlock & {
                    events: _76.Event[] & (_76.Event & {
                        type: string;
                        attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                            key: Uint8Array;
                            value: Uint8Array;
                            index: boolean;
                        } & Record<Exclude<keyof I_16["beginBlock"]["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_16["beginBlock"]["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                    } & Record<Exclude<keyof I_16["beginBlock"]["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_16["beginBlock"]["events"], keyof _76.Event[]>, never>;
                } & Record<Exclude<keyof I_16["beginBlock"], "events">, never>;
                checkTx?: _76.ResponseCheckTx & {
                    code: number;
                    data: Uint8Array;
                    log: string;
                    info: string;
                    gasWanted: bigint;
                    gasUsed: bigint;
                    events: _76.Event[] & (_76.Event & {
                        type: string;
                        attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                            key: Uint8Array;
                            value: Uint8Array;
                            index: boolean;
                        } & Record<Exclude<keyof I_16["checkTx"]["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_16["checkTx"]["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                    } & Record<Exclude<keyof I_16["checkTx"]["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_16["checkTx"]["events"], keyof _76.Event[]>, never>;
                    codespace: string;
                    sender: string;
                    priority: bigint;
                    mempoolError: string;
                } & Record<Exclude<keyof I_16["checkTx"], keyof _76.ResponseCheckTx>, never>;
                deliverTx?: _76.ResponseDeliverTx & {
                    code: number;
                    data: Uint8Array;
                    log: string;
                    info: string;
                    gasWanted: bigint;
                    gasUsed: bigint;
                    events: _76.Event[] & (_76.Event & {
                        type: string;
                        attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                            key: Uint8Array;
                            value: Uint8Array;
                            index: boolean;
                        } & Record<Exclude<keyof I_16["deliverTx"]["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_16["deliverTx"]["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                    } & Record<Exclude<keyof I_16["deliverTx"]["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_16["deliverTx"]["events"], keyof _76.Event[]>, never>;
                    codespace: string;
                } & Record<Exclude<keyof I_16["deliverTx"], keyof _76.ResponseDeliverTx>, never>;
                endBlock?: _76.ResponseEndBlock & {
                    validatorUpdates: _76.ValidatorUpdate[] & (_76.ValidatorUpdate & {
                        pubKey: _77.PublicKey & {
                            ed25519?: Uint8Array;
                            secp256k1?: Uint8Array;
                        } & Record<Exclude<keyof I_16["endBlock"]["validatorUpdates"][number]["pubKey"], keyof _77.PublicKey>, never>;
                        power: bigint;
                    } & Record<Exclude<keyof I_16["endBlock"]["validatorUpdates"][number], keyof _76.ValidatorUpdate>, never>)[] & Record<Exclude<keyof I_16["endBlock"]["validatorUpdates"], keyof _76.ValidatorUpdate[]>, never>;
                    consensusParamUpdates?: _76.ConsensusParams & {
                        block?: _76.BlockParams & {
                            maxBytes: bigint;
                            maxGas: bigint;
                        } & Record<Exclude<keyof I_16["endBlock"]["consensusParamUpdates"]["block"], keyof _76.BlockParams>, never>;
                        evidence?: _82.EvidenceParams & {
                            maxAgeNumBlocks: bigint;
                            maxAgeDuration: import("../google/protobuf/duration").Duration & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I_16["endBlock"]["consensusParamUpdates"]["evidence"]["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                            maxBytes: bigint;
                        } & Record<Exclude<keyof I_16["endBlock"]["consensusParamUpdates"]["evidence"], keyof _82.EvidenceParams>, never>;
                        validator?: _82.ValidatorParams & {
                            pubKeyTypes: string[] & Record<Exclude<keyof I_16["endBlock"]["consensusParamUpdates"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                        } & Record<Exclude<keyof I_16["endBlock"]["consensusParamUpdates"]["validator"], "pubKeyTypes">, never>;
                        version?: _82.VersionParams & {
                            appVersion: bigint;
                        } & Record<Exclude<keyof I_16["endBlock"]["consensusParamUpdates"]["version"], "appVersion">, never>;
                    } & Record<Exclude<keyof I_16["endBlock"]["consensusParamUpdates"], keyof _76.ConsensusParams>, never>;
                    events: _76.Event[] & (_76.Event & {
                        type: string;
                        attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                            key: Uint8Array;
                            value: Uint8Array;
                            index: boolean;
                        } & Record<Exclude<keyof I_16["endBlock"]["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_16["endBlock"]["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                    } & Record<Exclude<keyof I_16["endBlock"]["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_16["endBlock"]["events"], keyof _76.Event[]>, never>;
                } & Record<Exclude<keyof I_16["endBlock"], keyof _76.ResponseEndBlock>, never>;
                commit?: _76.ResponseCommit & {
                    data: Uint8Array;
                    retainHeight: bigint;
                } & Record<Exclude<keyof I_16["commit"], keyof _76.ResponseCommit>, never>;
                listSnapshots?: _76.ResponseListSnapshots & {
                    snapshots: _76.Snapshot[] & (_76.Snapshot & {
                        height: bigint;
                        format: number;
                        chunks: number;
                        hash: Uint8Array;
                        metadata: Uint8Array;
                    } & Record<Exclude<keyof I_16["listSnapshots"]["snapshots"][number], keyof _76.Snapshot>, never>)[] & Record<Exclude<keyof I_16["listSnapshots"]["snapshots"], keyof _76.Snapshot[]>, never>;
                } & Record<Exclude<keyof I_16["listSnapshots"], "snapshots">, never>;
                offerSnapshot?: _76.ResponseOfferSnapshot & {
                    result: _76.ResponseOfferSnapshot_Result;
                } & Record<Exclude<keyof I_16["offerSnapshot"], "result">, never>;
                loadSnapshotChunk?: _76.ResponseLoadSnapshotChunk & {
                    chunk: Uint8Array;
                } & Record<Exclude<keyof I_16["loadSnapshotChunk"], "chunk">, never>;
                applySnapshotChunk?: _76.ResponseApplySnapshotChunk & {
                    result: _76.ResponseApplySnapshotChunk_Result;
                    refetchChunks: number[] & Record<Exclude<keyof I_16["applySnapshotChunk"]["refetchChunks"], keyof number[]>, never>;
                    rejectSenders: string[] & Record<Exclude<keyof I_16["applySnapshotChunk"]["rejectSenders"], keyof string[]>, never>;
                } & Record<Exclude<keyof I_16["applySnapshotChunk"], keyof _76.ResponseApplySnapshotChunk>, never>;
            } & Record<Exclude<keyof I_16, keyof _76.Response>, never>>(object: I_16): _76.Response;
        };
        ResponseException: {
            typeUrl: string;
            encode(message: _76.ResponseException, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseException;
            fromJSON(object: any): _76.ResponseException;
            toJSON(message: _76.ResponseException): unknown;
            fromPartial<I_17 extends Partial<_76.ResponseException> & {
                error?: string;
            } & Record<Exclude<keyof I_17, "error">, never>>(object: I_17): _76.ResponseException;
        };
        ResponseEcho: {
            typeUrl: string;
            encode(message: _76.ResponseEcho, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseEcho;
            fromJSON(object: any): _76.ResponseEcho;
            toJSON(message: _76.ResponseEcho): unknown;
            fromPartial<I_18 extends Partial<_76.ResponseEcho> & {
                message?: string;
            } & Record<Exclude<keyof I_18, "message">, never>>(object: I_18): _76.ResponseEcho;
        };
        ResponseFlush: {
            typeUrl: string;
            encode(_: _76.ResponseFlush, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseFlush;
            fromJSON(_: any): _76.ResponseFlush;
            toJSON(_: _76.ResponseFlush): unknown;
            fromPartial<I_19 extends Partial<_76.ResponseFlush> & {} & Record<Exclude<keyof I_19, never>, never>>(_: I_19): _76.ResponseFlush;
        };
        ResponseInfo: {
            typeUrl: string;
            encode(message: _76.ResponseInfo, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseInfo;
            fromJSON(object: any): _76.ResponseInfo;
            toJSON(message: _76.ResponseInfo): unknown;
            fromPartial<I_20 extends Partial<_76.ResponseInfo> & {
                data?: string;
                version?: string;
                appVersion?: bigint;
                lastBlockHeight?: bigint;
                lastBlockAppHash?: Uint8Array;
            } & Record<Exclude<keyof I_20, keyof _76.ResponseInfo>, never>>(object: I_20): _76.ResponseInfo;
        };
        ResponseSetOption: {
            typeUrl: string;
            encode(message: _76.ResponseSetOption, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseSetOption;
            fromJSON(object: any): _76.ResponseSetOption;
            toJSON(message: _76.ResponseSetOption): unknown;
            fromPartial<I_21 extends Partial<_76.ResponseSetOption> & {
                code?: number;
                log?: string;
                info?: string;
            } & Record<Exclude<keyof I_21, keyof _76.ResponseSetOption>, never>>(object: I_21): _76.ResponseSetOption;
        };
        ResponseInitChain: {
            typeUrl: string;
            encode(message: _76.ResponseInitChain, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseInitChain;
            fromJSON(object: any): _76.ResponseInitChain;
            toJSON(message: _76.ResponseInitChain): unknown;
            fromPartial<I_22 extends Partial<_76.ResponseInitChain> & {
                consensusParams?: _76.ConsensusParams & {
                    block?: _76.BlockParams & {
                        maxBytes: bigint;
                        maxGas: bigint;
                    } & Record<Exclude<keyof I_22["consensusParams"]["block"], keyof _76.BlockParams>, never>;
                    evidence?: _82.EvidenceParams & {
                        maxAgeNumBlocks: bigint;
                        maxAgeDuration: import("../google/protobuf/duration").Duration & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_22["consensusParams"]["evidence"]["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                        maxBytes: bigint;
                    } & Record<Exclude<keyof I_22["consensusParams"]["evidence"], keyof _82.EvidenceParams>, never>;
                    validator?: _82.ValidatorParams & {
                        pubKeyTypes: string[] & Record<Exclude<keyof I_22["consensusParams"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                    } & Record<Exclude<keyof I_22["consensusParams"]["validator"], "pubKeyTypes">, never>;
                    version?: _82.VersionParams & {
                        appVersion: bigint;
                    } & Record<Exclude<keyof I_22["consensusParams"]["version"], "appVersion">, never>;
                } & Record<Exclude<keyof I_22["consensusParams"], keyof _76.ConsensusParams>, never>;
                validators?: _76.ValidatorUpdate[] & (_76.ValidatorUpdate & {
                    pubKey: _77.PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I_22["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                    power: bigint;
                } & Record<Exclude<keyof I_22["validators"][number], keyof _76.ValidatorUpdate>, never>)[] & Record<Exclude<keyof I_22["validators"], keyof _76.ValidatorUpdate[]>, never>;
                appHash?: Uint8Array;
            } & Record<Exclude<keyof I_22, keyof _76.ResponseInitChain>, never>>(object: I_22): _76.ResponseInitChain;
        };
        ResponseQuery: {
            typeUrl: string;
            encode(message: _76.ResponseQuery, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseQuery;
            fromJSON(object: any): _76.ResponseQuery;
            toJSON(message: _76.ResponseQuery): unknown;
            fromPartial<I_23 extends Partial<_76.ResponseQuery> & {
                code?: number;
                log?: string;
                info?: string;
                index?: bigint;
                key?: Uint8Array;
                value?: Uint8Array;
                proofOps?: _78.ProofOps & {
                    ops: _78.ProofOp[] & (_78.ProofOp & {
                        type: string;
                        key: Uint8Array;
                        data: Uint8Array;
                    } & Record<Exclude<keyof I_23["proofOps"]["ops"][number], keyof _78.ProofOp>, never>)[] & Record<Exclude<keyof I_23["proofOps"]["ops"], keyof _78.ProofOp[]>, never>;
                } & Record<Exclude<keyof I_23["proofOps"], "ops">, never>;
                height?: bigint;
                codespace?: string;
            } & Record<Exclude<keyof I_23, keyof _76.ResponseQuery>, never>>(object: I_23): _76.ResponseQuery;
        };
        ResponseBeginBlock: {
            typeUrl: string;
            encode(message: _76.ResponseBeginBlock, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseBeginBlock;
            fromJSON(object: any): _76.ResponseBeginBlock;
            toJSON(message: _76.ResponseBeginBlock): unknown;
            fromPartial<I_24 extends Partial<_76.ResponseBeginBlock> & {
                events?: _76.Event[] & (_76.Event & {
                    type: string;
                    attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                        key: Uint8Array;
                        value: Uint8Array;
                        index: boolean;
                    } & Record<Exclude<keyof I_24["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_24["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                } & Record<Exclude<keyof I_24["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_24["events"], keyof _76.Event[]>, never>;
            } & Record<Exclude<keyof I_24, "events">, never>>(object: I_24): _76.ResponseBeginBlock;
        };
        ResponseCheckTx: {
            typeUrl: string;
            encode(message: _76.ResponseCheckTx, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseCheckTx;
            fromJSON(object: any): _76.ResponseCheckTx;
            toJSON(message: _76.ResponseCheckTx): unknown;
            fromPartial<I_25 extends Partial<_76.ResponseCheckTx> & {
                code?: number;
                data?: Uint8Array;
                log?: string;
                info?: string;
                gasWanted?: bigint;
                gasUsed?: bigint;
                events?: _76.Event[] & (_76.Event & {
                    type: string;
                    attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                        key: Uint8Array;
                        value: Uint8Array;
                        index: boolean;
                    } & Record<Exclude<keyof I_25["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_25["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                } & Record<Exclude<keyof I_25["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_25["events"], keyof _76.Event[]>, never>;
                codespace?: string;
                sender?: string;
                priority?: bigint;
                mempoolError?: string;
            } & Record<Exclude<keyof I_25, keyof _76.ResponseCheckTx>, never>>(object: I_25): _76.ResponseCheckTx;
        };
        ResponseDeliverTx: {
            typeUrl: string;
            encode(message: _76.ResponseDeliverTx, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseDeliverTx;
            fromJSON(object: any): _76.ResponseDeliverTx;
            toJSON(message: _76.ResponseDeliverTx): unknown;
            fromPartial<I_26 extends Partial<_76.ResponseDeliverTx> & {
                code?: number;
                data?: Uint8Array;
                log?: string;
                info?: string;
                gasWanted?: bigint;
                gasUsed?: bigint;
                events?: _76.Event[] & (_76.Event & {
                    type: string;
                    attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                        key: Uint8Array;
                        value: Uint8Array;
                        index: boolean;
                    } & Record<Exclude<keyof I_26["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_26["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                } & Record<Exclude<keyof I_26["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_26["events"], keyof _76.Event[]>, never>;
                codespace?: string;
            } & Record<Exclude<keyof I_26, keyof _76.ResponseDeliverTx>, never>>(object: I_26): _76.ResponseDeliverTx;
        };
        ResponseEndBlock: {
            typeUrl: string;
            encode(message: _76.ResponseEndBlock, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseEndBlock;
            fromJSON(object: any): _76.ResponseEndBlock;
            toJSON(message: _76.ResponseEndBlock): unknown;
            fromPartial<I_27 extends Partial<_76.ResponseEndBlock> & {
                validatorUpdates?: _76.ValidatorUpdate[] & (_76.ValidatorUpdate & {
                    pubKey: _77.PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I_27["validatorUpdates"][number]["pubKey"], keyof _77.PublicKey>, never>;
                    power: bigint;
                } & Record<Exclude<keyof I_27["validatorUpdates"][number], keyof _76.ValidatorUpdate>, never>)[] & Record<Exclude<keyof I_27["validatorUpdates"], keyof _76.ValidatorUpdate[]>, never>;
                consensusParamUpdates?: _76.ConsensusParams & {
                    block?: _76.BlockParams & {
                        maxBytes: bigint;
                        maxGas: bigint;
                    } & Record<Exclude<keyof I_27["consensusParamUpdates"]["block"], keyof _76.BlockParams>, never>;
                    evidence?: _82.EvidenceParams & {
                        maxAgeNumBlocks: bigint;
                        maxAgeDuration: import("../google/protobuf/duration").Duration & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_27["consensusParamUpdates"]["evidence"]["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                        maxBytes: bigint;
                    } & Record<Exclude<keyof I_27["consensusParamUpdates"]["evidence"], keyof _82.EvidenceParams>, never>;
                    validator?: _82.ValidatorParams & {
                        pubKeyTypes: string[] & Record<Exclude<keyof I_27["consensusParamUpdates"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                    } & Record<Exclude<keyof I_27["consensusParamUpdates"]["validator"], "pubKeyTypes">, never>;
                    version?: _82.VersionParams & {
                        appVersion: bigint;
                    } & Record<Exclude<keyof I_27["consensusParamUpdates"]["version"], "appVersion">, never>;
                } & Record<Exclude<keyof I_27["consensusParamUpdates"], keyof _76.ConsensusParams>, never>;
                events?: _76.Event[] & (_76.Event & {
                    type: string;
                    attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                        key: Uint8Array;
                        value: Uint8Array;
                        index: boolean;
                    } & Record<Exclude<keyof I_27["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_27["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                } & Record<Exclude<keyof I_27["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_27["events"], keyof _76.Event[]>, never>;
            } & Record<Exclude<keyof I_27, keyof _76.ResponseEndBlock>, never>>(object: I_27): _76.ResponseEndBlock;
        };
        ResponseCommit: {
            typeUrl: string;
            encode(message: _76.ResponseCommit, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseCommit;
            fromJSON(object: any): _76.ResponseCommit;
            toJSON(message: _76.ResponseCommit): unknown;
            fromPartial<I_28 extends Partial<_76.ResponseCommit> & {
                data?: Uint8Array;
                retainHeight?: bigint;
            } & Record<Exclude<keyof I_28, keyof _76.ResponseCommit>, never>>(object: I_28): _76.ResponseCommit;
        };
        ResponseListSnapshots: {
            typeUrl: string;
            encode(message: _76.ResponseListSnapshots, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseListSnapshots;
            fromJSON(object: any): _76.ResponseListSnapshots;
            toJSON(message: _76.ResponseListSnapshots): unknown;
            fromPartial<I_29 extends Partial<_76.ResponseListSnapshots> & {
                snapshots?: _76.Snapshot[] & (_76.Snapshot & {
                    height: bigint;
                    format: number;
                    chunks: number;
                    hash: Uint8Array;
                    metadata: Uint8Array;
                } & Record<Exclude<keyof I_29["snapshots"][number], keyof _76.Snapshot>, never>)[] & Record<Exclude<keyof I_29["snapshots"], keyof _76.Snapshot[]>, never>;
            } & Record<Exclude<keyof I_29, "snapshots">, never>>(object: I_29): _76.ResponseListSnapshots;
        };
        ResponseOfferSnapshot: {
            typeUrl: string;
            encode(message: _76.ResponseOfferSnapshot, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseOfferSnapshot;
            fromJSON(object: any): _76.ResponseOfferSnapshot;
            toJSON(message: _76.ResponseOfferSnapshot): unknown;
            fromPartial<I_30 extends Partial<_76.ResponseOfferSnapshot> & {
                result?: _76.ResponseOfferSnapshot_Result;
            } & Record<Exclude<keyof I_30, "result">, never>>(object: I_30): _76.ResponseOfferSnapshot;
        };
        ResponseLoadSnapshotChunk: {
            typeUrl: string;
            encode(message: _76.ResponseLoadSnapshotChunk, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseLoadSnapshotChunk;
            fromJSON(object: any): _76.ResponseLoadSnapshotChunk;
            toJSON(message: _76.ResponseLoadSnapshotChunk): unknown;
            fromPartial<I_31 extends Partial<_76.ResponseLoadSnapshotChunk> & {
                chunk?: Uint8Array;
            } & Record<Exclude<keyof I_31, "chunk">, never>>(object: I_31): _76.ResponseLoadSnapshotChunk;
        };
        ResponseApplySnapshotChunk: {
            typeUrl: string;
            encode(message: _76.ResponseApplySnapshotChunk, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ResponseApplySnapshotChunk;
            fromJSON(object: any): _76.ResponseApplySnapshotChunk;
            toJSON(message: _76.ResponseApplySnapshotChunk): unknown;
            fromPartial<I_32 extends Partial<_76.ResponseApplySnapshotChunk> & {
                result?: _76.ResponseApplySnapshotChunk_Result;
                refetchChunks?: number[] & Record<Exclude<keyof I_32["refetchChunks"], keyof number[]>, never>;
                rejectSenders?: string[] & Record<Exclude<keyof I_32["rejectSenders"], keyof string[]>, never>;
            } & Record<Exclude<keyof I_32, keyof _76.ResponseApplySnapshotChunk>, never>>(object: I_32): _76.ResponseApplySnapshotChunk;
        };
        ConsensusParams: {
            typeUrl: string;
            encode(message: _76.ConsensusParams, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ConsensusParams;
            fromJSON(object: any): _76.ConsensusParams;
            toJSON(message: _76.ConsensusParams): unknown;
            fromPartial<I_33 extends Partial<_76.ConsensusParams> & {
                block?: _76.BlockParams & {
                    maxBytes: bigint;
                    maxGas: bigint;
                } & Record<Exclude<keyof I_33["block"], keyof _76.BlockParams>, never>;
                evidence?: _82.EvidenceParams & {
                    maxAgeNumBlocks: bigint;
                    maxAgeDuration: import("../google/protobuf/duration").Duration & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_33["evidence"]["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                    maxBytes: bigint;
                } & Record<Exclude<keyof I_33["evidence"], keyof _82.EvidenceParams>, never>;
                validator?: _82.ValidatorParams & {
                    pubKeyTypes: string[] & Record<Exclude<keyof I_33["validator"]["pubKeyTypes"], keyof string[]>, never>;
                } & Record<Exclude<keyof I_33["validator"], "pubKeyTypes">, never>;
                version?: _82.VersionParams & {
                    appVersion: bigint;
                } & Record<Exclude<keyof I_33["version"], "appVersion">, never>;
            } & Record<Exclude<keyof I_33, keyof _76.ConsensusParams>, never>>(object: I_33): _76.ConsensusParams;
        };
        BlockParams: {
            typeUrl: string;
            encode(message: _76.BlockParams, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.BlockParams;
            fromJSON(object: any): _76.BlockParams;
            toJSON(message: _76.BlockParams): unknown;
            fromPartial<I_34 extends Partial<_76.BlockParams> & {
                maxBytes?: bigint;
                maxGas?: bigint;
            } & Record<Exclude<keyof I_34, keyof _76.BlockParams>, never>>(object: I_34): _76.BlockParams;
        };
        LastCommitInfo: {
            typeUrl: string;
            encode(message: _76.LastCommitInfo, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.LastCommitInfo;
            fromJSON(object: any): _76.LastCommitInfo;
            toJSON(message: _76.LastCommitInfo): unknown;
            fromPartial<I_35 extends Partial<_76.LastCommitInfo> & {
                round?: number;
                votes?: _76.VoteInfo[] & (_76.VoteInfo & {
                    validator: _76.Validator & {
                        address: Uint8Array;
                        power: bigint;
                    } & Record<Exclude<keyof I_35["votes"][number]["validator"], keyof _76.Validator>, never>;
                    signedLastBlock: boolean;
                } & Record<Exclude<keyof I_35["votes"][number], keyof _76.VoteInfo>, never>)[] & Record<Exclude<keyof I_35["votes"], keyof _76.VoteInfo[]>, never>;
            } & Record<Exclude<keyof I_35, keyof _76.LastCommitInfo>, never>>(object: I_35): _76.LastCommitInfo;
        };
        Event: {
            typeUrl: string;
            encode(message: _76.Event, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.Event;
            fromJSON(object: any): _76.Event;
            toJSON(message: _76.Event): unknown;
            fromPartial<I_36 extends Partial<_76.Event> & {
                type?: string;
                attributes?: _76.EventAttribute[] & (_76.EventAttribute & {
                    key: Uint8Array;
                    value: Uint8Array;
                    index: boolean;
                } & Record<Exclude<keyof I_36["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_36["attributes"], keyof _76.EventAttribute[]>, never>;
            } & Record<Exclude<keyof I_36, keyof _76.Event>, never>>(object: I_36): _76.Event;
        };
        EventAttribute: {
            typeUrl: string;
            encode(message: _76.EventAttribute, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.EventAttribute;
            fromJSON(object: any): _76.EventAttribute;
            toJSON(message: _76.EventAttribute): unknown;
            fromPartial<I_37 extends Partial<_76.EventAttribute> & {
                key?: Uint8Array;
                value?: Uint8Array;
                index?: boolean;
            } & Record<Exclude<keyof I_37, keyof _76.EventAttribute>, never>>(object: I_37): _76.EventAttribute;
        };
        TxResult: {
            typeUrl: string;
            encode(message: _76.TxResult, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.TxResult;
            fromJSON(object: any): _76.TxResult;
            toJSON(message: _76.TxResult): unknown;
            fromPartial<I_38 extends Partial<_76.TxResult> & {
                height?: bigint;
                index?: number;
                tx?: Uint8Array;
                result?: _76.ResponseDeliverTx & {
                    code: number;
                    data: Uint8Array;
                    log: string;
                    info: string;
                    gasWanted: bigint;
                    gasUsed: bigint;
                    events: _76.Event[] & (_76.Event & {
                        type: string;
                        attributes: _76.EventAttribute[] & (_76.EventAttribute & {
                            key: Uint8Array;
                            value: Uint8Array;
                            index: boolean;
                        } & Record<Exclude<keyof I_38["result"]["events"][number]["attributes"][number], keyof _76.EventAttribute>, never>)[] & Record<Exclude<keyof I_38["result"]["events"][number]["attributes"], keyof _76.EventAttribute[]>, never>;
                    } & Record<Exclude<keyof I_38["result"]["events"][number], keyof _76.Event>, never>)[] & Record<Exclude<keyof I_38["result"]["events"], keyof _76.Event[]>, never>;
                    codespace: string;
                } & Record<Exclude<keyof I_38["result"], keyof _76.ResponseDeliverTx>, never>;
            } & Record<Exclude<keyof I_38, keyof _76.TxResult>, never>>(object: I_38): _76.TxResult;
        };
        Validator: {
            typeUrl: string;
            encode(message: _76.Validator, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.Validator;
            fromJSON(object: any): _76.Validator;
            toJSON(message: _76.Validator): unknown;
            fromPartial<I_39 extends Partial<_76.Validator> & {
                address?: Uint8Array;
                power?: bigint;
            } & Record<Exclude<keyof I_39, keyof _76.Validator>, never>>(object: I_39): _76.Validator;
        };
        ValidatorUpdate: {
            typeUrl: string;
            encode(message: _76.ValidatorUpdate, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.ValidatorUpdate;
            fromJSON(object: any): _76.ValidatorUpdate;
            toJSON(message: _76.ValidatorUpdate): unknown;
            fromPartial<I_40 extends Partial<_76.ValidatorUpdate> & {
                pubKey?: _77.PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I_40["pubKey"], keyof _77.PublicKey>, never>;
                power?: bigint;
            } & Record<Exclude<keyof I_40, keyof _76.ValidatorUpdate>, never>>(object: I_40): _76.ValidatorUpdate;
        };
        VoteInfo: {
            typeUrl: string;
            encode(message: _76.VoteInfo, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.VoteInfo;
            fromJSON(object: any): _76.VoteInfo;
            toJSON(message: _76.VoteInfo): unknown;
            fromPartial<I_41 extends Partial<_76.VoteInfo> & {
                validator?: _76.Validator & {
                    address: Uint8Array;
                    power: bigint;
                } & Record<Exclude<keyof I_41["validator"], keyof _76.Validator>, never>;
                signedLastBlock?: boolean;
            } & Record<Exclude<keyof I_41, keyof _76.VoteInfo>, never>>(object: I_41): _76.VoteInfo;
        };
        Evidence: {
            typeUrl: string;
            encode(message: _76.Evidence, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.Evidence;
            fromJSON(object: any): _76.Evidence;
            toJSON(message: _76.Evidence): unknown;
            fromPartial<I_42 extends Partial<_76.Evidence> & {
                type?: _76.EvidenceType;
                validator?: _76.Validator & {
                    address: Uint8Array;
                    power: bigint;
                } & Record<Exclude<keyof I_42["validator"], keyof _76.Validator>, never>;
                height?: bigint;
                time?: import("../google/protobuf/timestamp").Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_42["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                totalVotingPower?: bigint;
            } & Record<Exclude<keyof I_42, keyof _76.Evidence>, never>>(object: I_42): _76.Evidence;
        };
        Snapshot: {
            typeUrl: string;
            encode(message: _76.Snapshot, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _76.Snapshot;
            fromJSON(object: any): _76.Snapshot;
            toJSON(message: _76.Snapshot): unknown;
            fromPartial<I_43 extends Partial<_76.Snapshot> & {
                height?: bigint;
                format?: number;
                chunks?: number;
                hash?: Uint8Array;
                metadata?: Uint8Array;
            } & Record<Exclude<keyof I_43, keyof _76.Snapshot>, never>>(object: I_43): _76.Snapshot;
        };
        ABCIApplicationClientImpl: typeof _76.ABCIApplicationClientImpl;
        createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
            Echo(request: _76.RequestEcho): Promise<_76.ResponseEcho>;
            Flush(request?: _76.RequestFlush): Promise<_76.ResponseFlush>;
            Info(request: _76.RequestInfo): Promise<_76.ResponseInfo>;
            SetOption(request: _76.RequestSetOption): Promise<_76.ResponseSetOption>;
            DeliverTx(request: _76.RequestDeliverTx): Promise<_76.ResponseDeliverTx>;
            CheckTx(request: _76.RequestCheckTx): Promise<_76.ResponseCheckTx>;
            Query(request: _76.RequestQuery): Promise<_76.ResponseQuery>;
            Commit(request?: _76.RequestCommit): Promise<_76.ResponseCommit>;
            InitChain(request: _76.RequestInitChain): Promise<_76.ResponseInitChain>;
            BeginBlock(request: _76.RequestBeginBlock): Promise<_76.ResponseBeginBlock>;
            EndBlock(request: _76.RequestEndBlock): Promise<_76.ResponseEndBlock>;
            ListSnapshots(request?: _76.RequestListSnapshots): Promise<_76.ResponseListSnapshots>;
            OfferSnapshot(request: _76.RequestOfferSnapshot): Promise<_76.ResponseOfferSnapshot>;
            LoadSnapshotChunk(request: _76.RequestLoadSnapshotChunk): Promise<_76.ResponseLoadSnapshotChunk>;
            ApplySnapshotChunk(request: _76.RequestApplySnapshotChunk): Promise<_76.ResponseApplySnapshotChunk>;
        };
    };
    const crypto: {
        protobufPackage: "tendermint.crypto";
        Proof: {
            typeUrl: string;
            encode(message: _78.Proof, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _78.Proof;
            fromJSON(object: any): _78.Proof;
            toJSON(message: _78.Proof): unknown;
            fromPartial<I extends Partial<_78.Proof> & {
                total?: bigint;
                index?: bigint;
                leafHash?: Uint8Array;
                aunts?: Uint8Array[] & Record<Exclude<keyof I["aunts"], keyof Uint8Array[]>, never>;
            } & Record<Exclude<keyof I, keyof _78.Proof>, never>>(object: I): _78.Proof;
        };
        ValueOp: {
            typeUrl: string;
            encode(message: _78.ValueOp, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _78.ValueOp;
            fromJSON(object: any): _78.ValueOp;
            toJSON(message: _78.ValueOp): unknown;
            fromPartial<I_1 extends Partial<_78.ValueOp> & {
                key?: Uint8Array;
                proof?: _78.Proof & {
                    total: bigint;
                    index: bigint;
                    leafHash: Uint8Array;
                    aunts: Uint8Array[] & Record<Exclude<keyof I_1["proof"]["aunts"], keyof Uint8Array[]>, never>;
                } & Record<Exclude<keyof I_1["proof"], keyof _78.Proof>, never>;
            } & Record<Exclude<keyof I_1, keyof _78.ValueOp>, never>>(object: I_1): _78.ValueOp;
        };
        DominoOp: {
            typeUrl: string;
            encode(message: _78.DominoOp, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _78.DominoOp;
            fromJSON(object: any): _78.DominoOp;
            toJSON(message: _78.DominoOp): unknown;
            fromPartial<I_2 extends Partial<_78.DominoOp> & {
                key?: string;
                input?: string;
                output?: string;
            } & Record<Exclude<keyof I_2, keyof _78.DominoOp>, never>>(object: I_2): _78.DominoOp;
        };
        ProofOp: {
            typeUrl: string;
            encode(message: _78.ProofOp, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _78.ProofOp;
            fromJSON(object: any): _78.ProofOp;
            toJSON(message: _78.ProofOp): unknown;
            fromPartial<I_3 extends Partial<_78.ProofOp> & {
                type?: string;
                key?: Uint8Array;
                data?: Uint8Array;
            } & Record<Exclude<keyof I_3, keyof _78.ProofOp>, never>>(object: I_3): _78.ProofOp;
        };
        ProofOps: {
            typeUrl: string;
            encode(message: _78.ProofOps, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _78.ProofOps;
            fromJSON(object: any): _78.ProofOps;
            toJSON(message: _78.ProofOps): unknown;
            fromPartial<I_4 extends Partial<_78.ProofOps> & {
                ops?: _78.ProofOp[] & (_78.ProofOp & {
                    type: string;
                    key: Uint8Array;
                    data: Uint8Array;
                } & Record<Exclude<keyof I_4["ops"][number], keyof _78.ProofOp>, never>)[] & Record<Exclude<keyof I_4["ops"], keyof _78.ProofOp[]>, never>;
            } & Record<Exclude<keyof I_4, "ops">, never>>(object: I_4): _78.ProofOps;
        };
        PublicKey: {
            typeUrl: string;
            encode(message: _77.PublicKey, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _77.PublicKey;
            fromJSON(object: any): _77.PublicKey;
            toJSON(message: _77.PublicKey): unknown;
            fromPartial<I_5 extends Partial<_77.PublicKey> & {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            } & Record<Exclude<keyof I_5, keyof _77.PublicKey>, never>>(object: I_5): _77.PublicKey;
        };
    };
    const p2p: {
        protobufPackage: "tendermint.p2p";
        NetAddress: {
            typeUrl: string;
            encode(message: _79.NetAddress, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _79.NetAddress;
            fromJSON(object: any): _79.NetAddress;
            toJSON(message: _79.NetAddress): unknown;
            fromPartial<I extends Partial<_79.NetAddress> & {
                id?: string;
                ip?: string;
                port?: number;
            } & Record<Exclude<keyof I, keyof _79.NetAddress>, never>>(object: I): _79.NetAddress;
        };
        ProtocolVersion: {
            typeUrl: string;
            encode(message: _79.ProtocolVersion, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _79.ProtocolVersion;
            fromJSON(object: any): _79.ProtocolVersion;
            toJSON(message: _79.ProtocolVersion): unknown;
            fromPartial<I_1 extends Partial<_79.ProtocolVersion> & {
                p2p?: bigint;
                block?: bigint;
                app?: bigint;
            } & Record<Exclude<keyof I_1, keyof _79.ProtocolVersion>, never>>(object: I_1): _79.ProtocolVersion;
        };
        DefaultNodeInfo: {
            typeUrl: string;
            encode(message: _79.DefaultNodeInfo, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _79.DefaultNodeInfo;
            fromJSON(object: any): _79.DefaultNodeInfo;
            toJSON(message: _79.DefaultNodeInfo): unknown;
            fromPartial<I_2 extends Partial<_79.DefaultNodeInfo> & {
                protocolVersion?: _79.ProtocolVersion & {
                    p2p: bigint;
                    block: bigint;
                    app: bigint;
                } & Record<Exclude<keyof I_2["protocolVersion"], keyof _79.ProtocolVersion>, never>;
                defaultNodeId?: string;
                listenAddr?: string;
                network?: string;
                version?: string;
                channels?: Uint8Array;
                moniker?: string;
                other?: _79.DefaultNodeInfoOther & {
                    txIndex: string;
                    rpcAddress: string;
                } & Record<Exclude<keyof I_2["other"], keyof _79.DefaultNodeInfoOther>, never>;
            } & Record<Exclude<keyof I_2, keyof _79.DefaultNodeInfo>, never>>(object: I_2): _79.DefaultNodeInfo;
        };
        DefaultNodeInfoOther: {
            typeUrl: string;
            encode(message: _79.DefaultNodeInfoOther, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _79.DefaultNodeInfoOther;
            fromJSON(object: any): _79.DefaultNodeInfoOther;
            toJSON(message: _79.DefaultNodeInfoOther): unknown;
            fromPartial<I_3 extends Partial<_79.DefaultNodeInfoOther> & {
                txIndex?: string;
                rpcAddress?: string;
            } & Record<Exclude<keyof I_3, keyof _79.DefaultNodeInfoOther>, never>>(object: I_3): _79.DefaultNodeInfoOther;
        };
    };
    const types: {
        protobufPackage: "tendermint.types";
        ValidatorSet: {
            typeUrl: string;
            encode(message: _84.ValidatorSet, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _84.ValidatorSet;
            fromJSON(object: any): _84.ValidatorSet;
            toJSON(message: _84.ValidatorSet): unknown;
            fromPartial<I extends Partial<_84.ValidatorSet> & {
                validators?: _84.Validator[] & (_84.Validator & {
                    address: Uint8Array;
                    pubKey: _77.PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                    votingPower: bigint;
                    proposerPriority: bigint;
                } & Record<Exclude<keyof I["validators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I["validators"], keyof _84.Validator[]>, never>;
                proposer?: _84.Validator & {
                    address: Uint8Array;
                    pubKey: _77.PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I["proposer"]["pubKey"], keyof _77.PublicKey>, never>;
                    votingPower: bigint;
                    proposerPriority: bigint;
                } & Record<Exclude<keyof I["proposer"], keyof _84.Validator>, never>;
                totalVotingPower?: bigint;
            } & Record<Exclude<keyof I, keyof _84.ValidatorSet>, never>>(object: I): _84.ValidatorSet;
        };
        Validator: {
            typeUrl: string;
            encode(message: _84.Validator, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _84.Validator;
            fromJSON(object: any): _84.Validator;
            toJSON(message: _84.Validator): unknown;
            fromPartial<I_1 extends Partial<_84.Validator> & {
                address?: Uint8Array;
                pubKey?: _77.PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I_1["pubKey"], keyof _77.PublicKey>, never>;
                votingPower?: bigint;
                proposerPriority?: bigint;
            } & Record<Exclude<keyof I_1, keyof _84.Validator>, never>>(object: I_1): _84.Validator;
        };
        SimpleValidator: {
            typeUrl: string;
            encode(message: _84.SimpleValidator, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _84.SimpleValidator;
            fromJSON(object: any): _84.SimpleValidator;
            toJSON(message: _84.SimpleValidator): unknown;
            fromPartial<I_2 extends Partial<_84.SimpleValidator> & {
                pubKey?: _77.PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I_2["pubKey"], keyof _77.PublicKey>, never>;
                votingPower?: bigint;
            } & Record<Exclude<keyof I_2, keyof _84.SimpleValidator>, never>>(object: I_2): _84.SimpleValidator;
        };
        blockIDFlagFromJSON(object: any): _83.BlockIDFlag;
        blockIDFlagToJSON(object: _83.BlockIDFlag): string;
        signedMsgTypeFromJSON(object: any): _83.SignedMsgType;
        signedMsgTypeToJSON(object: _83.SignedMsgType): string;
        BlockIDFlag: typeof _83.BlockIDFlag;
        BlockIDFlagSDKType: typeof _83.BlockIDFlag;
        SignedMsgType: typeof _83.SignedMsgType;
        SignedMsgTypeSDKType: typeof _83.SignedMsgType;
        PartSetHeader: {
            typeUrl: string;
            encode(message: _83.PartSetHeader, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.PartSetHeader;
            fromJSON(object: any): _83.PartSetHeader;
            toJSON(message: _83.PartSetHeader): unknown;
            fromPartial<I_3 extends Partial<_83.PartSetHeader> & {
                total?: number;
                hash?: Uint8Array;
            } & Record<Exclude<keyof I_3, keyof _83.PartSetHeader>, never>>(object: I_3): _83.PartSetHeader;
        };
        Part: {
            typeUrl: string;
            encode(message: _83.Part, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.Part;
            fromJSON(object: any): _83.Part;
            toJSON(message: _83.Part): unknown;
            fromPartial<I_4 extends Partial<_83.Part> & {
                index?: number;
                bytes?: Uint8Array;
                proof?: _78.Proof & {
                    total: bigint;
                    index: bigint;
                    leafHash: Uint8Array;
                    aunts: Uint8Array[] & Record<Exclude<keyof I_4["proof"]["aunts"], keyof Uint8Array[]>, never>;
                } & Record<Exclude<keyof I_4["proof"], keyof _78.Proof>, never>;
            } & Record<Exclude<keyof I_4, keyof _83.Part>, never>>(object: I_4): _83.Part;
        };
        BlockID: {
            typeUrl: string;
            encode(message: _83.BlockID, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.BlockID;
            fromJSON(object: any): _83.BlockID;
            toJSON(message: _83.BlockID): unknown;
            fromPartial<I_5 extends Partial<_83.BlockID> & {
                hash?: Uint8Array;
                partSetHeader?: _83.PartSetHeader & {
                    total: number;
                    hash: Uint8Array;
                } & Record<Exclude<keyof I_5["partSetHeader"], keyof _83.PartSetHeader>, never>;
            } & Record<Exclude<keyof I_5, keyof _83.BlockID>, never>>(object: I_5): _83.BlockID;
        };
        Header: {
            typeUrl: string;
            encode(message: _83.Header, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.Header;
            fromJSON(object: any): _83.Header;
            toJSON(message: _83.Header): unknown;
            fromPartial<I_6 extends Partial<_83.Header> & {
                version?: _85.Consensus & {
                    block: bigint;
                    app: bigint;
                } & Record<Exclude<keyof I_6["version"], keyof _85.Consensus>, never>;
                chainId?: string;
                height?: bigint;
                time?: import("../google/protobuf/timestamp").Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_6["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                lastBlockId?: _83.BlockID & {
                    hash: Uint8Array;
                    partSetHeader: _83.PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I_6["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                } & Record<Exclude<keyof I_6["lastBlockId"], keyof _83.BlockID>, never>;
                lastCommitHash?: Uint8Array;
                dataHash?: Uint8Array;
                validatorsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                consensusHash?: Uint8Array;
                appHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                proposerAddress?: Uint8Array;
            } & Record<Exclude<keyof I_6, keyof _83.Header>, never>>(object: I_6): _83.Header;
        };
        Data: {
            typeUrl: string;
            encode(message: _83.Data, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.Data;
            fromJSON(object: any): _83.Data;
            toJSON(message: _83.Data): unknown;
            fromPartial<I_7 extends Partial<_83.Data> & {
                txs?: Uint8Array[] & Record<Exclude<keyof I_7["txs"], keyof Uint8Array[]>, never>;
            } & Record<Exclude<keyof I_7, "txs">, never>>(object: I_7): _83.Data;
        };
        Vote: {
            typeUrl: string;
            encode(message: _83.Vote, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.Vote;
            fromJSON(object: any): _83.Vote;
            toJSON(message: _83.Vote): unknown;
            fromPartial<I_8 extends Partial<_83.Vote> & {
                type?: _83.SignedMsgType;
                height?: bigint;
                round?: number;
                blockId?: _83.BlockID & {
                    hash: Uint8Array;
                    partSetHeader: _83.PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I_8["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                } & Record<Exclude<keyof I_8["blockId"], keyof _83.BlockID>, never>;
                timestamp?: import("../google/protobuf/timestamp").Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_8["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                validatorAddress?: Uint8Array;
                validatorIndex?: number;
                signature?: Uint8Array;
            } & Record<Exclude<keyof I_8, keyof _83.Vote>, never>>(object: I_8): _83.Vote;
        };
        Commit: {
            typeUrl: string;
            encode(message: _83.Commit, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.Commit;
            fromJSON(object: any): _83.Commit;
            toJSON(message: _83.Commit): unknown;
            fromPartial<I_9 extends Partial<_83.Commit> & {
                height?: bigint;
                round?: number;
                blockId?: _83.BlockID & {
                    hash: Uint8Array;
                    partSetHeader: _83.PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I_9["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                } & Record<Exclude<keyof I_9["blockId"], keyof _83.BlockID>, never>;
                signatures?: _83.CommitSig[] & (_83.CommitSig & {
                    blockIdFlag: _83.BlockIDFlag;
                    validatorAddress: Uint8Array;
                    timestamp: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_9["signatures"][number]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    signature: Uint8Array;
                } & Record<Exclude<keyof I_9["signatures"][number], keyof _83.CommitSig>, never>)[] & Record<Exclude<keyof I_9["signatures"], keyof _83.CommitSig[]>, never>;
            } & Record<Exclude<keyof I_9, keyof _83.Commit>, never>>(object: I_9): _83.Commit;
        };
        CommitSig: {
            typeUrl: string;
            encode(message: _83.CommitSig, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.CommitSig;
            fromJSON(object: any): _83.CommitSig;
            toJSON(message: _83.CommitSig): unknown;
            fromPartial<I_10 extends Partial<_83.CommitSig> & {
                blockIdFlag?: _83.BlockIDFlag;
                validatorAddress?: Uint8Array;
                timestamp?: import("../google/protobuf/timestamp").Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_10["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                signature?: Uint8Array;
            } & Record<Exclude<keyof I_10, keyof _83.CommitSig>, never>>(object: I_10): _83.CommitSig;
        };
        Proposal: {
            typeUrl: string;
            encode(message: _83.Proposal, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.Proposal;
            fromJSON(object: any): _83.Proposal;
            toJSON(message: _83.Proposal): unknown;
            fromPartial<I_11 extends Partial<_83.Proposal> & {
                type?: _83.SignedMsgType;
                height?: bigint;
                round?: number;
                polRound?: number;
                blockId?: _83.BlockID & {
                    hash: Uint8Array;
                    partSetHeader: _83.PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I_11["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                } & Record<Exclude<keyof I_11["blockId"], keyof _83.BlockID>, never>;
                timestamp?: import("../google/protobuf/timestamp").Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_11["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                signature?: Uint8Array;
            } & Record<Exclude<keyof I_11, keyof _83.Proposal>, never>>(object: I_11): _83.Proposal;
        };
        SignedHeader: {
            typeUrl: string;
            encode(message: _83.SignedHeader, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.SignedHeader;
            fromJSON(object: any): _83.SignedHeader;
            toJSON(message: _83.SignedHeader): unknown;
            fromPartial<I_12 extends Partial<_83.SignedHeader> & {
                header?: _83.Header & {
                    version: _85.Consensus & {
                        block: bigint;
                        app: bigint;
                    } & Record<Exclude<keyof I_12["header"]["version"], keyof _85.Consensus>, never>;
                    chainId: string;
                    height: bigint;
                    time: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_12["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    lastBlockId: _83.BlockID & {
                        hash: Uint8Array;
                        partSetHeader: _83.PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I_12["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                    } & Record<Exclude<keyof I_12["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                    lastCommitHash: Uint8Array;
                    dataHash: Uint8Array;
                    validatorsHash: Uint8Array;
                    nextValidatorsHash: Uint8Array;
                    consensusHash: Uint8Array;
                    appHash: Uint8Array;
                    lastResultsHash: Uint8Array;
                    evidenceHash: Uint8Array;
                    proposerAddress: Uint8Array;
                } & Record<Exclude<keyof I_12["header"], keyof _83.Header>, never>;
                commit?: _83.Commit & {
                    height: bigint;
                    round: number;
                    blockId: _83.BlockID & {
                        hash: Uint8Array;
                        partSetHeader: _83.PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I_12["commit"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                    } & Record<Exclude<keyof I_12["commit"]["blockId"], keyof _83.BlockID>, never>;
                    signatures: _83.CommitSig[] & (_83.CommitSig & {
                        blockIdFlag: _83.BlockIDFlag;
                        validatorAddress: Uint8Array;
                        timestamp: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_12["commit"]["signatures"][number]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        signature: Uint8Array;
                    } & Record<Exclude<keyof I_12["commit"]["signatures"][number], keyof _83.CommitSig>, never>)[] & Record<Exclude<keyof I_12["commit"]["signatures"], keyof _83.CommitSig[]>, never>;
                } & Record<Exclude<keyof I_12["commit"], keyof _83.Commit>, never>;
            } & Record<Exclude<keyof I_12, keyof _83.SignedHeader>, never>>(object: I_12): _83.SignedHeader;
        };
        LightBlock: {
            typeUrl: string;
            encode(message: _83.LightBlock, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.LightBlock;
            fromJSON(object: any): _83.LightBlock;
            toJSON(message: _83.LightBlock): unknown;
            fromPartial<I_13 extends Partial<_83.LightBlock> & {
                signedHeader?: _83.SignedHeader & {
                    header?: _83.Header & {
                        version: _85.Consensus & {
                            block: bigint;
                            app: bigint;
                        } & Record<Exclude<keyof I_13["signedHeader"]["header"]["version"], keyof _85.Consensus>, never>;
                        chainId: string;
                        height: bigint;
                        time: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_13["signedHeader"]["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        lastBlockId: _83.BlockID & {
                            hash: Uint8Array;
                            partSetHeader: _83.PartSetHeader & {
                                total: number;
                                hash: Uint8Array;
                            } & Record<Exclude<keyof I_13["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                        } & Record<Exclude<keyof I_13["signedHeader"]["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                        lastCommitHash: Uint8Array;
                        dataHash: Uint8Array;
                        validatorsHash: Uint8Array;
                        nextValidatorsHash: Uint8Array;
                        consensusHash: Uint8Array;
                        appHash: Uint8Array;
                        lastResultsHash: Uint8Array;
                        evidenceHash: Uint8Array;
                        proposerAddress: Uint8Array;
                    } & Record<Exclude<keyof I_13["signedHeader"]["header"], keyof _83.Header>, never>;
                    commit?: _83.Commit & {
                        height: bigint;
                        round: number;
                        blockId: _83.BlockID & {
                            hash: Uint8Array;
                            partSetHeader: _83.PartSetHeader & {
                                total: number;
                                hash: Uint8Array;
                            } & Record<Exclude<keyof I_13["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                        } & Record<Exclude<keyof I_13["signedHeader"]["commit"]["blockId"], keyof _83.BlockID>, never>;
                        signatures: _83.CommitSig[] & (_83.CommitSig & {
                            blockIdFlag: _83.BlockIDFlag;
                            validatorAddress: Uint8Array;
                            timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I_13["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                            signature: Uint8Array;
                        } & Record<Exclude<keyof I_13["signedHeader"]["commit"]["signatures"][number], keyof _83.CommitSig>, never>)[] & Record<Exclude<keyof I_13["signedHeader"]["commit"]["signatures"], keyof _83.CommitSig[]>, never>;
                    } & Record<Exclude<keyof I_13["signedHeader"]["commit"], keyof _83.Commit>, never>;
                } & Record<Exclude<keyof I_13["signedHeader"], keyof _83.SignedHeader>, never>;
                validatorSet?: _84.ValidatorSet & {
                    validators: _84.Validator[] & (_84.Validator & {
                        address: Uint8Array;
                        pubKey: _77.PublicKey & {
                            ed25519?: Uint8Array;
                            secp256k1?: Uint8Array;
                        } & Record<Exclude<keyof I_13["validatorSet"]["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                        votingPower: bigint;
                        proposerPriority: bigint;
                    } & Record<Exclude<keyof I_13["validatorSet"]["validators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_13["validatorSet"]["validators"], keyof _84.Validator[]>, never>;
                    proposer?: _84.Validator & {
                        address: Uint8Array;
                        pubKey: _77.PublicKey & {
                            ed25519?: Uint8Array;
                            secp256k1?: Uint8Array;
                        } & Record<Exclude<keyof I_13["validatorSet"]["proposer"]["pubKey"], keyof _77.PublicKey>, never>;
                        votingPower: bigint;
                        proposerPriority: bigint;
                    } & Record<Exclude<keyof I_13["validatorSet"]["proposer"], keyof _84.Validator>, never>;
                    totalVotingPower: bigint;
                } & Record<Exclude<keyof I_13["validatorSet"], keyof _84.ValidatorSet>, never>;
            } & Record<Exclude<keyof I_13, keyof _83.LightBlock>, never>>(object: I_13): _83.LightBlock;
        };
        BlockMeta: {
            typeUrl: string;
            encode(message: _83.BlockMeta, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.BlockMeta;
            fromJSON(object: any): _83.BlockMeta;
            toJSON(message: _83.BlockMeta): unknown;
            fromPartial<I_14 extends Partial<_83.BlockMeta> & {
                blockId?: _83.BlockID & {
                    hash: Uint8Array;
                    partSetHeader: _83.PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I_14["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                } & Record<Exclude<keyof I_14["blockId"], keyof _83.BlockID>, never>;
                blockSize?: bigint;
                header?: _83.Header & {
                    version: _85.Consensus & {
                        block: bigint;
                        app: bigint;
                    } & Record<Exclude<keyof I_14["header"]["version"], keyof _85.Consensus>, never>;
                    chainId: string;
                    height: bigint;
                    time: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_14["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    lastBlockId: _83.BlockID & {
                        hash: Uint8Array;
                        partSetHeader: _83.PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I_14["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                    } & Record<Exclude<keyof I_14["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                    lastCommitHash: Uint8Array;
                    dataHash: Uint8Array;
                    validatorsHash: Uint8Array;
                    nextValidatorsHash: Uint8Array;
                    consensusHash: Uint8Array;
                    appHash: Uint8Array;
                    lastResultsHash: Uint8Array;
                    evidenceHash: Uint8Array;
                    proposerAddress: Uint8Array;
                } & Record<Exclude<keyof I_14["header"], keyof _83.Header>, never>;
                numTxs?: bigint;
            } & Record<Exclude<keyof I_14, keyof _83.BlockMeta>, never>>(object: I_14): _83.BlockMeta;
        };
        TxProof: {
            typeUrl: string;
            encode(message: _83.TxProof, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _83.TxProof;
            fromJSON(object: any): _83.TxProof;
            toJSON(message: _83.TxProof): unknown;
            fromPartial<I_15 extends Partial<_83.TxProof> & {
                rootHash?: Uint8Array;
                data?: Uint8Array;
                proof?: _78.Proof & {
                    total: bigint;
                    index: bigint;
                    leafHash: Uint8Array;
                    aunts: Uint8Array[] & Record<Exclude<keyof I_15["proof"]["aunts"], keyof Uint8Array[]>, never>;
                } & Record<Exclude<keyof I_15["proof"], keyof _78.Proof>, never>;
            } & Record<Exclude<keyof I_15, keyof _83.TxProof>, never>>(object: I_15): _83.TxProof;
        };
        ConsensusParams: {
            typeUrl: string;
            encode(message: _82.ConsensusParams, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _82.ConsensusParams;
            fromJSON(object: any): _82.ConsensusParams;
            toJSON(message: _82.ConsensusParams): unknown;
            fromPartial<I_16 extends Partial<_82.ConsensusParams> & {
                block?: _82.BlockParams & {
                    maxBytes: bigint;
                    maxGas: bigint;
                    timeIotaMs: bigint;
                } & Record<Exclude<keyof I_16["block"], keyof _82.BlockParams>, never>;
                evidence?: _82.EvidenceParams & {
                    maxAgeNumBlocks: bigint;
                    maxAgeDuration: import("../google/protobuf/duration").Duration & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_16["evidence"]["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                    maxBytes: bigint;
                } & Record<Exclude<keyof I_16["evidence"], keyof _82.EvidenceParams>, never>;
                validator?: _82.ValidatorParams & {
                    pubKeyTypes: string[] & Record<Exclude<keyof I_16["validator"]["pubKeyTypes"], keyof string[]>, never>;
                } & Record<Exclude<keyof I_16["validator"], "pubKeyTypes">, never>;
                version?: _82.VersionParams & {
                    appVersion: bigint;
                } & Record<Exclude<keyof I_16["version"], "appVersion">, never>;
            } & Record<Exclude<keyof I_16, keyof _82.ConsensusParams>, never>>(object: I_16): _82.ConsensusParams;
        };
        BlockParams: {
            typeUrl: string;
            encode(message: _82.BlockParams, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _82.BlockParams;
            fromJSON(object: any): _82.BlockParams;
            toJSON(message: _82.BlockParams): unknown;
            fromPartial<I_17 extends Partial<_82.BlockParams> & {
                maxBytes?: bigint;
                maxGas?: bigint;
                timeIotaMs?: bigint;
            } & Record<Exclude<keyof I_17, keyof _82.BlockParams>, never>>(object: I_17): _82.BlockParams;
        };
        EvidenceParams: {
            typeUrl: string;
            encode(message: _82.EvidenceParams, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _82.EvidenceParams;
            fromJSON(object: any): _82.EvidenceParams;
            toJSON(message: _82.EvidenceParams): unknown;
            fromPartial<I_18 extends Partial<_82.EvidenceParams> & {
                maxAgeNumBlocks?: bigint;
                maxAgeDuration?: import("../google/protobuf/duration").Duration & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_18["maxAgeDuration"], keyof import("../google/protobuf/duration").Duration>, never>;
                maxBytes?: bigint;
            } & Record<Exclude<keyof I_18, keyof _82.EvidenceParams>, never>>(object: I_18): _82.EvidenceParams;
        };
        ValidatorParams: {
            typeUrl: string;
            encode(message: _82.ValidatorParams, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _82.ValidatorParams;
            fromJSON(object: any): _82.ValidatorParams;
            toJSON(message: _82.ValidatorParams): unknown;
            fromPartial<I_19 extends Partial<_82.ValidatorParams> & {
                pubKeyTypes?: string[] & Record<Exclude<keyof I_19["pubKeyTypes"], keyof string[]>, never>;
            } & Record<Exclude<keyof I_19, "pubKeyTypes">, never>>(object: I_19): _82.ValidatorParams;
        };
        VersionParams: {
            typeUrl: string;
            encode(message: _82.VersionParams, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _82.VersionParams;
            fromJSON(object: any): _82.VersionParams;
            toJSON(message: _82.VersionParams): unknown;
            fromPartial<I_20 extends Partial<_82.VersionParams> & {
                appVersion?: bigint;
            } & Record<Exclude<keyof I_20, "appVersion">, never>>(object: I_20): _82.VersionParams;
        };
        HashedParams: {
            typeUrl: string;
            encode(message: _82.HashedParams, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _82.HashedParams;
            fromJSON(object: any): _82.HashedParams;
            toJSON(message: _82.HashedParams): unknown;
            fromPartial<I_21 extends Partial<_82.HashedParams> & {
                blockMaxBytes?: bigint;
                blockMaxGas?: bigint;
            } & Record<Exclude<keyof I_21, keyof _82.HashedParams>, never>>(object: I_21): _82.HashedParams;
        };
        Evidence: {
            typeUrl: string;
            encode(message: _81.Evidence, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _81.Evidence;
            fromJSON(object: any): _81.Evidence;
            toJSON(message: _81.Evidence): unknown;
            fromPartial<I_22 extends Partial<_81.Evidence> & {
                duplicateVoteEvidence?: _81.DuplicateVoteEvidence & {
                    voteA?: _83.Vote & {
                        type: _83.SignedMsgType;
                        height: bigint;
                        round: number;
                        blockId: _83.BlockID & {
                            hash: Uint8Array;
                            partSetHeader: _83.PartSetHeader & {
                                total: number;
                                hash: Uint8Array;
                            } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["voteA"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                        } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["voteA"]["blockId"], keyof _83.BlockID>, never>;
                        timestamp: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["voteA"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        validatorAddress: Uint8Array;
                        validatorIndex: number;
                        signature: Uint8Array;
                    } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["voteA"], keyof _83.Vote>, never>;
                    voteB?: _83.Vote & {
                        type: _83.SignedMsgType;
                        height: bigint;
                        round: number;
                        blockId: _83.BlockID & {
                            hash: Uint8Array;
                            partSetHeader: _83.PartSetHeader & {
                                total: number;
                                hash: Uint8Array;
                            } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["voteB"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                        } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["voteB"]["blockId"], keyof _83.BlockID>, never>;
                        timestamp: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["voteB"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        validatorAddress: Uint8Array;
                        validatorIndex: number;
                        signature: Uint8Array;
                    } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["voteB"], keyof _83.Vote>, never>;
                    totalVotingPower: bigint;
                    validatorPower: bigint;
                    timestamp: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_22["duplicateVoteEvidence"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                } & Record<Exclude<keyof I_22["duplicateVoteEvidence"], keyof _81.DuplicateVoteEvidence>, never>;
                lightClientAttackEvidence?: _81.LightClientAttackEvidence & {
                    conflictingBlock?: _83.LightBlock & {
                        signedHeader?: _83.SignedHeader & {
                            header?: _83.Header & {
                                version: _85.Consensus & {
                                    block: bigint;
                                    app: bigint;
                                } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["version"], keyof _85.Consensus>, never>;
                                chainId: string;
                                height: bigint;
                                time: import("../google/protobuf/timestamp").Timestamp & {
                                    seconds: bigint;
                                    nanos: number;
                                } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                lastBlockId: _83.BlockID & {
                                    hash: Uint8Array;
                                    partSetHeader: _83.PartSetHeader & {
                                        total: number;
                                        hash: Uint8Array;
                                    } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                                } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                                lastCommitHash: Uint8Array;
                                dataHash: Uint8Array;
                                validatorsHash: Uint8Array;
                                nextValidatorsHash: Uint8Array;
                                consensusHash: Uint8Array;
                                appHash: Uint8Array;
                                lastResultsHash: Uint8Array;
                                evidenceHash: Uint8Array;
                                proposerAddress: Uint8Array;
                            } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"], keyof _83.Header>, never>;
                            commit?: _83.Commit & {
                                height: bigint;
                                round: number;
                                blockId: _83.BlockID & {
                                    hash: Uint8Array;
                                    partSetHeader: _83.PartSetHeader & {
                                        total: number;
                                        hash: Uint8Array;
                                    } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                                } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"], keyof _83.BlockID>, never>;
                                signatures: _83.CommitSig[] & (_83.CommitSig & {
                                    blockIdFlag: _83.BlockIDFlag;
                                    validatorAddress: Uint8Array;
                                    timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                        seconds: bigint;
                                        nanos: number;
                                    } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                    signature: Uint8Array;
                                } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number], keyof _83.CommitSig>, never>)[] & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"], keyof _83.CommitSig[]>, never>;
                            } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"], keyof _83.Commit>, never>;
                        } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"], keyof _83.SignedHeader>, never>;
                        validatorSet?: _84.ValidatorSet & {
                            validators: _84.Validator[] & (_84.Validator & {
                                address: Uint8Array;
                                pubKey: _77.PublicKey & {
                                    ed25519?: Uint8Array;
                                    secp256k1?: Uint8Array;
                                } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                                votingPower: bigint;
                                proposerPriority: bigint;
                            } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"], keyof _84.Validator[]>, never>;
                            proposer?: _84.Validator & {
                                address: Uint8Array;
                                pubKey: _77.PublicKey & {
                                    ed25519?: Uint8Array;
                                    secp256k1?: Uint8Array;
                                } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"]["pubKey"], keyof _77.PublicKey>, never>;
                                votingPower: bigint;
                                proposerPriority: bigint;
                            } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"], keyof _84.Validator>, never>;
                            totalVotingPower: bigint;
                        } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"], keyof _84.ValidatorSet>, never>;
                    } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["conflictingBlock"], keyof _83.LightBlock>, never>;
                    commonHeight: bigint;
                    byzantineValidators: _84.Validator[] & (_84.Validator & {
                        address: Uint8Array;
                        pubKey: _77.PublicKey & {
                            ed25519?: Uint8Array;
                            secp256k1?: Uint8Array;
                        } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["byzantineValidators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                        votingPower: bigint;
                        proposerPriority: bigint;
                    } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["byzantineValidators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["byzantineValidators"], keyof _84.Validator[]>, never>;
                    totalVotingPower: bigint;
                    timestamp: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_22["lightClientAttackEvidence"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                } & Record<Exclude<keyof I_22["lightClientAttackEvidence"], keyof _81.LightClientAttackEvidence>, never>;
            } & Record<Exclude<keyof I_22, keyof _81.Evidence>, never>>(object: I_22): _81.Evidence;
        };
        DuplicateVoteEvidence: {
            typeUrl: string;
            encode(message: _81.DuplicateVoteEvidence, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _81.DuplicateVoteEvidence;
            fromJSON(object: any): _81.DuplicateVoteEvidence;
            toJSON(message: _81.DuplicateVoteEvidence): unknown;
            fromPartial<I_23 extends Partial<_81.DuplicateVoteEvidence> & {
                voteA?: _83.Vote & {
                    type: _83.SignedMsgType;
                    height: bigint;
                    round: number;
                    blockId: _83.BlockID & {
                        hash: Uint8Array;
                        partSetHeader: _83.PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I_23["voteA"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                    } & Record<Exclude<keyof I_23["voteA"]["blockId"], keyof _83.BlockID>, never>;
                    timestamp: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_23["voteA"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    validatorAddress: Uint8Array;
                    validatorIndex: number;
                    signature: Uint8Array;
                } & Record<Exclude<keyof I_23["voteA"], keyof _83.Vote>, never>;
                voteB?: _83.Vote & {
                    type: _83.SignedMsgType;
                    height: bigint;
                    round: number;
                    blockId: _83.BlockID & {
                        hash: Uint8Array;
                        partSetHeader: _83.PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I_23["voteB"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                    } & Record<Exclude<keyof I_23["voteB"]["blockId"], keyof _83.BlockID>, never>;
                    timestamp: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_23["voteB"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    validatorAddress: Uint8Array;
                    validatorIndex: number;
                    signature: Uint8Array;
                } & Record<Exclude<keyof I_23["voteB"], keyof _83.Vote>, never>;
                totalVotingPower?: bigint;
                validatorPower?: bigint;
                timestamp?: import("../google/protobuf/timestamp").Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_23["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
            } & Record<Exclude<keyof I_23, keyof _81.DuplicateVoteEvidence>, never>>(object: I_23): _81.DuplicateVoteEvidence;
        };
        LightClientAttackEvidence: {
            typeUrl: string;
            encode(message: _81.LightClientAttackEvidence, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _81.LightClientAttackEvidence;
            fromJSON(object: any): _81.LightClientAttackEvidence;
            toJSON(message: _81.LightClientAttackEvidence): unknown;
            fromPartial<I_24 extends Partial<_81.LightClientAttackEvidence> & {
                conflictingBlock?: _83.LightBlock & {
                    signedHeader?: _83.SignedHeader & {
                        header?: _83.Header & {
                            version: _85.Consensus & {
                                block: bigint;
                                app: bigint;
                            } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["header"]["version"], keyof _85.Consensus>, never>;
                            chainId: string;
                            height: bigint;
                            time: import("../google/protobuf/timestamp").Timestamp & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                            lastBlockId: _83.BlockID & {
                                hash: Uint8Array;
                                partSetHeader: _83.PartSetHeader & {
                                    total: number;
                                    hash: Uint8Array;
                                } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                            } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                            lastCommitHash: Uint8Array;
                            dataHash: Uint8Array;
                            validatorsHash: Uint8Array;
                            nextValidatorsHash: Uint8Array;
                            consensusHash: Uint8Array;
                            appHash: Uint8Array;
                            lastResultsHash: Uint8Array;
                            evidenceHash: Uint8Array;
                            proposerAddress: Uint8Array;
                        } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["header"], keyof _83.Header>, never>;
                        commit?: _83.Commit & {
                            height: bigint;
                            round: number;
                            blockId: _83.BlockID & {
                                hash: Uint8Array;
                                partSetHeader: _83.PartSetHeader & {
                                    total: number;
                                    hash: Uint8Array;
                                } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                            } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["commit"]["blockId"], keyof _83.BlockID>, never>;
                            signatures: _83.CommitSig[] & (_83.CommitSig & {
                                blockIdFlag: _83.BlockIDFlag;
                                validatorAddress: Uint8Array;
                                timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                    seconds: bigint;
                                    nanos: number;
                                } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                signature: Uint8Array;
                            } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number], keyof _83.CommitSig>, never>)[] & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["commit"]["signatures"], keyof _83.CommitSig[]>, never>;
                        } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"]["commit"], keyof _83.Commit>, never>;
                    } & Record<Exclude<keyof I_24["conflictingBlock"]["signedHeader"], keyof _83.SignedHeader>, never>;
                    validatorSet?: _84.ValidatorSet & {
                        validators: _84.Validator[] & (_84.Validator & {
                            address: Uint8Array;
                            pubKey: _77.PublicKey & {
                                ed25519?: Uint8Array;
                                secp256k1?: Uint8Array;
                            } & Record<Exclude<keyof I_24["conflictingBlock"]["validatorSet"]["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                            votingPower: bigint;
                            proposerPriority: bigint;
                        } & Record<Exclude<keyof I_24["conflictingBlock"]["validatorSet"]["validators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_24["conflictingBlock"]["validatorSet"]["validators"], keyof _84.Validator[]>, never>;
                        proposer?: _84.Validator & {
                            address: Uint8Array;
                            pubKey: _77.PublicKey & {
                                ed25519?: Uint8Array;
                                secp256k1?: Uint8Array;
                            } & Record<Exclude<keyof I_24["conflictingBlock"]["validatorSet"]["proposer"]["pubKey"], keyof _77.PublicKey>, never>;
                            votingPower: bigint;
                            proposerPriority: bigint;
                        } & Record<Exclude<keyof I_24["conflictingBlock"]["validatorSet"]["proposer"], keyof _84.Validator>, never>;
                        totalVotingPower: bigint;
                    } & Record<Exclude<keyof I_24["conflictingBlock"]["validatorSet"], keyof _84.ValidatorSet>, never>;
                } & Record<Exclude<keyof I_24["conflictingBlock"], keyof _83.LightBlock>, never>;
                commonHeight?: bigint;
                byzantineValidators?: _84.Validator[] & (_84.Validator & {
                    address: Uint8Array;
                    pubKey: _77.PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I_24["byzantineValidators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                    votingPower: bigint;
                    proposerPriority: bigint;
                } & Record<Exclude<keyof I_24["byzantineValidators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_24["byzantineValidators"], keyof _84.Validator[]>, never>;
                totalVotingPower?: bigint;
                timestamp?: import("../google/protobuf/timestamp").Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I_24["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
            } & Record<Exclude<keyof I_24, keyof _81.LightClientAttackEvidence>, never>>(object: I_24): _81.LightClientAttackEvidence;
        };
        EvidenceList: {
            typeUrl: string;
            encode(message: _81.EvidenceList, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _81.EvidenceList;
            fromJSON(object: any): _81.EvidenceList;
            toJSON(message: _81.EvidenceList): unknown;
            fromPartial<I_25 extends Partial<_81.EvidenceList> & {
                evidence?: _81.Evidence[] & (_81.Evidence & {
                    duplicateVoteEvidence?: _81.DuplicateVoteEvidence & {
                        voteA?: _83.Vote & {
                            type: _83.SignedMsgType;
                            height: bigint;
                            round: number;
                            blockId: _83.BlockID & {
                                hash: Uint8Array;
                                partSetHeader: _83.PartSetHeader & {
                                    total: number;
                                    hash: Uint8Array;
                                } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["voteA"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                            } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["voteA"]["blockId"], keyof _83.BlockID>, never>;
                            timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["voteA"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                            validatorAddress: Uint8Array;
                            validatorIndex: number;
                            signature: Uint8Array;
                        } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["voteA"], keyof _83.Vote>, never>;
                        voteB?: _83.Vote & {
                            type: _83.SignedMsgType;
                            height: bigint;
                            round: number;
                            blockId: _83.BlockID & {
                                hash: Uint8Array;
                                partSetHeader: _83.PartSetHeader & {
                                    total: number;
                                    hash: Uint8Array;
                                } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["voteB"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                            } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["voteB"]["blockId"], keyof _83.BlockID>, never>;
                            timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["voteB"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                            validatorAddress: Uint8Array;
                            validatorIndex: number;
                            signature: Uint8Array;
                        } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["voteB"], keyof _83.Vote>, never>;
                        totalVotingPower: bigint;
                        validatorPower: bigint;
                        timestamp: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    } & Record<Exclude<keyof I_25["evidence"][number]["duplicateVoteEvidence"], keyof _81.DuplicateVoteEvidence>, never>;
                    lightClientAttackEvidence?: _81.LightClientAttackEvidence & {
                        conflictingBlock?: _83.LightBlock & {
                            signedHeader?: _83.SignedHeader & {
                                header?: _83.Header & {
                                    version: _85.Consensus & {
                                        block: bigint;
                                        app: bigint;
                                    } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["version"], keyof _85.Consensus>, never>;
                                    chainId: string;
                                    height: bigint;
                                    time: import("../google/protobuf/timestamp").Timestamp & {
                                        seconds: bigint;
                                        nanos: number;
                                    } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                    lastBlockId: _83.BlockID & {
                                        hash: Uint8Array;
                                        partSetHeader: _83.PartSetHeader & {
                                            total: number;
                                            hash: Uint8Array;
                                        } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                                    } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                                    lastCommitHash: Uint8Array;
                                    dataHash: Uint8Array;
                                    validatorsHash: Uint8Array;
                                    nextValidatorsHash: Uint8Array;
                                    consensusHash: Uint8Array;
                                    appHash: Uint8Array;
                                    lastResultsHash: Uint8Array;
                                    evidenceHash: Uint8Array;
                                    proposerAddress: Uint8Array;
                                } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"], keyof _83.Header>, never>;
                                commit?: _83.Commit & {
                                    height: bigint;
                                    round: number;
                                    blockId: _83.BlockID & {
                                        hash: Uint8Array;
                                        partSetHeader: _83.PartSetHeader & {
                                            total: number;
                                            hash: Uint8Array;
                                        } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                                    } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"], keyof _83.BlockID>, never>;
                                    signatures: _83.CommitSig[] & (_83.CommitSig & {
                                        blockIdFlag: _83.BlockIDFlag;
                                        validatorAddress: Uint8Array;
                                        timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                            seconds: bigint;
                                            nanos: number;
                                        } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                        signature: Uint8Array;
                                    } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number], keyof _83.CommitSig>, never>)[] & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"], keyof _83.CommitSig[]>, never>;
                                } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"], keyof _83.Commit>, never>;
                            } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"], keyof _83.SignedHeader>, never>;
                            validatorSet?: _84.ValidatorSet & {
                                validators: _84.Validator[] & (_84.Validator & {
                                    address: Uint8Array;
                                    pubKey: _77.PublicKey & {
                                        ed25519?: Uint8Array;
                                        secp256k1?: Uint8Array;
                                    } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                                    votingPower: bigint;
                                    proposerPriority: bigint;
                                } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"], keyof _84.Validator[]>, never>;
                                proposer?: _84.Validator & {
                                    address: Uint8Array;
                                    pubKey: _77.PublicKey & {
                                        ed25519?: Uint8Array;
                                        secp256k1?: Uint8Array;
                                    } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"]["pubKey"], keyof _77.PublicKey>, never>;
                                    votingPower: bigint;
                                    proposerPriority: bigint;
                                } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"], keyof _84.Validator>, never>;
                                totalVotingPower: bigint;
                            } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"], keyof _84.ValidatorSet>, never>;
                        } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"], keyof _83.LightBlock>, never>;
                        commonHeight: bigint;
                        byzantineValidators: _84.Validator[] & (_84.Validator & {
                            address: Uint8Array;
                            pubKey: _77.PublicKey & {
                                ed25519?: Uint8Array;
                                secp256k1?: Uint8Array;
                            } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                            votingPower: bigint;
                            proposerPriority: bigint;
                        } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"], keyof _84.Validator[]>, never>;
                        totalVotingPower: bigint;
                        timestamp: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    } & Record<Exclude<keyof I_25["evidence"][number]["lightClientAttackEvidence"], keyof _81.LightClientAttackEvidence>, never>;
                } & Record<Exclude<keyof I_25["evidence"][number], keyof _81.Evidence>, never>)[] & Record<Exclude<keyof I_25["evidence"], keyof _81.Evidence[]>, never>;
            } & Record<Exclude<keyof I_25, "evidence">, never>>(object: I_25): _81.EvidenceList;
        };
        Block: {
            typeUrl: string;
            encode(message: _80.Block, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _80.Block;
            fromJSON(object: any): _80.Block;
            toJSON(message: _80.Block): unknown;
            fromPartial<I_26 extends Partial<_80.Block> & {
                header?: _83.Header & {
                    version: _85.Consensus & {
                        block: bigint;
                        app: bigint;
                    } & Record<Exclude<keyof I_26["header"]["version"], keyof _85.Consensus>, never>;
                    chainId: string;
                    height: bigint;
                    time: import("../google/protobuf/timestamp").Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I_26["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                    lastBlockId: _83.BlockID & {
                        hash: Uint8Array;
                        partSetHeader: _83.PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I_26["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                    } & Record<Exclude<keyof I_26["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                    lastCommitHash: Uint8Array;
                    dataHash: Uint8Array;
                    validatorsHash: Uint8Array;
                    nextValidatorsHash: Uint8Array;
                    consensusHash: Uint8Array;
                    appHash: Uint8Array;
                    lastResultsHash: Uint8Array;
                    evidenceHash: Uint8Array;
                    proposerAddress: Uint8Array;
                } & Record<Exclude<keyof I_26["header"], keyof _83.Header>, never>;
                data?: _83.Data & {
                    txs: Uint8Array[] & Record<Exclude<keyof I_26["data"]["txs"], keyof Uint8Array[]>, never>;
                } & Record<Exclude<keyof I_26["data"], "txs">, never>;
                evidence?: _81.EvidenceList & {
                    evidence: _81.Evidence[] & (_81.Evidence & {
                        duplicateVoteEvidence?: _81.DuplicateVoteEvidence & {
                            voteA?: _83.Vote & {
                                type: _83.SignedMsgType;
                                height: bigint;
                                round: number;
                                blockId: _83.BlockID & {
                                    hash: Uint8Array;
                                    partSetHeader: _83.PartSetHeader & {
                                        total: number;
                                        hash: Uint8Array;
                                    } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["voteA"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                                } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["voteA"]["blockId"], keyof _83.BlockID>, never>;
                                timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                    seconds: bigint;
                                    nanos: number;
                                } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["voteA"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                validatorAddress: Uint8Array;
                                validatorIndex: number;
                                signature: Uint8Array;
                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["voteA"], keyof _83.Vote>, never>;
                            voteB?: _83.Vote & {
                                type: _83.SignedMsgType;
                                height: bigint;
                                round: number;
                                blockId: _83.BlockID & {
                                    hash: Uint8Array;
                                    partSetHeader: _83.PartSetHeader & {
                                        total: number;
                                        hash: Uint8Array;
                                    } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["voteB"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                                } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["voteB"]["blockId"], keyof _83.BlockID>, never>;
                                timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                    seconds: bigint;
                                    nanos: number;
                                } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["voteB"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                validatorAddress: Uint8Array;
                                validatorIndex: number;
                                signature: Uint8Array;
                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["voteB"], keyof _83.Vote>, never>;
                            totalVotingPower: bigint;
                            validatorPower: bigint;
                            timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["duplicateVoteEvidence"], keyof _81.DuplicateVoteEvidence>, never>;
                        lightClientAttackEvidence?: _81.LightClientAttackEvidence & {
                            conflictingBlock?: _83.LightBlock & {
                                signedHeader?: _83.SignedHeader & {
                                    header?: _83.Header & {
                                        version: _85.Consensus & {
                                            block: bigint;
                                            app: bigint;
                                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["version"], keyof _85.Consensus>, never>;
                                        chainId: string;
                                        height: bigint;
                                        time: import("../google/protobuf/timestamp").Timestamp & {
                                            seconds: bigint;
                                            nanos: number;
                                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["time"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                        lastBlockId: _83.BlockID & {
                                            hash: Uint8Array;
                                            partSetHeader: _83.PartSetHeader & {
                                                total: number;
                                                hash: Uint8Array;
                                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"], keyof _83.BlockID>, never>;
                                        lastCommitHash: Uint8Array;
                                        dataHash: Uint8Array;
                                        validatorsHash: Uint8Array;
                                        nextValidatorsHash: Uint8Array;
                                        consensusHash: Uint8Array;
                                        appHash: Uint8Array;
                                        lastResultsHash: Uint8Array;
                                        evidenceHash: Uint8Array;
                                        proposerAddress: Uint8Array;
                                    } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"], keyof _83.Header>, never>;
                                    commit?: _83.Commit & {
                                        height: bigint;
                                        round: number;
                                        blockId: _83.BlockID & {
                                            hash: Uint8Array;
                                            partSetHeader: _83.PartSetHeader & {
                                                total: number;
                                                hash: Uint8Array;
                                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"], keyof _83.BlockID>, never>;
                                        signatures: _83.CommitSig[] & (_83.CommitSig & {
                                            blockIdFlag: _83.BlockIDFlag;
                                            validatorAddress: Uint8Array;
                                            timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                                seconds: bigint;
                                                nanos: number;
                                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                                            signature: Uint8Array;
                                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number], keyof _83.CommitSig>, never>)[] & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"], keyof _83.CommitSig[]>, never>;
                                    } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"], keyof _83.Commit>, never>;
                                } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"], keyof _83.SignedHeader>, never>;
                                validatorSet?: _84.ValidatorSet & {
                                    validators: _84.Validator[] & (_84.Validator & {
                                        address: Uint8Array;
                                        pubKey: _77.PublicKey & {
                                            ed25519?: Uint8Array;
                                            secp256k1?: Uint8Array;
                                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                                        votingPower: bigint;
                                        proposerPriority: bigint;
                                    } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"], keyof _84.Validator[]>, never>;
                                    proposer?: _84.Validator & {
                                        address: Uint8Array;
                                        pubKey: _77.PublicKey & {
                                            ed25519?: Uint8Array;
                                            secp256k1?: Uint8Array;
                                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"]["pubKey"], keyof _77.PublicKey>, never>;
                                        votingPower: bigint;
                                        proposerPriority: bigint;
                                    } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"], keyof _84.Validator>, never>;
                                    totalVotingPower: bigint;
                                } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"], keyof _84.ValidatorSet>, never>;
                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"], keyof _83.LightBlock>, never>;
                            commonHeight: bigint;
                            byzantineValidators: _84.Validator[] & (_84.Validator & {
                                address: Uint8Array;
                                pubKey: _77.PublicKey & {
                                    ed25519?: Uint8Array;
                                    secp256k1?: Uint8Array;
                                } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"][number]["pubKey"], keyof _77.PublicKey>, never>;
                                votingPower: bigint;
                                proposerPriority: bigint;
                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"][number], keyof _84.Validator>, never>)[] & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"], keyof _84.Validator[]>, never>;
                            totalVotingPower: bigint;
                            timestamp: import("../google/protobuf/timestamp").Timestamp & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        } & Record<Exclude<keyof I_26["evidence"]["evidence"][number]["lightClientAttackEvidence"], keyof _81.LightClientAttackEvidence>, never>;
                    } & Record<Exclude<keyof I_26["evidence"]["evidence"][number], keyof _81.Evidence>, never>)[] & Record<Exclude<keyof I_26["evidence"]["evidence"], keyof _81.Evidence[]>, never>;
                } & Record<Exclude<keyof I_26["evidence"], "evidence">, never>;
                lastCommit?: _83.Commit & {
                    height: bigint;
                    round: number;
                    blockId: _83.BlockID & {
                        hash: Uint8Array;
                        partSetHeader: _83.PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I_26["lastCommit"]["blockId"]["partSetHeader"], keyof _83.PartSetHeader>, never>;
                    } & Record<Exclude<keyof I_26["lastCommit"]["blockId"], keyof _83.BlockID>, never>;
                    signatures: _83.CommitSig[] & (_83.CommitSig & {
                        blockIdFlag: _83.BlockIDFlag;
                        validatorAddress: Uint8Array;
                        timestamp: import("../google/protobuf/timestamp").Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I_26["lastCommit"]["signatures"][number]["timestamp"], keyof import("../google/protobuf/timestamp").Timestamp>, never>;
                        signature: Uint8Array;
                    } & Record<Exclude<keyof I_26["lastCommit"]["signatures"][number], keyof _83.CommitSig>, never>)[] & Record<Exclude<keyof I_26["lastCommit"]["signatures"], keyof _83.CommitSig[]>, never>;
                } & Record<Exclude<keyof I_26["lastCommit"], keyof _83.Commit>, never>;
            } & Record<Exclude<keyof I_26, keyof _80.Block>, never>>(object: I_26): _80.Block;
        };
    };
    const version: {
        protobufPackage: "tendermint.version";
        App: {
            typeUrl: string;
            encode(message: _85.App, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _85.App;
            fromJSON(object: any): _85.App;
            toJSON(message: _85.App): unknown;
            fromPartial<I extends Partial<_85.App> & {
                protocol?: bigint;
                software?: string;
            } & Record<Exclude<keyof I, keyof _85.App>, never>>(object: I): _85.App;
        };
        Consensus: {
            typeUrl: string;
            encode(message: _85.Consensus, writer?: import("../binary").BinaryWriter): import("../binary").BinaryWriter;
            decode(input: Uint8Array | import("../binary").BinaryReader, length?: number): _85.Consensus;
            fromJSON(object: any): _85.Consensus;
            toJSON(message: _85.Consensus): unknown;
            fromPartial<I_1 extends Partial<_85.Consensus> & {
                block?: bigint;
                app?: bigint;
            } & Record<Exclude<keyof I_1, keyof _85.Consensus>, never>>(object: I_1): _85.Consensus;
        };
    };
    const ClientFactory: {
        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: {
                    node: {
                        v1beta1: import("../cosmos/base/node/v1beta1/query.lcd").LCDQueryClient;
                    };
                    reflection: {
                        v1beta1: import("../cosmos/base/reflection/v1beta1/reflection.lcd").LCDQueryClient;
                    };
                    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: {
                    v1beta1: import("../cosmos/gov/v1beta1/query.lcd").LCDQueryClient;
                };
                mint: {
                    v1beta1: import("../cosmos/mint/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;
                };
            };
        }>;
    };
}