juno-network 0.7.0 → 0.9.0

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

@@ -0,0 +1,2065 @@
+import * as _82 from "./abci/types";
+import * as _83 from "./crypto/keys";
+import * as _84 from "./crypto/proof";
+import * as _85 from "./libs/bits/types";
+import * as _86 from "./p2p/types";
+import * as _87 from "./types/block";
+import * as _88 from "./types/evidence";
+import * as _89 from "./types/params";
+import * as _90 from "./types/types";
+import * as _91 from "./types/validator";
+import * as _92 from "./version/types";
+export declare namespace tendermint {
+    const abci: {
+        checkTxTypeFromJSON(object: any): _82.CheckTxType;
+        checkTxTypeToJSON(object: _82.CheckTxType): string;
+        responseOfferSnapshot_ResultFromJSON(object: any): _82.ResponseOfferSnapshot_Result;
+        responseOfferSnapshot_ResultToJSON(object: _82.ResponseOfferSnapshot_Result): string;
+        responseApplySnapshotChunk_ResultFromJSON(object: any): _82.ResponseApplySnapshotChunk_Result;
+        responseApplySnapshotChunk_ResultToJSON(object: _82.ResponseApplySnapshotChunk_Result): string;
+        evidenceTypeFromJSON(object: any): _82.EvidenceType;
+        evidenceTypeToJSON(object: _82.EvidenceType): string;
+        CheckTxType: typeof _82.CheckTxType;
+        CheckTxTypeSDKType: typeof _82.CheckTxTypeSDKType;
+        ResponseOfferSnapshot_Result: typeof _82.ResponseOfferSnapshot_Result;
+        ResponseOfferSnapshot_ResultSDKType: typeof _82.ResponseOfferSnapshot_ResultSDKType;
+        ResponseApplySnapshotChunk_Result: typeof _82.ResponseApplySnapshotChunk_Result;
+        ResponseApplySnapshotChunk_ResultSDKType: typeof _82.ResponseApplySnapshotChunk_ResultSDKType;
+        EvidenceType: typeof _82.EvidenceType;
+        EvidenceTypeSDKType: typeof _82.EvidenceTypeSDKType;
+        Request: {
+            encode(message: _82.Request, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.Request;
+            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?: _82.EvidenceType;
+                        validator?: {
+                            address?: Uint8Array;
+                            power?: any;
+                        };
+                        height?: any;
+                        time?: Date;
+                        totalVotingPower?: any;
+                    }[];
+                };
+                checkTx?: {
+                    tx?: Uint8Array;
+                    type?: _82.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;
+                };
+            }): _82.Request;
+        };
+        RequestEcho: {
+            encode(message: _82.RequestEcho, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestEcho;
+            fromPartial(object: {
+                message?: string;
+            }): _82.RequestEcho;
+        };
+        RequestFlush: {
+            encode(_: _82.RequestFlush, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestFlush;
+            fromPartial(_: {}): _82.RequestFlush;
+        };
+        RequestInfo: {
+            encode(message: _82.RequestInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestInfo;
+            fromPartial(object: {
+                version?: string;
+                blockVersion?: any;
+                p2pVersion?: any;
+            }): _82.RequestInfo;
+        };
+        RequestSetOption: {
+            encode(message: _82.RequestSetOption, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestSetOption;
+            fromPartial(object: {
+                key?: string;
+                value?: string;
+            }): _82.RequestSetOption;
+        };
+        RequestInitChain: {
+            encode(message: _82.RequestInitChain, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestInitChain;
+            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;
+            }): _82.RequestInitChain;
+        };
+        RequestQuery: {
+            encode(message: _82.RequestQuery, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestQuery;
+            fromPartial(object: {
+                data?: Uint8Array;
+                path?: string;
+                height?: any;
+                prove?: boolean;
+            }): _82.RequestQuery;
+        };
+        RequestBeginBlock: {
+            encode(message: _82.RequestBeginBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestBeginBlock;
+            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?: _82.EvidenceType;
+                    validator?: {
+                        address?: Uint8Array;
+                        power?: any;
+                    };
+                    height?: any;
+                    time?: Date;
+                    totalVotingPower?: any;
+                }[];
+            }): _82.RequestBeginBlock;
+        };
+        RequestCheckTx: {
+            encode(message: _82.RequestCheckTx, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestCheckTx;
+            fromPartial(object: {
+                tx?: Uint8Array;
+                type?: _82.CheckTxType;
+            }): _82.RequestCheckTx;
+        };
+        RequestDeliverTx: {
+            encode(message: _82.RequestDeliverTx, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestDeliverTx;
+            fromPartial(object: {
+                tx?: Uint8Array;
+            }): _82.RequestDeliverTx;
+        };
+        RequestEndBlock: {
+            encode(message: _82.RequestEndBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestEndBlock;
+            fromPartial(object: {
+                height?: any;
+            }): _82.RequestEndBlock;
+        };
+        RequestCommit: {
+            encode(_: _82.RequestCommit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestCommit;
+            fromPartial(_: {}): _82.RequestCommit;
+        };
+        RequestListSnapshots: {
+            encode(_: _82.RequestListSnapshots, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestListSnapshots;
+            fromPartial(_: {}): _82.RequestListSnapshots;
+        };
+        RequestOfferSnapshot: {
+            encode(message: _82.RequestOfferSnapshot, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestOfferSnapshot;
+            fromPartial(object: {
+                snapshot?: {
+                    height?: any;
+                    format?: number;
+                    chunks?: number;
+                    hash?: Uint8Array;
+                    metadata?: Uint8Array;
+                };
+                appHash?: Uint8Array;
+            }): _82.RequestOfferSnapshot;
+        };
+        RequestLoadSnapshotChunk: {
+            encode(message: _82.RequestLoadSnapshotChunk, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestLoadSnapshotChunk;
+            fromPartial(object: {
+                height?: any;
+                format?: number;
+                chunk?: number;
+            }): _82.RequestLoadSnapshotChunk;
+        };
+        RequestApplySnapshotChunk: {
+            encode(message: _82.RequestApplySnapshotChunk, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.RequestApplySnapshotChunk;
+            fromPartial(object: {
+                index?: number;
+                chunk?: Uint8Array;
+                sender?: string;
+            }): _82.RequestApplySnapshotChunk;
+        };
+        Response: {
+            encode(message: _82.Response, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.Response;
+            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?: _82.ResponseOfferSnapshot_Result;
+                };
+                loadSnapshotChunk?: {
+                    chunk?: Uint8Array;
+                };
+                applySnapshotChunk?: {
+                    result?: _82.ResponseApplySnapshotChunk_Result;
+                    refetchChunks?: number[];
+                    rejectSenders?: string[];
+                };
+            }): _82.Response;
+        };
+        ResponseException: {
+            encode(message: _82.ResponseException, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseException;
+            fromPartial(object: {
+                error?: string;
+            }): _82.ResponseException;
+        };
+        ResponseEcho: {
+            encode(message: _82.ResponseEcho, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseEcho;
+            fromPartial(object: {
+                message?: string;
+            }): _82.ResponseEcho;
+        };
+        ResponseFlush: {
+            encode(_: _82.ResponseFlush, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseFlush;
+            fromPartial(_: {}): _82.ResponseFlush;
+        };
+        ResponseInfo: {
+            encode(message: _82.ResponseInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseInfo;
+            fromPartial(object: {
+                data?: string;
+                version?: string;
+                appVersion?: any;
+                lastBlockHeight?: any;
+                lastBlockAppHash?: Uint8Array;
+            }): _82.ResponseInfo;
+        };
+        ResponseSetOption: {
+            encode(message: _82.ResponseSetOption, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseSetOption;
+            fromPartial(object: {
+                code?: number;
+                log?: string;
+                info?: string;
+            }): _82.ResponseSetOption;
+        };
+        ResponseInitChain: {
+            encode(message: _82.ResponseInitChain, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseInitChain;
+            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;
+            }): _82.ResponseInitChain;
+        };
+        ResponseQuery: {
+            encode(message: _82.ResponseQuery, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseQuery;
+            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;
+            }): _82.ResponseQuery;
+        };
+        ResponseBeginBlock: {
+            encode(message: _82.ResponseBeginBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseBeginBlock;
+            fromPartial(object: {
+                events?: {
+                    type?: string;
+                    attributes?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                        index?: boolean;
+                    }[];
+                }[];
+            }): _82.ResponseBeginBlock;
+        };
+        ResponseCheckTx: {
+            encode(message: _82.ResponseCheckTx, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseCheckTx;
+            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;
+            }): _82.ResponseCheckTx;
+        };
+        ResponseDeliverTx: {
+            encode(message: _82.ResponseDeliverTx, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseDeliverTx;
+            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;
+            }): _82.ResponseDeliverTx;
+        };
+        ResponseEndBlock: {
+            encode(message: _82.ResponseEndBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseEndBlock;
+            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;
+                    }[];
+                }[];
+            }): _82.ResponseEndBlock;
+        };
+        ResponseCommit: {
+            encode(message: _82.ResponseCommit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseCommit;
+            fromPartial(object: {
+                data?: Uint8Array;
+                retainHeight?: any;
+            }): _82.ResponseCommit;
+        };
+        ResponseListSnapshots: {
+            encode(message: _82.ResponseListSnapshots, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseListSnapshots;
+            fromPartial(object: {
+                snapshots?: {
+                    height?: any;
+                    format?: number;
+                    chunks?: number;
+                    hash?: Uint8Array;
+                    metadata?: Uint8Array;
+                }[];
+            }): _82.ResponseListSnapshots;
+        };
+        ResponseOfferSnapshot: {
+            encode(message: _82.ResponseOfferSnapshot, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseOfferSnapshot;
+            fromPartial(object: {
+                result?: _82.ResponseOfferSnapshot_Result;
+            }): _82.ResponseOfferSnapshot;
+        };
+        ResponseLoadSnapshotChunk: {
+            encode(message: _82.ResponseLoadSnapshotChunk, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseLoadSnapshotChunk;
+            fromPartial(object: {
+                chunk?: Uint8Array;
+            }): _82.ResponseLoadSnapshotChunk;
+        };
+        ResponseApplySnapshotChunk: {
+            encode(message: _82.ResponseApplySnapshotChunk, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ResponseApplySnapshotChunk;
+            fromPartial(object: {
+                result?: _82.ResponseApplySnapshotChunk_Result;
+                refetchChunks?: number[];
+                rejectSenders?: string[];
+            }): _82.ResponseApplySnapshotChunk;
+        };
+        ConsensusParams: {
+            encode(message: _82.ConsensusParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ConsensusParams;
+            fromPartial(object: {
+                block?: {
+                    maxBytes?: any;
+                    maxGas?: any;
+                };
+                evidence?: {
+                    maxAgeNumBlocks?: any;
+                    maxAgeDuration?: {
+                        seconds?: any;
+                        nanos?: number;
+                    };
+                    maxBytes?: any;
+                };
+                validator?: {
+                    pubKeyTypes?: string[];
+                };
+                version?: {
+                    appVersion?: any;
+                };
+            }): _82.ConsensusParams;
+        };
+        BlockParams: {
+            encode(message: _82.BlockParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.BlockParams;
+            fromPartial(object: {
+                maxBytes?: any;
+                maxGas?: any;
+            }): _82.BlockParams;
+        };
+        LastCommitInfo: {
+            encode(message: _82.LastCommitInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.LastCommitInfo;
+            fromPartial(object: {
+                round?: number;
+                votes?: {
+                    validator?: {
+                        address?: Uint8Array;
+                        power?: any;
+                    };
+                    signedLastBlock?: boolean;
+                }[];
+            }): _82.LastCommitInfo;
+        };
+        Event: {
+            encode(message: _82.Event, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.Event;
+            fromPartial(object: {
+                type?: string;
+                attributes?: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                    index?: boolean;
+                }[];
+            }): _82.Event;
+        };
+        EventAttribute: {
+            encode(message: _82.EventAttribute, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.EventAttribute;
+            fromPartial(object: {
+                key?: Uint8Array;
+                value?: Uint8Array;
+                index?: boolean;
+            }): _82.EventAttribute;
+        };
+        TxResult: {
+            encode(message: _82.TxResult, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.TxResult;
+            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;
+                };
+            }): _82.TxResult;
+        };
+        Validator: {
+            encode(message: _82.Validator, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.Validator;
+            fromPartial(object: {
+                address?: Uint8Array;
+                power?: any;
+            }): _82.Validator;
+        };
+        ValidatorUpdate: {
+            encode(message: _82.ValidatorUpdate, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.ValidatorUpdate;
+            fromPartial(object: {
+                pubKey?: {
+                    ed25519?: Uint8Array;
+                    secp256k1?: Uint8Array;
+                };
+                power?: any;
+            }): _82.ValidatorUpdate;
+        };
+        VoteInfo: {
+            encode(message: _82.VoteInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.VoteInfo;
+            fromPartial(object: {
+                validator?: {
+                    address?: Uint8Array;
+                    power?: any;
+                };
+                signedLastBlock?: boolean;
+            }): _82.VoteInfo;
+        };
+        Evidence: {
+            encode(message: _82.Evidence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.Evidence;
+            fromPartial(object: {
+                type?: _82.EvidenceType;
+                validator?: {
+                    address?: Uint8Array;
+                    power?: any;
+                };
+                height?: any;
+                time?: Date;
+                totalVotingPower?: any;
+            }): _82.Evidence;
+        };
+        Snapshot: {
+            encode(message: _82.Snapshot, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _82.Snapshot;
+            fromPartial(object: {
+                height?: any;
+                format?: number;
+                chunks?: number;
+                hash?: Uint8Array;
+                metadata?: Uint8Array;
+            }): _82.Snapshot;
+        };
+    };
+    const crypto: {
+        Proof: {
+            encode(message: _84.Proof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _84.Proof;
+            fromPartial(object: {
+                total?: any;
+                index?: any;
+                leafHash?: Uint8Array;
+                aunts?: Uint8Array[];
+            }): _84.Proof;
+        };
+        ValueOp: {
+            encode(message: _84.ValueOp, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _84.ValueOp;
+            fromPartial(object: {
+                key?: Uint8Array;
+                proof?: {
+                    total?: any;
+                    index?: any;
+                    leafHash?: Uint8Array;
+                    aunts?: Uint8Array[];
+                };
+            }): _84.ValueOp;
+        };
+        DominoOp: {
+            encode(message: _84.DominoOp, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _84.DominoOp;
+            fromPartial(object: {
+                key?: string;
+                input?: string;
+                output?: string;
+            }): _84.DominoOp;
+        };
+        ProofOp: {
+            encode(message: _84.ProofOp, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _84.ProofOp;
+            fromPartial(object: {
+                type?: string;
+                key?: Uint8Array;
+                data?: Uint8Array;
+            }): _84.ProofOp;
+        };
+        ProofOps: {
+            encode(message: _84.ProofOps, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _84.ProofOps;
+            fromPartial(object: {
+                ops?: {
+                    type?: string;
+                    key?: Uint8Array;
+                    data?: Uint8Array;
+                }[];
+            }): _84.ProofOps;
+        };
+        PublicKey: {
+            encode(message: _83.PublicKey, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _83.PublicKey;
+            fromPartial(object: {
+                ed25519?: Uint8Array;
+                secp256k1?: Uint8Array;
+            }): _83.PublicKey;
+        };
+    };
+    namespace libs {
+        const bits: {
+            BitArray: {
+                encode(message: _85.BitArray, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _85.BitArray;
+                fromPartial(object: {
+                    bits?: any;
+                    elems?: any[];
+                }): _85.BitArray;
+            };
+        };
+    }
+    const p2p: {
+        ProtocolVersion: {
+            encode(message: _86.ProtocolVersion, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _86.ProtocolVersion;
+            fromPartial(object: {
+                p2p?: any;
+                block?: any;
+                app?: any;
+            }): _86.ProtocolVersion;
+        };
+        NodeInfo: {
+            encode(message: _86.NodeInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _86.NodeInfo;
+            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;
+                };
+            }): _86.NodeInfo;
+        };
+        NodeInfoOther: {
+            encode(message: _86.NodeInfoOther, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _86.NodeInfoOther;
+            fromPartial(object: {
+                txIndex?: string;
+                rpcAddress?: string;
+            }): _86.NodeInfoOther;
+        };
+        PeerInfo: {
+            encode(message: _86.PeerInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _86.PeerInfo;
+            fromPartial(object: {
+                id?: string;
+                addressInfo?: {
+                    address?: string;
+                    lastDialSuccess?: Date;
+                    lastDialFailure?: Date;
+                    dialFailures?: number;
+                }[];
+                lastConnected?: Date;
+            }): _86.PeerInfo;
+        };
+        PeerAddressInfo: {
+            encode(message: _86.PeerAddressInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _86.PeerAddressInfo;
+            fromPartial(object: {
+                address?: string;
+                lastDialSuccess?: Date;
+                lastDialFailure?: Date;
+                dialFailures?: number;
+            }): _86.PeerAddressInfo;
+        };
+    };
+    const types: {
+        ValidatorSet: {
+            encode(message: _91.ValidatorSet, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _91.ValidatorSet;
+            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;
+            }): _91.ValidatorSet;
+        };
+        Validator: {
+            encode(message: _91.Validator, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _91.Validator;
+            fromPartial(object: {
+                address?: Uint8Array;
+                pubKey?: {
+                    ed25519?: Uint8Array;
+                    secp256k1?: Uint8Array;
+                };
+                votingPower?: any;
+                proposerPriority?: any;
+            }): _91.Validator;
+        };
+        SimpleValidator: {
+            encode(message: _91.SimpleValidator, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _91.SimpleValidator;
+            fromPartial(object: {
+                pubKey?: {
+                    ed25519?: Uint8Array;
+                    secp256k1?: Uint8Array;
+                };
+                votingPower?: any;
+            }): _91.SimpleValidator;
+        };
+        blockIDFlagFromJSON(object: any): _90.BlockIDFlag;
+        blockIDFlagToJSON(object: _90.BlockIDFlag): string;
+        signedMsgTypeFromJSON(object: any): _90.SignedMsgType;
+        signedMsgTypeToJSON(object: _90.SignedMsgType): string;
+        BlockIDFlag: typeof _90.BlockIDFlag;
+        BlockIDFlagSDKType: typeof _90.BlockIDFlagSDKType;
+        SignedMsgType: typeof _90.SignedMsgType;
+        SignedMsgTypeSDKType: typeof _90.SignedMsgTypeSDKType;
+        PartSetHeader: {
+            encode(message: _90.PartSetHeader, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.PartSetHeader;
+            fromPartial(object: {
+                total?: number;
+                hash?: Uint8Array;
+            }): _90.PartSetHeader;
+        };
+        Part: {
+            encode(message: _90.Part, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.Part;
+            fromPartial(object: {
+                index?: number;
+                bytes?: Uint8Array;
+                proof?: {
+                    total?: any;
+                    index?: any;
+                    leafHash?: Uint8Array;
+                    aunts?: Uint8Array[];
+                };
+            }): _90.Part;
+        };
+        BlockID: {
+            encode(message: _90.BlockID, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.BlockID;
+            fromPartial(object: {
+                hash?: Uint8Array;
+                partSetHeader?: {
+                    total?: number;
+                    hash?: Uint8Array;
+                };
+            }): _90.BlockID;
+        };
+        Header: {
+            encode(message: _90.Header, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.Header;
+            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;
+            }): _90.Header;
+        };
+        Data: {
+            encode(message: _90.Data, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.Data;
+            fromPartial(object: {
+                txs?: Uint8Array[];
+            }): _90.Data;
+        };
+        Vote: {
+            encode(message: _90.Vote, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.Vote;
+            fromPartial(object: {
+                type?: _90.SignedMsgType;
+                height?: any;
+                round?: number;
+                blockId?: {
+                    hash?: Uint8Array;
+                    partSetHeader?: {
+                        total?: number;
+                        hash?: Uint8Array;
+                    };
+                };
+                timestamp?: Date;
+                validatorAddress?: Uint8Array;
+                validatorIndex?: number;
+                signature?: Uint8Array;
+            }): _90.Vote;
+        };
+        Commit: {
+            encode(message: _90.Commit, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.Commit;
+            fromPartial(object: {
+                height?: any;
+                round?: number;
+                blockId?: {
+                    hash?: Uint8Array;
+                    partSetHeader?: {
+                        total?: number;
+                        hash?: Uint8Array;
+                    };
+                };
+                signatures?: {
+                    blockIdFlag?: _90.BlockIDFlag;
+                    validatorAddress?: Uint8Array;
+                    timestamp?: Date;
+                    signature?: Uint8Array;
+                }[];
+            }): _90.Commit;
+        };
+        CommitSig: {
+            encode(message: _90.CommitSig, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.CommitSig;
+            fromPartial(object: {
+                blockIdFlag?: _90.BlockIDFlag;
+                validatorAddress?: Uint8Array;
+                timestamp?: Date;
+                signature?: Uint8Array;
+            }): _90.CommitSig;
+        };
+        Proposal: {
+            encode(message: _90.Proposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.Proposal;
+            fromPartial(object: {
+                type?: _90.SignedMsgType;
+                height?: any;
+                round?: number;
+                polRound?: number;
+                blockId?: {
+                    hash?: Uint8Array;
+                    partSetHeader?: {
+                        total?: number;
+                        hash?: Uint8Array;
+                    };
+                };
+                timestamp?: Date;
+                signature?: Uint8Array;
+            }): _90.Proposal;
+        };
+        SignedHeader: {
+            encode(message: _90.SignedHeader, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.SignedHeader;
+            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?: _90.BlockIDFlag;
+                        validatorAddress?: Uint8Array;
+                        timestamp?: Date;
+                        signature?: Uint8Array;
+                    }[];
+                };
+            }): _90.SignedHeader;
+        };
+        LightBlock: {
+            encode(message: _90.LightBlock, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.LightBlock;
+            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?: _90.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;
+                };
+            }): _90.LightBlock;
+        };
+        BlockMeta: {
+            encode(message: _90.BlockMeta, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.BlockMeta;
+            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;
+            }): _90.BlockMeta;
+        };
+        TxProof: {
+            encode(message: _90.TxProof, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _90.TxProof;
+            fromPartial(object: {
+                rootHash?: Uint8Array;
+                data?: Uint8Array;
+                proof?: {
+                    total?: any;
+                    index?: any;
+                    leafHash?: Uint8Array;
+                    aunts?: Uint8Array[];
+                };
+            }): _90.TxProof;
+        };
+        ConsensusParams: {
+            encode(message: _89.ConsensusParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _89.ConsensusParams;
+            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;
+                };
+            }): _89.ConsensusParams;
+        };
+        BlockParams: {
+            encode(message: _89.BlockParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _89.BlockParams;
+            fromPartial(object: {
+                maxBytes?: any;
+                maxGas?: any;
+                timeIotaMs?: any;
+            }): _89.BlockParams;
+        };
+        EvidenceParams: {
+            encode(message: _89.EvidenceParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _89.EvidenceParams;
+            fromPartial(object: {
+                maxAgeNumBlocks?: any;
+                maxAgeDuration?: {
+                    seconds?: any;
+                    nanos?: number;
+                };
+                maxBytes?: any;
+            }): _89.EvidenceParams;
+        };
+        ValidatorParams: {
+            encode(message: _89.ValidatorParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _89.ValidatorParams;
+            fromPartial(object: {
+                pubKeyTypes?: string[];
+            }): _89.ValidatorParams;
+        };
+        VersionParams: {
+            encode(message: _89.VersionParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _89.VersionParams;
+            fromPartial(object: {
+                appVersion?: any;
+            }): _89.VersionParams;
+        };
+        HashedParams: {
+            encode(message: _89.HashedParams, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _89.HashedParams;
+            fromPartial(object: {
+                blockMaxBytes?: any;
+                blockMaxGas?: any;
+            }): _89.HashedParams;
+        };
+        Evidence: {
+            encode(message: _88.Evidence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _88.Evidence;
+            fromPartial(object: {
+                duplicateVoteEvidence?: {
+                    voteA?: {
+                        type?: _90.SignedMsgType;
+                        height?: any;
+                        round?: number;
+                        blockId?: {
+                            hash?: Uint8Array;
+                            partSetHeader?: {
+                                total?: number;
+                                hash?: Uint8Array;
+                            };
+                        };
+                        timestamp?: Date;
+                        validatorAddress?: Uint8Array;
+                        validatorIndex?: number;
+                        signature?: Uint8Array;
+                    };
+                    voteB?: {
+                        type?: _90.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?: _90.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;
+                };
+            }): _88.Evidence;
+        };
+        DuplicateVoteEvidence: {
+            encode(message: _88.DuplicateVoteEvidence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _88.DuplicateVoteEvidence;
+            fromPartial(object: {
+                voteA?: {
+                    type?: _90.SignedMsgType;
+                    height?: any;
+                    round?: number;
+                    blockId?: {
+                        hash?: Uint8Array;
+                        partSetHeader?: {
+                            total?: number;
+                            hash?: Uint8Array;
+                        };
+                    };
+                    timestamp?: Date;
+                    validatorAddress?: Uint8Array;
+                    validatorIndex?: number;
+                    signature?: Uint8Array;
+                };
+                voteB?: {
+                    type?: _90.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;
+            }): _88.DuplicateVoteEvidence;
+        };
+        LightClientAttackEvidence: {
+            encode(message: _88.LightClientAttackEvidence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _88.LightClientAttackEvidence;
+            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?: _90.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;
+            }): _88.LightClientAttackEvidence;
+        };
+        EvidenceList: {
+            encode(message: _88.EvidenceList, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _88.EvidenceList;
+            fromPartial(object: {
+                evidence?: {
+                    duplicateVoteEvidence?: {
+                        voteA?: {
+                            type?: _90.SignedMsgType;
+                            height?: any;
+                            round?: number;
+                            blockId?: {
+                                hash?: Uint8Array;
+                                partSetHeader?: {
+                                    total?: number;
+                                    hash?: Uint8Array;
+                                };
+                            };
+                            timestamp?: Date;
+                            validatorAddress?: Uint8Array;
+                            validatorIndex?: number;
+                            signature?: Uint8Array;
+                        };
+                        voteB?: {
+                            type?: _90.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?: _90.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;
+                    };
+                }[];
+            }): _88.EvidenceList;
+        };
+        Block: {
+            encode(message: _87.Block, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _87.Block;
+            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?: _90.SignedMsgType;
+                                height?: any;
+                                round?: number;
+                                blockId?: {
+                                    hash?: Uint8Array;
+                                    partSetHeader?: {
+                                        total?: number;
+                                        hash?: Uint8Array;
+                                    };
+                                };
+                                timestamp?: Date;
+                                validatorAddress?: Uint8Array;
+                                validatorIndex?: number;
+                                signature?: Uint8Array;
+                            };
+                            voteB?: {
+                                type?: _90.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?: _90.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?: _90.BlockIDFlag;
+                        validatorAddress?: Uint8Array;
+                        timestamp?: Date;
+                        signature?: Uint8Array;
+                    }[];
+                };
+            }): _87.Block;
+        };
+    };
+    const version: {
+        App: {
+            encode(message: _92.App, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _92.App;
+            fromPartial(object: {
+                protocol?: any;
+                software?: string;
+            }): _92.App;
+        };
+        Consensus: {
+            encode(message: _92.Consensus, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+            decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _92.Consensus;
+            fromPartial(object: {
+                block?: any;
+                app?: any;
+            }): _92.Consensus;
+        };
+    };
+}