juno-network 0.0.2

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

@@ -0,0 +1,2229 @@
+import * as _138 from "./abci/types";
+import * as _139 from "./crypto/keys";
+import * as _140 from "./crypto/proof";
+import * as _141 from "./libs/bits/types";
+import * as _142 from "./p2p/types";
+import * as _143 from "./types/block";
+import * as _144 from "./types/evidence";
+import * as _145 from "./types/params";
+import * as _146 from "./types/types";
+import * as _147 from "./types/validator";
+import * as _148 from "./version/types";
+export declare namespace tendermint {
+    const abci: {
+        checkTxTypeFromJSON(object: any): _138.CheckTxType;
+        checkTxTypeToJSON(object: _138.CheckTxType): string;
+        responseOfferSnapshot_ResultFromJSON(object: any): _138.ResponseOfferSnapshot_Result;
+        responseOfferSnapshot_ResultToJSON(object: _138.ResponseOfferSnapshot_Result): string;
+        responseApplySnapshotChunk_ResultFromJSON(object: any): _138.ResponseApplySnapshotChunk_Result;
+        responseApplySnapshotChunk_ResultToJSON(object: _138.ResponseApplySnapshotChunk_Result): string;
+        evidenceTypeFromJSON(object: any): _138.EvidenceType;
+        evidenceTypeToJSON(object: _138.EvidenceType): string;
+        CheckTxType: typeof _138.CheckTxType;
+        ResponseOfferSnapshot_Result: typeof _138.ResponseOfferSnapshot_Result;
+        ResponseApplySnapshotChunk_Result: typeof _138.ResponseApplySnapshotChunk_Result;
+        EvidenceType: typeof _138.EvidenceType;
+        Request: {
+            encode(message: _138.Request, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.Request;
+            fromJSON(object: any): _138.Request;
+            toJSON(message: _138.Request): unknown;
+            fromPartial(object: {
+                echo?: {
+                    message?: string;
+                };
+                flush?: {};
+                info?: {
+                    version?: string;
+                    blockVersion?: any;
+                    p2pVersion?: any;
+                };
+                setOption?: {
+                    key?: string;
+                    value?: string;
+                };
+                initChain?: {
+                    time?: Date;
+                    chainId?: string;
+                    consensusParams?: {
+                        block?: {
+                            maxBytes?: any;
+                            maxGas?: any;
+                        };
+                        evidence?: {
+                            maxAgeNumBlocks?: any;
+                            maxAgeDuration?: {
+                                seconds?: any;
+                                nanos?: number;
+                            };
+                            maxBytes?: any;
+                        };
+                        validator?: {
+                            pubKeyTypes?: string[];
+                        };
+                        version?: {
+                            appVersion?: any;
+                        };
+                    };
+                    validators?: {
+                        pubKey?: {
+                            ed25519?: Uint8Array;
+                            secp256k1?: Uint8Array;
+                        };
+                        power?: any;
+                    }[];
+                    appStateBytes?: Uint8Array;
+                    initialHeight?: any;
+                };
+                query?: {
+                    data?: Uint8Array;
+                    path?: string;
+                    height?: any;
+                    prove?: boolean;
+                };
+                beginBlock?: {
+                    hash?: Uint8Array;
+                    header?: {
+                        version?: {
+                            block?: any;
+                            app?: any;
+                        };
+                        chainId?: string;
+                        height?: any;
+                        time?: Date;
+                        lastBlockId?: {
+                            hash?: Uint8Array;
+                            partSetHeader?: {
+                                total?: number;
+                                hash?: Uint8Array;
+                            };
+                        };
+                        lastCommitHash?: Uint8Array;
+                        dataHash?: Uint8Array;
+                        validatorsHash?: Uint8Array;
+                        nextValidatorsHash?: Uint8Array;
+                        consensusHash?: Uint8Array;
+                        appHash?: Uint8Array;
+                        lastResultsHash?: Uint8Array;
+                        evidenceHash?: Uint8Array;
+                        proposerAddress?: Uint8Array;
+                    };
+                    lastCommitInfo?: {
+                        round?: number;
+                        votes?: {
+                            validator?: {
+                                address?: Uint8Array;
+                                power?: any;
+                            };
+                            signedLastBlock?: boolean;
+                        }[];
+                    };
+                    byzantineValidators?: {
+                        type?: _138.EvidenceType;
+                        validator?: {
+                            address?: Uint8Array;
+                            power?: any;
+                        };
+                        height?: any;
+                        time?: Date;
+                        totalVotingPower?: any;
+                    }[];
+                };
+                checkTx?: {
+                    tx?: Uint8Array;
+                    type?: _138.CheckTxType;
+                };
+                deliverTx?: {
+                    tx?: Uint8Array;
+                };
+                endBlock?: {
+                    height?: any;
+                };
+                commit?: {};
+                listSnapshots?: {};
+                offerSnapshot?: {
+                    snapshot?: {
+                        height?: any;
+                        format?: number;
+                        chunks?: number;
+                        hash?: Uint8Array;
+                        metadata?: Uint8Array;
+                    };
+                    appHash?: Uint8Array;
+                };
+                loadSnapshotChunk?: {
+                    height?: any;
+                    format?: number;
+                    chunk?: number;
+                };
+                applySnapshotChunk?: {
+                    index?: number;
+                    chunk?: Uint8Array;
+                    sender?: string;
+                };
+            }): _138.Request;
+        };
+        RequestEcho: {
+            encode(message: _138.RequestEcho, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestEcho;
+            fromJSON(object: any): _138.RequestEcho;
+            toJSON(message: _138.RequestEcho): unknown;
+            fromPartial(object: {
+                message?: string;
+            }): _138.RequestEcho;
+        };
+        RequestFlush: {
+            encode(_: _138.RequestFlush, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestFlush;
+            fromJSON(_: any): _138.RequestFlush;
+            toJSON(_: _138.RequestFlush): unknown;
+            fromPartial(_: {}): _138.RequestFlush;
+        };
+        RequestInfo: {
+            encode(message: _138.RequestInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestInfo;
+            fromJSON(object: any): _138.RequestInfo;
+            toJSON(message: _138.RequestInfo): unknown;
+            fromPartial(object: {
+                version?: string;
+                blockVersion?: any;
+                p2pVersion?: any;
+            }): _138.RequestInfo;
+        };
+        RequestSetOption: {
+            encode(message: _138.RequestSetOption, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestSetOption;
+            fromJSON(object: any): _138.RequestSetOption;
+            toJSON(message: _138.RequestSetOption): unknown;
+            fromPartial(object: {
+                key?: string;
+                value?: string;
+            }): _138.RequestSetOption;
+        };
+        RequestInitChain: {
+            encode(message: _138.RequestInitChain, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestInitChain;
+            fromJSON(object: any): _138.RequestInitChain;
+            toJSON(message: _138.RequestInitChain): unknown;
+            fromPartial(object: {
+                time?: Date;
+                chainId?: string;
+                consensusParams?: {
+                    block?: {
+                        maxBytes?: any;
+                        maxGas?: any;
+                    };
+                    evidence?: {
+                        maxAgeNumBlocks?: any;
+                        maxAgeDuration?: {
+                            seconds?: any;
+                            nanos?: number;
+                        };
+                        maxBytes?: any;
+                    };
+                    validator?: {
+                        pubKeyTypes?: string[];
+                    };
+                    version?: {
+                        appVersion?: any;
+                    };
+                };
+                validators?: {
+                    pubKey?: {
+                        ed25519?: Uint8Array;
+                        secp256k1?: Uint8Array;
+                    };
+                    power?: any;
+                }[];
+                appStateBytes?: Uint8Array;
+                initialHeight?: any;
+            }): _138.RequestInitChain;
+        };
+        RequestQuery: {
+            encode(message: _138.RequestQuery, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestQuery;
+            fromJSON(object: any): _138.RequestQuery;
+            toJSON(message: _138.RequestQuery): unknown;
+            fromPartial(object: {
+                data?: Uint8Array;
+                path?: string;
+                height?: any;
+                prove?: boolean;
+            }): _138.RequestQuery;
+        };
+        RequestBeginBlock: {
+            encode(message: _138.RequestBeginBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestBeginBlock;
+            fromJSON(object: any): _138.RequestBeginBlock;
+            toJSON(message: _138.RequestBeginBlock): unknown;
+            fromPartial(object: {
+                hash?: Uint8Array;
+                header?: {
+                    version?: {
+                        block?: any;
+                        app?: any;
+                    };
+                    chainId?: string;
+                    height?: any;
+                    time?: Date;
+                    lastBlockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    lastCommitHash?: Uint8Array;
+                    dataHash?: Uint8Array;
+                    validatorsHash?: Uint8Array;
+                    nextValidatorsHash?: Uint8Array;
+                    consensusHash?: Uint8Array;
+                    appHash?: Uint8Array;
+                    lastResultsHash?: Uint8Array;
+                    evidenceHash?: Uint8Array;
+                    proposerAddress?: Uint8Array;
+                };
+                lastCommitInfo?: {
+                    round?: number;
+                    votes?: {
+                        validator?: {
+                            address?: Uint8Array;
+                            power?: any;
+                        };
+                        signedLastBlock?: boolean;
+                    }[];
+                };
+                byzantineValidators?: {
+                    type?: _138.EvidenceType;
+                    validator?: {
+                        address?: Uint8Array;
+                        power?: any;
+                    };
+                    height?: any;
+                    time?: Date;
+                    totalVotingPower?: any;
+                }[];
+            }): _138.RequestBeginBlock;
+        };
+        RequestCheckTx: {
+            encode(message: _138.RequestCheckTx, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestCheckTx;
+            fromJSON(object: any): _138.RequestCheckTx;
+            toJSON(message: _138.RequestCheckTx): unknown;
+            fromPartial(object: {
+                tx?: Uint8Array;
+                type?: _138.CheckTxType;
+            }): _138.RequestCheckTx;
+        };
+        RequestDeliverTx: {
+            encode(message: _138.RequestDeliverTx, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestDeliverTx;
+            fromJSON(object: any): _138.RequestDeliverTx;
+            toJSON(message: _138.RequestDeliverTx): unknown;
+            fromPartial(object: {
+                tx?: Uint8Array;
+            }): _138.RequestDeliverTx;
+        };
+        RequestEndBlock: {
+            encode(message: _138.RequestEndBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestEndBlock;
+            fromJSON(object: any): _138.RequestEndBlock;
+            toJSON(message: _138.RequestEndBlock): unknown;
+            fromPartial(object: {
+                height?: any;
+            }): _138.RequestEndBlock;
+        };
+        RequestCommit: {
+            encode(_: _138.RequestCommit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestCommit;
+            fromJSON(_: any): _138.RequestCommit;
+            toJSON(_: _138.RequestCommit): unknown;
+            fromPartial(_: {}): _138.RequestCommit;
+        };
+        RequestListSnapshots: {
+            encode(_: _138.RequestListSnapshots, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestListSnapshots;
+            fromJSON(_: any): _138.RequestListSnapshots;
+            toJSON(_: _138.RequestListSnapshots): unknown;
+            fromPartial(_: {}): _138.RequestListSnapshots;
+        };
+        RequestOfferSnapshot: {
+            encode(message: _138.RequestOfferSnapshot, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestOfferSnapshot;
+            fromJSON(object: any): _138.RequestOfferSnapshot;
+            toJSON(message: _138.RequestOfferSnapshot): unknown;
+            fromPartial(object: {
+                snapshot?: {
+                    height?: any;
+                    format?: number;
+                    chunks?: number;
+                    hash?: Uint8Array;
+                    metadata?: Uint8Array;
+                };
+                appHash?: Uint8Array;
+            }): _138.RequestOfferSnapshot;
+        };
+        RequestLoadSnapshotChunk: {
+            encode(message: _138.RequestLoadSnapshotChunk, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestLoadSnapshotChunk;
+            fromJSON(object: any): _138.RequestLoadSnapshotChunk;
+            toJSON(message: _138.RequestLoadSnapshotChunk): unknown;
+            fromPartial(object: {
+                height?: any;
+                format?: number;
+                chunk?: number;
+            }): _138.RequestLoadSnapshotChunk;
+        };
+        RequestApplySnapshotChunk: {
+            encode(message: _138.RequestApplySnapshotChunk, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.RequestApplySnapshotChunk;
+            fromJSON(object: any): _138.RequestApplySnapshotChunk;
+            toJSON(message: _138.RequestApplySnapshotChunk): unknown;
+            fromPartial(object: {
+                index?: number;
+                chunk?: Uint8Array;
+                sender?: string;
+            }): _138.RequestApplySnapshotChunk;
+        };
+        Response: {
+            encode(message: _138.Response, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.Response;
+            fromJSON(object: any): _138.Response;
+            toJSON(message: _138.Response): unknown;
+            fromPartial(object: {
+                exception?: {
+                    error?: string;
+                };
+                echo?: {
+                    message?: string;
+                };
+                flush?: {};
+                info?: {
+                    data?: string;
+                    version?: string;
+                    appVersion?: any;
+                    lastBlockHeight?: any;
+                    lastBlockAppHash?: Uint8Array;
+                };
+                setOption?: {
+                    code?: number;
+                    log?: string;
+                    info?: string;
+                };
+                initChain?: {
+                    consensusParams?: {
+                        block?: {
+                            maxBytes?: any;
+                            maxGas?: any;
+                        };
+                        evidence?: {
+                            maxAgeNumBlocks?: any;
+                            maxAgeDuration?: {
+                                seconds?: any;
+                                nanos?: number;
+                            };
+                            maxBytes?: any;
+                        };
+                        validator?: {
+                            pubKeyTypes?: string[];
+                        };
+                        version?: {
+                            appVersion?: any;
+                        };
+                    };
+                    validators?: {
+                        pubKey?: {
+                            ed25519?: Uint8Array;
+                            secp256k1?: Uint8Array;
+                        };
+                        power?: any;
+                    }[];
+                    appHash?: Uint8Array;
+                };
+                query?: {
+                    code?: number;
+                    log?: string;
+                    info?: string;
+                    index?: any;
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    proofOps?: {
+                        ops?: {
+                            type?: string;
+                            key?: Uint8Array;
+                            data?: Uint8Array;
+                        }[];
+                    };
+                    height?: any;
+                    codespace?: string;
+                };
+                beginBlock?: {
+                    events?: {
+                        type?: string;
+                        attributes?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            index?: boolean;
+                        }[];
+                    }[];
+                };
+                checkTx?: {
+                    code?: number;
+                    data?: Uint8Array;
+                    log?: string;
+                    info?: string;
+                    gasWanted?: any;
+                    gasUsed?: any;
+                    events?: {
+                        type?: string;
+                        attributes?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            index?: boolean;
+                        }[];
+                    }[];
+                    codespace?: string;
+                };
+                deliverTx?: {
+                    code?: number;
+                    data?: Uint8Array;
+                    log?: string;
+                    info?: string;
+                    gasWanted?: any;
+                    gasUsed?: any;
+                    events?: {
+                        type?: string;
+                        attributes?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            index?: boolean;
+                        }[];
+                    }[];
+                    codespace?: string;
+                };
+                endBlock?: {
+                    validatorUpdates?: {
+                        pubKey?: {
+                            ed25519?: Uint8Array;
+                            secp256k1?: Uint8Array;
+                        };
+                        power?: any;
+                    }[];
+                    consensusParamUpdates?: {
+                        block?: {
+                            maxBytes?: any;
+                            maxGas?: any;
+                        };
+                        evidence?: {
+                            maxAgeNumBlocks?: any;
+                            maxAgeDuration?: {
+                                seconds?: any;
+                                nanos?: number;
+                            };
+                            maxBytes?: any;
+                        };
+                        validator?: {
+                            pubKeyTypes?: string[];
+                        };
+                        version?: {
+                            appVersion?: any;
+                        };
+                    };
+                    events?: {
+                        type?: string;
+                        attributes?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            index?: boolean;
+                        }[];
+                    }[];
+                };
+                commit?: {
+                    data?: Uint8Array;
+                    retainHeight?: any;
+                };
+                listSnapshots?: {
+                    snapshots?: {
+                        height?: any;
+                        format?: number;
+                        chunks?: number;
+                        hash?: Uint8Array;
+                        metadata?: Uint8Array;
+                    }[];
+                };
+                offerSnapshot?: {
+                    result?: _138.ResponseOfferSnapshot_Result;
+                };
+                loadSnapshotChunk?: {
+                    chunk?: Uint8Array;
+                };
+                applySnapshotChunk?: {
+                    result?: _138.ResponseApplySnapshotChunk_Result;
+                    refetchChunks?: number[];
+                    rejectSenders?: string[];
+                };
+            }): _138.Response;
+        };
+        ResponseException: {
+            encode(message: _138.ResponseException, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseException;
+            fromJSON(object: any): _138.ResponseException;
+            toJSON(message: _138.ResponseException): unknown;
+            fromPartial(object: {
+                error?: string;
+            }): _138.ResponseException;
+        };
+        ResponseEcho: {
+            encode(message: _138.ResponseEcho, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseEcho;
+            fromJSON(object: any): _138.ResponseEcho;
+            toJSON(message: _138.ResponseEcho): unknown;
+            fromPartial(object: {
+                message?: string;
+            }): _138.ResponseEcho;
+        };
+        ResponseFlush: {
+            encode(_: _138.ResponseFlush, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseFlush;
+            fromJSON(_: any): _138.ResponseFlush;
+            toJSON(_: _138.ResponseFlush): unknown;
+            fromPartial(_: {}): _138.ResponseFlush;
+        };
+        ResponseInfo: {
+            encode(message: _138.ResponseInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseInfo;
+            fromJSON(object: any): _138.ResponseInfo;
+            toJSON(message: _138.ResponseInfo): unknown;
+            fromPartial(object: {
+                data?: string;
+                version?: string;
+                appVersion?: any;
+                lastBlockHeight?: any;
+                lastBlockAppHash?: Uint8Array;
+            }): _138.ResponseInfo;
+        };
+        ResponseSetOption: {
+            encode(message: _138.ResponseSetOption, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseSetOption;
+            fromJSON(object: any): _138.ResponseSetOption;
+            toJSON(message: _138.ResponseSetOption): unknown;
+            fromPartial(object: {
+                code?: number;
+                log?: string;
+                info?: string;
+            }): _138.ResponseSetOption;
+        };
+        ResponseInitChain: {
+            encode(message: _138.ResponseInitChain, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseInitChain;
+            fromJSON(object: any): _138.ResponseInitChain;
+            toJSON(message: _138.ResponseInitChain): unknown;
+            fromPartial(object: {
+                consensusParams?: {
+                    block?: {
+                        maxBytes?: any;
+                        maxGas?: any;
+                    };
+                    evidence?: {
+                        maxAgeNumBlocks?: any;
+                        maxAgeDuration?: {
+                            seconds?: any;
+                            nanos?: number;
+                        };
+                        maxBytes?: any;
+                    };
+                    validator?: {
+                        pubKeyTypes?: string[];
+                    };
+                    version?: {
+                        appVersion?: any;
+                    };
+                };
+                validators?: {
+                    pubKey?: {
+                        ed25519?: Uint8Array;
+                        secp256k1?: Uint8Array;
+                    };
+                    power?: any;
+                }[];
+                appHash?: Uint8Array;
+            }): _138.ResponseInitChain;
+        };
+        ResponseQuery: {
+            encode(message: _138.ResponseQuery, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseQuery;
+            fromJSON(object: any): _138.ResponseQuery;
+            toJSON(message: _138.ResponseQuery): unknown;
+            fromPartial(object: {
+                code?: number;
+                log?: string;
+                info?: string;
+                index?: any;
+                key?: Uint8Array;
+                value?: Uint8Array;
+                proofOps?: {
+                    ops?: {
+                        type?: string;
+                        key?: Uint8Array;
+                        data?: Uint8Array;
+                    }[];
+                };
+                height?: any;
+                codespace?: string;
+            }): _138.ResponseQuery;
+        };
+        ResponseBeginBlock: {
+            encode(message: _138.ResponseBeginBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseBeginBlock;
+            fromJSON(object: any): _138.ResponseBeginBlock;
+            toJSON(message: _138.ResponseBeginBlock): unknown;
+            fromPartial(object: {
+                events?: {
+                    type?: string;
+                    attributes?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        index?: boolean;
+                    }[];
+                }[];
+            }): _138.ResponseBeginBlock;
+        };
+        ResponseCheckTx: {
+            encode(message: _138.ResponseCheckTx, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseCheckTx;
+            fromJSON(object: any): _138.ResponseCheckTx;
+            toJSON(message: _138.ResponseCheckTx): unknown;
+            fromPartial(object: {
+                code?: number;
+                data?: Uint8Array;
+                log?: string;
+                info?: string;
+                gasWanted?: any;
+                gasUsed?: any;
+                events?: {
+                    type?: string;
+                    attributes?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        index?: boolean;
+                    }[];
+                }[];
+                codespace?: string;
+            }): _138.ResponseCheckTx;
+        };
+        ResponseDeliverTx: {
+            encode(message: _138.ResponseDeliverTx, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseDeliverTx;
+            fromJSON(object: any): _138.ResponseDeliverTx;
+            toJSON(message: _138.ResponseDeliverTx): unknown;
+            fromPartial(object: {
+                code?: number;
+                data?: Uint8Array;
+                log?: string;
+                info?: string;
+                gasWanted?: any;
+                gasUsed?: any;
+                events?: {
+                    type?: string;
+                    attributes?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        index?: boolean;
+                    }[];
+                }[];
+                codespace?: string;
+            }): _138.ResponseDeliverTx;
+        };
+        ResponseEndBlock: {
+            encode(message: _138.ResponseEndBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseEndBlock;
+            fromJSON(object: any): _138.ResponseEndBlock;
+            toJSON(message: _138.ResponseEndBlock): unknown;
+            fromPartial(object: {
+                validatorUpdates?: {
+                    pubKey?: {
+                        ed25519?: Uint8Array;
+                        secp256k1?: Uint8Array;
+                    };
+                    power?: any;
+                }[];
+                consensusParamUpdates?: {
+                    block?: {
+                        maxBytes?: any;
+                        maxGas?: any;
+                    };
+                    evidence?: {
+                        maxAgeNumBlocks?: any;
+                        maxAgeDuration?: {
+                            seconds?: any;
+                            nanos?: number;
+                        };
+                        maxBytes?: any;
+                    };
+                    validator?: {
+                        pubKeyTypes?: string[];
+                    };
+                    version?: {
+                        appVersion?: any;
+                    };
+                };
+                events?: {
+                    type?: string;
+                    attributes?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        index?: boolean;
+                    }[];
+                }[];
+            }): _138.ResponseEndBlock;
+        };
+        ResponseCommit: {
+            encode(message: _138.ResponseCommit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseCommit;
+            fromJSON(object: any): _138.ResponseCommit;
+            toJSON(message: _138.ResponseCommit): unknown;
+            fromPartial(object: {
+                data?: Uint8Array;
+                retainHeight?: any;
+            }): _138.ResponseCommit;
+        };
+        ResponseListSnapshots: {
+            encode(message: _138.ResponseListSnapshots, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseListSnapshots;
+            fromJSON(object: any): _138.ResponseListSnapshots;
+            toJSON(message: _138.ResponseListSnapshots): unknown;
+            fromPartial(object: {
+                snapshots?: {
+                    height?: any;
+                    format?: number;
+                    chunks?: number;
+                    hash?: Uint8Array;
+                    metadata?: Uint8Array;
+                }[];
+            }): _138.ResponseListSnapshots;
+        };
+        ResponseOfferSnapshot: {
+            encode(message: _138.ResponseOfferSnapshot, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseOfferSnapshot;
+            fromJSON(object: any): _138.ResponseOfferSnapshot;
+            toJSON(message: _138.ResponseOfferSnapshot): unknown;
+            fromPartial(object: {
+                result?: _138.ResponseOfferSnapshot_Result;
+            }): _138.ResponseOfferSnapshot;
+        };
+        ResponseLoadSnapshotChunk: {
+            encode(message: _138.ResponseLoadSnapshotChunk, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseLoadSnapshotChunk;
+            fromJSON(object: any): _138.ResponseLoadSnapshotChunk;
+            toJSON(message: _138.ResponseLoadSnapshotChunk): unknown;
+            fromPartial(object: {
+                chunk?: Uint8Array;
+            }): _138.ResponseLoadSnapshotChunk;
+        };
+        ResponseApplySnapshotChunk: {
+            encode(message: _138.ResponseApplySnapshotChunk, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ResponseApplySnapshotChunk;
+            fromJSON(object: any): _138.ResponseApplySnapshotChunk;
+            toJSON(message: _138.ResponseApplySnapshotChunk): unknown;
+            fromPartial(object: {
+                result?: _138.ResponseApplySnapshotChunk_Result;
+                refetchChunks?: number[];
+                rejectSenders?: string[];
+            }): _138.ResponseApplySnapshotChunk;
+        };
+        ConsensusParams: {
+            encode(message: _138.ConsensusParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ConsensusParams;
+            fromJSON(object: any): _138.ConsensusParams;
+            toJSON(message: _138.ConsensusParams): unknown;
+            fromPartial(object: {
+                block?: {
+                    maxBytes?: any;
+                    maxGas?: any;
+                };
+                evidence?: {
+                    maxAgeNumBlocks?: any;
+                    maxAgeDuration?: {
+                        seconds?: any;
+                        nanos?: number;
+                    };
+                    maxBytes?: any;
+                };
+                validator?: {
+                    pubKeyTypes?: string[];
+                };
+                version?: {
+                    appVersion?: any;
+                };
+            }): _138.ConsensusParams;
+        };
+        BlockParams: {
+            encode(message: _138.BlockParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.BlockParams;
+            fromJSON(object: any): _138.BlockParams;
+            toJSON(message: _138.BlockParams): unknown;
+            fromPartial(object: {
+                maxBytes?: any;
+                maxGas?: any;
+            }): _138.BlockParams;
+        };
+        LastCommitInfo: {
+            encode(message: _138.LastCommitInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.LastCommitInfo;
+            fromJSON(object: any): _138.LastCommitInfo;
+            toJSON(message: _138.LastCommitInfo): unknown;
+            fromPartial(object: {
+                round?: number;
+                votes?: {
+                    validator?: {
+                        address?: Uint8Array;
+                        power?: any;
+                    };
+                    signedLastBlock?: boolean;
+                }[];
+            }): _138.LastCommitInfo;
+        };
+        Event: {
+            encode(message: _138.Event, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.Event;
+            fromJSON(object: any): _138.Event;
+            toJSON(message: _138.Event): unknown;
+            fromPartial(object: {
+                type?: string;
+                attributes?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    index?: boolean;
+                }[];
+            }): _138.Event;
+        };
+        EventAttribute: {
+            encode(message: _138.EventAttribute, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.EventAttribute;
+            fromJSON(object: any): _138.EventAttribute;
+            toJSON(message: _138.EventAttribute): unknown;
+            fromPartial(object: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                index?: boolean;
+            }): _138.EventAttribute;
+        };
+        TxResult: {
+            encode(message: _138.TxResult, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.TxResult;
+            fromJSON(object: any): _138.TxResult;
+            toJSON(message: _138.TxResult): unknown;
+            fromPartial(object: {
+                height?: any;
+                index?: number;
+                tx?: Uint8Array;
+                result?: {
+                    code?: number;
+                    data?: Uint8Array;
+                    log?: string;
+                    info?: string;
+                    gasWanted?: any;
+                    gasUsed?: any;
+                    events?: {
+                        type?: string;
+                        attributes?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                            index?: boolean;
+                        }[];
+                    }[];
+                    codespace?: string;
+                };
+            }): _138.TxResult;
+        };
+        Validator: {
+            encode(message: _138.Validator, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.Validator;
+            fromJSON(object: any): _138.Validator;
+            toJSON(message: _138.Validator): unknown;
+            fromPartial(object: {
+                address?: Uint8Array;
+                power?: any;
+            }): _138.Validator;
+        };
+        ValidatorUpdate: {
+            encode(message: _138.ValidatorUpdate, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.ValidatorUpdate;
+            fromJSON(object: any): _138.ValidatorUpdate;
+            toJSON(message: _138.ValidatorUpdate): unknown;
+            fromPartial(object: {
+                pubKey?: {
+                    ed25519?: Uint8Array;
+                    secp256k1?: Uint8Array;
+                };
+                power?: any;
+            }): _138.ValidatorUpdate;
+        };
+        VoteInfo: {
+            encode(message: _138.VoteInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.VoteInfo;
+            fromJSON(object: any): _138.VoteInfo;
+            toJSON(message: _138.VoteInfo): unknown;
+            fromPartial(object: {
+                validator?: {
+                    address?: Uint8Array;
+                    power?: any;
+                };
+                signedLastBlock?: boolean;
+            }): _138.VoteInfo;
+        };
+        Evidence: {
+            encode(message: _138.Evidence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.Evidence;
+            fromJSON(object: any): _138.Evidence;
+            toJSON(message: _138.Evidence): unknown;
+            fromPartial(object: {
+                type?: _138.EvidenceType;
+                validator?: {
+                    address?: Uint8Array;
+                    power?: any;
+                };
+                height?: any;
+                time?: Date;
+                totalVotingPower?: any;
+            }): _138.Evidence;
+        };
+        Snapshot: {
+            encode(message: _138.Snapshot, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _138.Snapshot;
+            fromJSON(object: any): _138.Snapshot;
+            toJSON(message: _138.Snapshot): unknown;
+            fromPartial(object: {
+                height?: any;
+                format?: number;
+                chunks?: number;
+                hash?: Uint8Array;
+                metadata?: Uint8Array;
+            }): _138.Snapshot;
+        };
+    };
+    const crypto: {
+        Proof: {
+            encode(message: _140.Proof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _140.Proof;
+            fromJSON(object: any): _140.Proof;
+            toJSON(message: _140.Proof): unknown;
+            fromPartial(object: {
+                total?: any;
+                index?: any;
+                leafHash?: Uint8Array;
+                aunts?: Uint8Array[];
+            }): _140.Proof;
+        };
+        ValueOp: {
+            encode(message: _140.ValueOp, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _140.ValueOp;
+            fromJSON(object: any): _140.ValueOp;
+            toJSON(message: _140.ValueOp): unknown;
+            fromPartial(object: {
+                key?: Uint8Array;
+                proof?: {
+                    total?: any;
+                    index?: any;
+                    leafHash?: Uint8Array;
+                    aunts?: Uint8Array[];
+                };
+            }): _140.ValueOp;
+        };
+        DominoOp: {
+            encode(message: _140.DominoOp, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _140.DominoOp;
+            fromJSON(object: any): _140.DominoOp;
+            toJSON(message: _140.DominoOp): unknown;
+            fromPartial(object: {
+                key?: string;
+                input?: string;
+                output?: string;
+            }): _140.DominoOp;
+        };
+        ProofOp: {
+            encode(message: _140.ProofOp, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _140.ProofOp;
+            fromJSON(object: any): _140.ProofOp;
+            toJSON(message: _140.ProofOp): unknown;
+            fromPartial(object: {
+                type?: string;
+                key?: Uint8Array;
+                data?: Uint8Array;
+            }): _140.ProofOp;
+        };
+        ProofOps: {
+            encode(message: _140.ProofOps, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _140.ProofOps;
+            fromJSON(object: any): _140.ProofOps;
+            toJSON(message: _140.ProofOps): unknown;
+            fromPartial(object: {
+                ops?: {
+                    type?: string;
+                    key?: Uint8Array;
+                    data?: Uint8Array;
+                }[];
+            }): _140.ProofOps;
+        };
+        PublicKey: {
+            encode(message: _139.PublicKey, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _139.PublicKey;
+            fromJSON(object: any): _139.PublicKey;
+            toJSON(message: _139.PublicKey): unknown;
+            fromPartial(object: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            }): _139.PublicKey;
+        };
+    };
+    namespace libs {
+        const bits: {
+            BitArray: {
+                encode(message: _141.BitArray, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _141.BitArray;
+                fromJSON(object: any): _141.BitArray;
+                toJSON(message: _141.BitArray): unknown;
+                fromPartial(object: {
+                    bits?: any;
+                    elems?: any[];
+                }): _141.BitArray;
+            };
+        };
+    }
+    const p2p: {
+        ProtocolVersion: {
+            encode(message: _142.ProtocolVersion, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _142.ProtocolVersion;
+            fromJSON(object: any): _142.ProtocolVersion;
+            toJSON(message: _142.ProtocolVersion): unknown;
+            fromPartial(object: {
+                p2p?: any;
+                block?: any;
+                app?: any;
+            }): _142.ProtocolVersion;
+        };
+        NodeInfo: {
+            encode(message: _142.NodeInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _142.NodeInfo;
+            fromJSON(object: any): _142.NodeInfo;
+            toJSON(message: _142.NodeInfo): unknown;
+            fromPartial(object: {
+                protocolVersion?: {
+                    p2p?: any;
+                    block?: any;
+                    app?: any;
+                };
+                nodeId?: string;
+                listenAddr?: string;
+                network?: string;
+                version?: string;
+                channels?: Uint8Array;
+                moniker?: string;
+                other?: {
+                    txIndex?: string;
+                    rpcAddress?: string;
+                };
+            }): _142.NodeInfo;
+        };
+        NodeInfoOther: {
+            encode(message: _142.NodeInfoOther, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _142.NodeInfoOther;
+            fromJSON(object: any): _142.NodeInfoOther;
+            toJSON(message: _142.NodeInfoOther): unknown;
+            fromPartial(object: {
+                txIndex?: string;
+                rpcAddress?: string;
+            }): _142.NodeInfoOther;
+        };
+        PeerInfo: {
+            encode(message: _142.PeerInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _142.PeerInfo;
+            fromJSON(object: any): _142.PeerInfo;
+            toJSON(message: _142.PeerInfo): unknown;
+            fromPartial(object: {
+                id?: string;
+                addressInfo?: {
+                    address?: string;
+                    lastDialSuccess?: Date;
+                    lastDialFailure?: Date;
+                    dialFailures?: number;
+                }[];
+                lastConnected?: Date;
+            }): _142.PeerInfo;
+        };
+        PeerAddressInfo: {
+            encode(message: _142.PeerAddressInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _142.PeerAddressInfo;
+            fromJSON(object: any): _142.PeerAddressInfo;
+            toJSON(message: _142.PeerAddressInfo): unknown;
+            fromPartial(object: {
+                address?: string;
+                lastDialSuccess?: Date;
+                lastDialFailure?: Date;
+                dialFailures?: number;
+            }): _142.PeerAddressInfo;
+        };
+    };
+    const types: {
+        ValidatorSet: {
+            encode(message: _147.ValidatorSet, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _147.ValidatorSet;
+            fromJSON(object: any): _147.ValidatorSet;
+            toJSON(message: _147.ValidatorSet): unknown;
+            fromPartial(object: {
+                validators?: {
+                    address?: Uint8Array;
+                    pubKey?: {
+                        ed25519?: Uint8Array;
+                        secp256k1?: Uint8Array;
+                    };
+                    votingPower?: any;
+                    proposerPriority?: any;
+                }[];
+                proposer?: {
+                    address?: Uint8Array;
+                    pubKey?: {
+                        ed25519?: Uint8Array;
+                        secp256k1?: Uint8Array;
+                    };
+                    votingPower?: any;
+                    proposerPriority?: any;
+                };
+                totalVotingPower?: any;
+            }): _147.ValidatorSet;
+        };
+        Validator: {
+            encode(message: _147.Validator, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _147.Validator;
+            fromJSON(object: any): _147.Validator;
+            toJSON(message: _147.Validator): unknown;
+            fromPartial(object: {
+                address?: Uint8Array;
+                pubKey?: {
+                    ed25519?: Uint8Array;
+                    secp256k1?: Uint8Array;
+                };
+                votingPower?: any;
+                proposerPriority?: any;
+            }): _147.Validator;
+        };
+        SimpleValidator: {
+            encode(message: _147.SimpleValidator, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _147.SimpleValidator;
+            fromJSON(object: any): _147.SimpleValidator;
+            toJSON(message: _147.SimpleValidator): unknown;
+            fromPartial(object: {
+                pubKey?: {
+                    ed25519?: Uint8Array;
+                    secp256k1?: Uint8Array;
+                };
+                votingPower?: any;
+            }): _147.SimpleValidator;
+        };
+        blockIDFlagFromJSON(object: any): _146.BlockIDFlag;
+        blockIDFlagToJSON(object: _146.BlockIDFlag): string;
+        signedMsgTypeFromJSON(object: any): _146.SignedMsgType;
+        signedMsgTypeToJSON(object: _146.SignedMsgType): string;
+        BlockIDFlag: typeof _146.BlockIDFlag;
+        SignedMsgType: typeof _146.SignedMsgType;
+        PartSetHeader: {
+            encode(message: _146.PartSetHeader, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.PartSetHeader;
+            fromJSON(object: any): _146.PartSetHeader;
+            toJSON(message: _146.PartSetHeader): unknown;
+            fromPartial(object: {
+                total?: number;
+                hash?: Uint8Array;
+            }): _146.PartSetHeader;
+        };
+        Part: {
+            encode(message: _146.Part, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.Part;
+            fromJSON(object: any): _146.Part;
+            toJSON(message: _146.Part): unknown;
+            fromPartial(object: {
+                index?: number;
+                bytes?: Uint8Array;
+                proof?: {
+                    total?: any;
+                    index?: any;
+                    leafHash?: Uint8Array;
+                    aunts?: Uint8Array[];
+                };
+            }): _146.Part;
+        };
+        BlockID: {
+            encode(message: _146.BlockID, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.BlockID;
+            fromJSON(object: any): _146.BlockID;
+            toJSON(message: _146.BlockID): unknown;
+            fromPartial(object: {
+                hash?: Uint8Array;
+                partSetHeader?: {
+                    total?: number;
+                    hash?: Uint8Array;
+                };
+            }): _146.BlockID;
+        };
+        Header: {
+            encode(message: _146.Header, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.Header;
+            fromJSON(object: any): _146.Header;
+            toJSON(message: _146.Header): unknown;
+            fromPartial(object: {
+                version?: {
+                    block?: any;
+                    app?: any;
+                };
+                chainId?: string;
+                height?: any;
+                time?: Date;
+                lastBlockId?: {
+                    hash?: Uint8Array;
+                    partSetHeader?: {
+                        total?: number;
+                        hash?: Uint8Array;
+                    };
+                };
+                lastCommitHash?: Uint8Array;
+                dataHash?: Uint8Array;
+                validatorsHash?: Uint8Array;
+                nextValidatorsHash?: Uint8Array;
+                consensusHash?: Uint8Array;
+                appHash?: Uint8Array;
+                lastResultsHash?: Uint8Array;
+                evidenceHash?: Uint8Array;
+                proposerAddress?: Uint8Array;
+            }): _146.Header;
+        };
+        Data: {
+            encode(message: _146.Data, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.Data;
+            fromJSON(object: any): _146.Data;
+            toJSON(message: _146.Data): unknown;
+            fromPartial(object: {
+                txs?: Uint8Array[];
+            }): _146.Data;
+        };
+        Vote: {
+            encode(message: _146.Vote, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.Vote;
+            fromJSON(object: any): _146.Vote;
+            toJSON(message: _146.Vote): unknown;
+            fromPartial(object: {
+                type?: _146.SignedMsgType;
+                height?: any;
+                round?: number;
+                blockId?: {
+                    hash?: Uint8Array;
+                    partSetHeader?: {
+                        total?: number;
+                        hash?: Uint8Array;
+                    };
+                };
+                timestamp?: Date;
+                validatorAddress?: Uint8Array;
+                validatorIndex?: number;
+                signature?: Uint8Array;
+            }): _146.Vote;
+        };
+        Commit: {
+            encode(message: _146.Commit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.Commit;
+            fromJSON(object: any): _146.Commit;
+            toJSON(message: _146.Commit): unknown;
+            fromPartial(object: {
+                height?: any;
+                round?: number;
+                blockId?: {
+                    hash?: Uint8Array;
+                    partSetHeader?: {
+                        total?: number;
+                        hash?: Uint8Array;
+                    };
+                };
+                signatures?: {
+                    blockIdFlag?: _146.BlockIDFlag;
+                    validatorAddress?: Uint8Array;
+                    timestamp?: Date;
+                    signature?: Uint8Array;
+                }[];
+            }): _146.Commit;
+        };
+        CommitSig: {
+            encode(message: _146.CommitSig, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.CommitSig;
+            fromJSON(object: any): _146.CommitSig;
+            toJSON(message: _146.CommitSig): unknown;
+            fromPartial(object: {
+                blockIdFlag?: _146.BlockIDFlag;
+                validatorAddress?: Uint8Array;
+                timestamp?: Date;
+                signature?: Uint8Array;
+            }): _146.CommitSig;
+        };
+        Proposal: {
+            encode(message: _146.Proposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.Proposal;
+            fromJSON(object: any): _146.Proposal;
+            toJSON(message: _146.Proposal): unknown;
+            fromPartial(object: {
+                type?: _146.SignedMsgType;
+                height?: any;
+                round?: number;
+                polRound?: number;
+                blockId?: {
+                    hash?: Uint8Array;
+                    partSetHeader?: {
+                        total?: number;
+                        hash?: Uint8Array;
+                    };
+                };
+                timestamp?: Date;
+                signature?: Uint8Array;
+            }): _146.Proposal;
+        };
+        SignedHeader: {
+            encode(message: _146.SignedHeader, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.SignedHeader;
+            fromJSON(object: any): _146.SignedHeader;
+            toJSON(message: _146.SignedHeader): unknown;
+            fromPartial(object: {
+                header?: {
+                    version?: {
+                        block?: any;
+                        app?: any;
+                    };
+                    chainId?: string;
+                    height?: any;
+                    time?: Date;
+                    lastBlockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    lastCommitHash?: Uint8Array;
+                    dataHash?: Uint8Array;
+                    validatorsHash?: Uint8Array;
+                    nextValidatorsHash?: Uint8Array;
+                    consensusHash?: Uint8Array;
+                    appHash?: Uint8Array;
+                    lastResultsHash?: Uint8Array;
+                    evidenceHash?: Uint8Array;
+                    proposerAddress?: Uint8Array;
+                };
+                commit?: {
+                    height?: any;
+                    round?: number;
+                    blockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    signatures?: {
+                        blockIdFlag?: _146.BlockIDFlag;
+                        validatorAddress?: Uint8Array;
+                        timestamp?: Date;
+                        signature?: Uint8Array;
+                    }[];
+                };
+            }): _146.SignedHeader;
+        };
+        LightBlock: {
+            encode(message: _146.LightBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.LightBlock;
+            fromJSON(object: any): _146.LightBlock;
+            toJSON(message: _146.LightBlock): unknown;
+            fromPartial(object: {
+                signedHeader?: {
+                    header?: {
+                        version?: {
+                            block?: any;
+                            app?: any;
+                        };
+                        chainId?: string;
+                        height?: any;
+                        time?: Date;
+                        lastBlockId?: {
+                            hash?: Uint8Array;
+                            partSetHeader?: {
+                                total?: number;
+                                hash?: Uint8Array;
+                            };
+                        };
+                        lastCommitHash?: Uint8Array;
+                        dataHash?: Uint8Array;
+                        validatorsHash?: Uint8Array;
+                        nextValidatorsHash?: Uint8Array;
+                        consensusHash?: Uint8Array;
+                        appHash?: Uint8Array;
+                        lastResultsHash?: Uint8Array;
+                        evidenceHash?: Uint8Array;
+                        proposerAddress?: Uint8Array;
+                    };
+                    commit?: {
+                        height?: any;
+                        round?: number;
+                        blockId?: {
+                            hash?: Uint8Array;
+                            partSetHeader?: {
+                                total?: number;
+                                hash?: Uint8Array;
+                            };
+                        };
+                        signatures?: {
+                            blockIdFlag?: _146.BlockIDFlag;
+                            validatorAddress?: Uint8Array;
+                            timestamp?: Date;
+                            signature?: Uint8Array;
+                        }[];
+                    };
+                };
+                validatorSet?: {
+                    validators?: {
+                        address?: Uint8Array;
+                        pubKey?: {
+                            ed25519?: Uint8Array;
+                            secp256k1?: Uint8Array;
+                        };
+                        votingPower?: any;
+                        proposerPriority?: any;
+                    }[];
+                    proposer?: {
+                        address?: Uint8Array;
+                        pubKey?: {
+                            ed25519?: Uint8Array;
+                            secp256k1?: Uint8Array;
+                        };
+                        votingPower?: any;
+                        proposerPriority?: any;
+                    };
+                    totalVotingPower?: any;
+                };
+            }): _146.LightBlock;
+        };
+        BlockMeta: {
+            encode(message: _146.BlockMeta, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.BlockMeta;
+            fromJSON(object: any): _146.BlockMeta;
+            toJSON(message: _146.BlockMeta): unknown;
+            fromPartial(object: {
+                blockId?: {
+                    hash?: Uint8Array;
+                    partSetHeader?: {
+                        total?: number;
+                        hash?: Uint8Array;
+                    };
+                };
+                blockSize?: any;
+                header?: {
+                    version?: {
+                        block?: any;
+                        app?: any;
+                    };
+                    chainId?: string;
+                    height?: any;
+                    time?: Date;
+                    lastBlockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    lastCommitHash?: Uint8Array;
+                    dataHash?: Uint8Array;
+                    validatorsHash?: Uint8Array;
+                    nextValidatorsHash?: Uint8Array;
+                    consensusHash?: Uint8Array;
+                    appHash?: Uint8Array;
+                    lastResultsHash?: Uint8Array;
+                    evidenceHash?: Uint8Array;
+                    proposerAddress?: Uint8Array;
+                };
+                numTxs?: any;
+            }): _146.BlockMeta;
+        };
+        TxProof: {
+            encode(message: _146.TxProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _146.TxProof;
+            fromJSON(object: any): _146.TxProof;
+            toJSON(message: _146.TxProof): unknown;
+            fromPartial(object: {
+                rootHash?: Uint8Array;
+                data?: Uint8Array;
+                proof?: {
+                    total?: any;
+                    index?: any;
+                    leafHash?: Uint8Array;
+                    aunts?: Uint8Array[];
+                };
+            }): _146.TxProof;
+        };
+        ConsensusParams: {
+            encode(message: _145.ConsensusParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _145.ConsensusParams;
+            fromJSON(object: any): _145.ConsensusParams;
+            toJSON(message: _145.ConsensusParams): unknown;
+            fromPartial(object: {
+                block?: {
+                    maxBytes?: any;
+                    maxGas?: any;
+                    timeIotaMs?: any;
+                };
+                evidence?: {
+                    maxAgeNumBlocks?: any;
+                    maxAgeDuration?: {
+                        seconds?: any;
+                        nanos?: number;
+                    };
+                    maxBytes?: any;
+                };
+                validator?: {
+                    pubKeyTypes?: string[];
+                };
+                version?: {
+                    appVersion?: any;
+                };
+            }): _145.ConsensusParams;
+        };
+        BlockParams: {
+            encode(message: _145.BlockParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _145.BlockParams;
+            fromJSON(object: any): _145.BlockParams;
+            toJSON(message: _145.BlockParams): unknown;
+            fromPartial(object: {
+                maxBytes?: any;
+                maxGas?: any;
+                timeIotaMs?: any;
+            }): _145.BlockParams;
+        };
+        EvidenceParams: {
+            encode(message: _145.EvidenceParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _145.EvidenceParams;
+            fromJSON(object: any): _145.EvidenceParams;
+            toJSON(message: _145.EvidenceParams): unknown;
+            fromPartial(object: {
+                maxAgeNumBlocks?: any;
+                maxAgeDuration?: {
+                    seconds?: any;
+                    nanos?: number;
+                };
+                maxBytes?: any;
+            }): _145.EvidenceParams;
+        };
+        ValidatorParams: {
+            encode(message: _145.ValidatorParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _145.ValidatorParams;
+            fromJSON(object: any): _145.ValidatorParams;
+            toJSON(message: _145.ValidatorParams): unknown;
+            fromPartial(object: {
+                pubKeyTypes?: string[];
+            }): _145.ValidatorParams;
+        };
+        VersionParams: {
+            encode(message: _145.VersionParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _145.VersionParams;
+            fromJSON(object: any): _145.VersionParams;
+            toJSON(message: _145.VersionParams): unknown;
+            fromPartial(object: {
+                appVersion?: any;
+            }): _145.VersionParams;
+        };
+        HashedParams: {
+            encode(message: _145.HashedParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _145.HashedParams;
+            fromJSON(object: any): _145.HashedParams;
+            toJSON(message: _145.HashedParams): unknown;
+            fromPartial(object: {
+                blockMaxBytes?: any;
+                blockMaxGas?: any;
+            }): _145.HashedParams;
+        };
+        Evidence: {
+            encode(message: _144.Evidence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _144.Evidence;
+            fromJSON(object: any): _144.Evidence;
+            toJSON(message: _144.Evidence): unknown;
+            fromPartial(object: {
+                duplicateVoteEvidence?: {
+                    voteA?: {
+                        type?: _146.SignedMsgType;
+                        height?: any;
+                        round?: number;
+                        blockId?: {
+                            hash?: Uint8Array;
+                            partSetHeader?: {
+                                total?: number;
+                                hash?: Uint8Array;
+                            };
+                        };
+                        timestamp?: Date;
+                        validatorAddress?: Uint8Array;
+                        validatorIndex?: number;
+                        signature?: Uint8Array;
+                    };
+                    voteB?: {
+                        type?: _146.SignedMsgType;
+                        height?: any;
+                        round?: number;
+                        blockId?: {
+                            hash?: Uint8Array;
+                            partSetHeader?: {
+                                total?: number;
+                                hash?: Uint8Array;
+                            };
+                        };
+                        timestamp?: Date;
+                        validatorAddress?: Uint8Array;
+                        validatorIndex?: number;
+                        signature?: Uint8Array;
+                    };
+                    totalVotingPower?: any;
+                    validatorPower?: any;
+                    timestamp?: Date;
+                };
+                lightClientAttackEvidence?: {
+                    conflictingBlock?: {
+                        signedHeader?: {
+                            header?: {
+                                version?: {
+                                    block?: any;
+                                    app?: any;
+                                };
+                                chainId?: string;
+                                height?: any;
+                                time?: Date;
+                                lastBlockId?: {
+                                    hash?: Uint8Array;
+                                    partSetHeader?: {
+                                        total?: number;
+                                        hash?: Uint8Array;
+                                    };
+                                };
+                                lastCommitHash?: Uint8Array;
+                                dataHash?: Uint8Array;
+                                validatorsHash?: Uint8Array;
+                                nextValidatorsHash?: Uint8Array;
+                                consensusHash?: Uint8Array;
+                                appHash?: Uint8Array;
+                                lastResultsHash?: Uint8Array;
+                                evidenceHash?: Uint8Array;
+                                proposerAddress?: Uint8Array;
+                            };
+                            commit?: {
+                                height?: any;
+                                round?: number;
+                                blockId?: {
+                                    hash?: Uint8Array;
+                                    partSetHeader?: {
+                                        total?: number;
+                                        hash?: Uint8Array;
+                                    };
+                                };
+                                signatures?: {
+                                    blockIdFlag?: _146.BlockIDFlag;
+                                    validatorAddress?: Uint8Array;
+                                    timestamp?: Date;
+                                    signature?: Uint8Array;
+                                }[];
+                            };
+                        };
+                        validatorSet?: {
+                            validators?: {
+                                address?: Uint8Array;
+                                pubKey?: {
+                                    ed25519?: Uint8Array;
+                                    secp256k1?: Uint8Array;
+                                };
+                                votingPower?: any;
+                                proposerPriority?: any;
+                            }[];
+                            proposer?: {
+                                address?: Uint8Array;
+                                pubKey?: {
+                                    ed25519?: Uint8Array;
+                                    secp256k1?: Uint8Array;
+                                };
+                                votingPower?: any;
+                                proposerPriority?: any;
+                            };
+                            totalVotingPower?: any;
+                        };
+                    };
+                    commonHeight?: any;
+                    byzantineValidators?: {
+                        address?: Uint8Array;
+                        pubKey?: {
+                            ed25519?: Uint8Array;
+                            secp256k1?: Uint8Array;
+                        };
+                        votingPower?: any;
+                        proposerPriority?: any;
+                    }[];
+                    totalVotingPower?: any;
+                    timestamp?: Date;
+                };
+            }): _144.Evidence;
+        };
+        DuplicateVoteEvidence: {
+            encode(message: _144.DuplicateVoteEvidence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _144.DuplicateVoteEvidence;
+            fromJSON(object: any): _144.DuplicateVoteEvidence;
+            toJSON(message: _144.DuplicateVoteEvidence): unknown;
+            fromPartial(object: {
+                voteA?: {
+                    type?: _146.SignedMsgType;
+                    height?: any;
+                    round?: number;
+                    blockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    timestamp?: Date;
+                    validatorAddress?: Uint8Array;
+                    validatorIndex?: number;
+                    signature?: Uint8Array;
+                };
+                voteB?: {
+                    type?: _146.SignedMsgType;
+                    height?: any;
+                    round?: number;
+                    blockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    timestamp?: Date;
+                    validatorAddress?: Uint8Array;
+                    validatorIndex?: number;
+                    signature?: Uint8Array;
+                };
+                totalVotingPower?: any;
+                validatorPower?: any;
+                timestamp?: Date;
+            }): _144.DuplicateVoteEvidence;
+        };
+        LightClientAttackEvidence: {
+            encode(message: _144.LightClientAttackEvidence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _144.LightClientAttackEvidence;
+            fromJSON(object: any): _144.LightClientAttackEvidence;
+            toJSON(message: _144.LightClientAttackEvidence): unknown;
+            fromPartial(object: {
+                conflictingBlock?: {
+                    signedHeader?: {
+                        header?: {
+                            version?: {
+                                block?: any;
+                                app?: any;
+                            };
+                            chainId?: string;
+                            height?: any;
+                            time?: Date;
+                            lastBlockId?: {
+                                hash?: Uint8Array;
+                                partSetHeader?: {
+                                    total?: number;
+                                    hash?: Uint8Array;
+                                };
+                            };
+                            lastCommitHash?: Uint8Array;
+                            dataHash?: Uint8Array;
+                            validatorsHash?: Uint8Array;
+                            nextValidatorsHash?: Uint8Array;
+                            consensusHash?: Uint8Array;
+                            appHash?: Uint8Array;
+                            lastResultsHash?: Uint8Array;
+                            evidenceHash?: Uint8Array;
+                            proposerAddress?: Uint8Array;
+                        };
+                        commit?: {
+                            height?: any;
+                            round?: number;
+                            blockId?: {
+                                hash?: Uint8Array;
+                                partSetHeader?: {
+                                    total?: number;
+                                    hash?: Uint8Array;
+                                };
+                            };
+                            signatures?: {
+                                blockIdFlag?: _146.BlockIDFlag;
+                                validatorAddress?: Uint8Array;
+                                timestamp?: Date;
+                                signature?: Uint8Array;
+                            }[];
+                        };
+                    };
+                    validatorSet?: {
+                        validators?: {
+                            address?: Uint8Array;
+                            pubKey?: {
+                                ed25519?: Uint8Array;
+                                secp256k1?: Uint8Array;
+                            };
+                            votingPower?: any;
+                            proposerPriority?: any;
+                        }[];
+                        proposer?: {
+                            address?: Uint8Array;
+                            pubKey?: {
+                                ed25519?: Uint8Array;
+                                secp256k1?: Uint8Array;
+                            };
+                            votingPower?: any;
+                            proposerPriority?: any;
+                        };
+                        totalVotingPower?: any;
+                    };
+                };
+                commonHeight?: any;
+                byzantineValidators?: {
+                    address?: Uint8Array;
+                    pubKey?: {
+                        ed25519?: Uint8Array;
+                        secp256k1?: Uint8Array;
+                    };
+                    votingPower?: any;
+                    proposerPriority?: any;
+                }[];
+                totalVotingPower?: any;
+                timestamp?: Date;
+            }): _144.LightClientAttackEvidence;
+        };
+        EvidenceList: {
+            encode(message: _144.EvidenceList, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _144.EvidenceList;
+            fromJSON(object: any): _144.EvidenceList;
+            toJSON(message: _144.EvidenceList): unknown;
+            fromPartial(object: {
+                evidence?: {
+                    duplicateVoteEvidence?: {
+                        voteA?: {
+                            type?: _146.SignedMsgType;
+                            height?: any;
+                            round?: number;
+                            blockId?: {
+                                hash?: Uint8Array;
+                                partSetHeader?: {
+                                    total?: number;
+                                    hash?: Uint8Array;
+                                };
+                            };
+                            timestamp?: Date;
+                            validatorAddress?: Uint8Array;
+                            validatorIndex?: number;
+                            signature?: Uint8Array;
+                        };
+                        voteB?: {
+                            type?: _146.SignedMsgType;
+                            height?: any;
+                            round?: number;
+                            blockId?: {
+                                hash?: Uint8Array;
+                                partSetHeader?: {
+                                    total?: number;
+                                    hash?: Uint8Array;
+                                };
+                            };
+                            timestamp?: Date;
+                            validatorAddress?: Uint8Array;
+                            validatorIndex?: number;
+                            signature?: Uint8Array;
+                        };
+                        totalVotingPower?: any;
+                        validatorPower?: any;
+                        timestamp?: Date;
+                    };
+                    lightClientAttackEvidence?: {
+                        conflictingBlock?: {
+                            signedHeader?: {
+                                header?: {
+                                    version?: {
+                                        block?: any;
+                                        app?: any;
+                                    };
+                                    chainId?: string;
+                                    height?: any;
+                                    time?: Date;
+                                    lastBlockId?: {
+                                        hash?: Uint8Array;
+                                        partSetHeader?: {
+                                            total?: number;
+                                            hash?: Uint8Array;
+                                        };
+                                    };
+                                    lastCommitHash?: Uint8Array;
+                                    dataHash?: Uint8Array;
+                                    validatorsHash?: Uint8Array;
+                                    nextValidatorsHash?: Uint8Array;
+                                    consensusHash?: Uint8Array;
+                                    appHash?: Uint8Array;
+                                    lastResultsHash?: Uint8Array;
+                                    evidenceHash?: Uint8Array;
+                                    proposerAddress?: Uint8Array;
+                                };
+                                commit?: {
+                                    height?: any;
+                                    round?: number;
+                                    blockId?: {
+                                        hash?: Uint8Array;
+                                        partSetHeader?: {
+                                            total?: number;
+                                            hash?: Uint8Array;
+                                        };
+                                    };
+                                    signatures?: {
+                                        blockIdFlag?: _146.BlockIDFlag;
+                                        validatorAddress?: Uint8Array;
+                                        timestamp?: Date;
+                                        signature?: Uint8Array;
+                                    }[];
+                                };
+                            };
+                            validatorSet?: {
+                                validators?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                }[];
+                                proposer?: {
+                                    address?: Uint8Array;
+                                    pubKey?: {
+                                        ed25519?: Uint8Array;
+                                        secp256k1?: Uint8Array;
+                                    };
+                                    votingPower?: any;
+                                    proposerPriority?: any;
+                                };
+                                totalVotingPower?: any;
+                            };
+                        };
+                        commonHeight?: any;
+                        byzantineValidators?: {
+                            address?: Uint8Array;
+                            pubKey?: {
+                                ed25519?: Uint8Array;
+                                secp256k1?: Uint8Array;
+                            };
+                            votingPower?: any;
+                            proposerPriority?: any;
+                        }[];
+                        totalVotingPower?: any;
+                        timestamp?: Date;
+                    };
+                }[];
+            }): _144.EvidenceList;
+        };
+        Block: {
+            encode(message: _143.Block, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _143.Block;
+            fromJSON(object: any): _143.Block;
+            toJSON(message: _143.Block): unknown;
+            fromPartial(object: {
+                header?: {
+                    version?: {
+                        block?: any;
+                        app?: any;
+                    };
+                    chainId?: string;
+                    height?: any;
+                    time?: Date;
+                    lastBlockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    lastCommitHash?: Uint8Array;
+                    dataHash?: Uint8Array;
+                    validatorsHash?: Uint8Array;
+                    nextValidatorsHash?: Uint8Array;
+                    consensusHash?: Uint8Array;
+                    appHash?: Uint8Array;
+                    lastResultsHash?: Uint8Array;
+                    evidenceHash?: Uint8Array;
+                    proposerAddress?: Uint8Array;
+                };
+                data?: {
+                    txs?: Uint8Array[];
+                };
+                evidence?: {
+                    evidence?: {
+                        duplicateVoteEvidence?: {
+                            voteA?: {
+                                type?: _146.SignedMsgType;
+                                height?: any;
+                                round?: number;
+                                blockId?: {
+                                    hash?: Uint8Array;
+                                    partSetHeader?: {
+                                        total?: number;
+                                        hash?: Uint8Array;
+                                    };
+                                };
+                                timestamp?: Date;
+                                validatorAddress?: Uint8Array;
+                                validatorIndex?: number;
+                                signature?: Uint8Array;
+                            };
+                            voteB?: {
+                                type?: _146.SignedMsgType;
+                                height?: any;
+                                round?: number;
+                                blockId?: {
+                                    hash?: Uint8Array;
+                                    partSetHeader?: {
+                                        total?: number;
+                                        hash?: Uint8Array;
+                                    };
+                                };
+                                timestamp?: Date;
+                                validatorAddress?: Uint8Array;
+                                validatorIndex?: number;
+                                signature?: Uint8Array;
+                            };
+                            totalVotingPower?: any;
+                            validatorPower?: any;
+                            timestamp?: Date;
+                        };
+                        lightClientAttackEvidence?: {
+                            conflictingBlock?: {
+                                signedHeader?: {
+                                    header?: {
+                                        version?: {
+                                            block?: any;
+                                            app?: any;
+                                        };
+                                        chainId?: string;
+                                        height?: any;
+                                        time?: Date;
+                                        lastBlockId?: {
+                                            hash?: Uint8Array;
+                                            partSetHeader?: {
+                                                total?: number;
+                                                hash?: Uint8Array;
+                                            };
+                                        };
+                                        lastCommitHash?: Uint8Array;
+                                        dataHash?: Uint8Array;
+                                        validatorsHash?: Uint8Array;
+                                        nextValidatorsHash?: Uint8Array;
+                                        consensusHash?: Uint8Array;
+                                        appHash?: Uint8Array;
+                                        lastResultsHash?: Uint8Array;
+                                        evidenceHash?: Uint8Array;
+                                        proposerAddress?: Uint8Array;
+                                    };
+                                    commit?: {
+                                        height?: any;
+                                        round?: number;
+                                        blockId?: {
+                                            hash?: Uint8Array;
+                                            partSetHeader?: {
+                                                total?: number;
+                                                hash?: Uint8Array;
+                                            };
+                                        };
+                                        signatures?: {
+                                            blockIdFlag?: _146.BlockIDFlag;
+                                            validatorAddress?: Uint8Array;
+                                            timestamp?: Date;
+                                            signature?: Uint8Array;
+                                        }[];
+                                    };
+                                };
+                                validatorSet?: {
+                                    validators?: {
+                                        address?: Uint8Array;
+                                        pubKey?: {
+                                            ed25519?: Uint8Array;
+                                            secp256k1?: Uint8Array;
+                                        };
+                                        votingPower?: any;
+                                        proposerPriority?: any;
+                                    }[];
+                                    proposer?: {
+                                        address?: Uint8Array;
+                                        pubKey?: {
+                                            ed25519?: Uint8Array;
+                                            secp256k1?: Uint8Array;
+                                        };
+                                        votingPower?: any;
+                                        proposerPriority?: any;
+                                    };
+                                    totalVotingPower?: any;
+                                };
+                            };
+                            commonHeight?: any;
+                            byzantineValidators?: {
+                                address?: Uint8Array;
+                                pubKey?: {
+                                    ed25519?: Uint8Array;
+                                    secp256k1?: Uint8Array;
+                                };
+                                votingPower?: any;
+                                proposerPriority?: any;
+                            }[];
+                            totalVotingPower?: any;
+                            timestamp?: Date;
+                        };
+                    }[];
+                };
+                lastCommit?: {
+                    height?: any;
+                    round?: number;
+                    blockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    signatures?: {
+                        blockIdFlag?: _146.BlockIDFlag;
+                        validatorAddress?: Uint8Array;
+                        timestamp?: Date;
+                        signature?: Uint8Array;
+                    }[];
+                };
+            }): _143.Block;
+        };
+    };
+    const version: {
+        App: {
+            encode(message: _148.App, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _148.App;
+            fromJSON(object: any): _148.App;
+            toJSON(message: _148.App): unknown;
+            fromPartial(object: {
+                protocol?: any;
+                software?: string;
+            }): _148.App;
+        };
+        Consensus: {
+            encode(message: _148.Consensus, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _148.Consensus;
+            fromJSON(object: any): _148.Consensus;
+            toJSON(message: _148.Consensus): unknown;
+            fromPartial(object: {
+                block?: any;
+                app?: any;
+            }): _148.Consensus;
+        };
+    };
+}