@agoric/cosmic-proto 0.4.1-orchestration-dev-096c4e8.0 → 0.4.1-upgrade-16-fi-dev-8879538.0

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

@@ -0,0 +1,986 @@
+import * as _124 from './abci/types.js';
+import * as _125 from './crypto/keys.js';
+import * as _126 from './crypto/proof.js';
+import * as _127 from './libs/bits/types.js';
+import * as _128 from './p2p/types.js';
+import * as _129 from './types/block.js';
+import * as _130 from './types/evidence.js';
+import * as _131 from './types/params.js';
+import * as _132 from './types/types.js';
+import * as _133 from './types/validator.js';
+import * as _134 from './version/types.js';
+export declare namespace tendermint {
+    const abci: {
+        checkTxTypeFromJSON(object: any): _124.CheckTxType;
+        checkTxTypeToJSON(object: CheckTxType): string;
+        responseOfferSnapshot_ResultFromJSON(object: any): _124.ResponseOfferSnapshot_Result;
+        responseOfferSnapshot_ResultToJSON(object: ResponseOfferSnapshot_Result): string;
+        responseApplySnapshotChunk_ResultFromJSON(object: any): _124.ResponseApplySnapshotChunk_Result;
+        responseApplySnapshotChunk_ResultToJSON(object: ResponseApplySnapshotChunk_Result): string;
+        evidenceTypeFromJSON(object: any): _124.EvidenceType;
+        evidenceTypeToJSON(object: EvidenceType): string;
+        CheckTxType: typeof _124.CheckTxType;
+        CheckTxTypeSDKType: typeof _124.CheckTxType;
+        ResponseOfferSnapshot_Result: typeof _124.ResponseOfferSnapshot_Result;
+        ResponseOfferSnapshot_ResultSDKType: typeof _124.ResponseOfferSnapshot_Result;
+        ResponseApplySnapshotChunk_Result: typeof _124.ResponseApplySnapshotChunk_Result;
+        ResponseApplySnapshotChunk_ResultSDKType: typeof _124.ResponseApplySnapshotChunk_Result;
+        EvidenceType: typeof _124.EvidenceType;
+        EvidenceTypeSDKType: typeof _124.EvidenceType;
+        Request: {
+            typeUrl: string;
+            encode(message: Request, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.Request;
+            fromJSON(object: any): _124.Request;
+            toJSON(message: Request): import("../json-safe.js").JsonSafe<_124.Request>;
+            fromPartial(object: Partial<Request>): _124.Request;
+            fromProtoMsg(message: RequestProtoMsg): _124.Request;
+            toProto(message: Request): Uint8Array;
+            toProtoMsg(message: Request): _124.RequestProtoMsg;
+        };
+        RequestEcho: {
+            typeUrl: string;
+            encode(message: RequestEcho, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestEcho;
+            fromJSON(object: any): _124.RequestEcho;
+            toJSON(message: RequestEcho): import("../json-safe.js").JsonSafe<_124.RequestEcho>;
+            fromPartial(object: Partial<RequestEcho>): _124.RequestEcho;
+            fromProtoMsg(message: RequestEchoProtoMsg): _124.RequestEcho;
+            toProto(message: RequestEcho): Uint8Array;
+            toProtoMsg(message: RequestEcho): _124.RequestEchoProtoMsg;
+        };
+        RequestFlush: {
+            typeUrl: string;
+            encode(_: RequestFlush, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestFlush;
+            fromJSON(_: any): _124.RequestFlush;
+            toJSON(_: RequestFlush): import("../json-safe.js").JsonSafe<_124.RequestFlush>;
+            fromPartial(_: Partial<RequestFlush>): _124.RequestFlush;
+            fromProtoMsg(message: RequestFlushProtoMsg): _124.RequestFlush;
+            toProto(message: RequestFlush): Uint8Array;
+            toProtoMsg(message: RequestFlush): _124.RequestFlushProtoMsg;
+        };
+        RequestInfo: {
+            typeUrl: string;
+            encode(message: RequestInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestInfo;
+            fromJSON(object: any): _124.RequestInfo;
+            toJSON(message: RequestInfo): import("../json-safe.js").JsonSafe<_124.RequestInfo>;
+            fromPartial(object: Partial<RequestInfo>): _124.RequestInfo;
+            fromProtoMsg(message: RequestInfoProtoMsg): _124.RequestInfo;
+            toProto(message: RequestInfo): Uint8Array;
+            toProtoMsg(message: RequestInfo): _124.RequestInfoProtoMsg;
+        };
+        RequestSetOption: {
+            typeUrl: string;
+            encode(message: RequestSetOption, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestSetOption;
+            fromJSON(object: any): _124.RequestSetOption;
+            toJSON(message: RequestSetOption): import("../json-safe.js").JsonSafe<_124.RequestSetOption>;
+            fromPartial(object: Partial<RequestSetOption>): _124.RequestSetOption;
+            fromProtoMsg(message: RequestSetOptionProtoMsg): _124.RequestSetOption;
+            toProto(message: RequestSetOption): Uint8Array;
+            toProtoMsg(message: RequestSetOption): _124.RequestSetOptionProtoMsg;
+        };
+        RequestInitChain: {
+            typeUrl: string;
+            encode(message: RequestInitChain, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestInitChain;
+            fromJSON(object: any): _124.RequestInitChain;
+            toJSON(message: RequestInitChain): import("../json-safe.js").JsonSafe<_124.RequestInitChain>;
+            fromPartial(object: Partial<RequestInitChain>): _124.RequestInitChain;
+            fromProtoMsg(message: RequestInitChainProtoMsg): _124.RequestInitChain;
+            toProto(message: RequestInitChain): Uint8Array;
+            toProtoMsg(message: RequestInitChain): _124.RequestInitChainProtoMsg;
+        };
+        RequestQuery: {
+            typeUrl: string;
+            encode(message: RequestQuery, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestQuery;
+            fromJSON(object: any): _124.RequestQuery;
+            toJSON(message: RequestQuery): import("../json-safe.js").JsonSafe<_124.RequestQuery>;
+            fromPartial(object: Partial<RequestQuery>): _124.RequestQuery;
+            fromProtoMsg(message: RequestQueryProtoMsg): _124.RequestQuery;
+            toProto(message: RequestQuery): Uint8Array;
+            toProtoMsg(message: RequestQuery): _124.RequestQueryProtoMsg;
+        };
+        RequestBeginBlock: {
+            typeUrl: string;
+            encode(message: RequestBeginBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestBeginBlock;
+            fromJSON(object: any): _124.RequestBeginBlock;
+            toJSON(message: RequestBeginBlock): import("../json-safe.js").JsonSafe<_124.RequestBeginBlock>;
+            fromPartial(object: Partial<RequestBeginBlock>): _124.RequestBeginBlock;
+            fromProtoMsg(message: RequestBeginBlockProtoMsg): _124.RequestBeginBlock;
+            toProto(message: RequestBeginBlock): Uint8Array;
+            toProtoMsg(message: RequestBeginBlock): _124.RequestBeginBlockProtoMsg;
+        };
+        RequestCheckTx: {
+            typeUrl: string;
+            encode(message: RequestCheckTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestCheckTx;
+            fromJSON(object: any): _124.RequestCheckTx;
+            toJSON(message: RequestCheckTx): import("../json-safe.js").JsonSafe<_124.RequestCheckTx>;
+            fromPartial(object: Partial<RequestCheckTx>): _124.RequestCheckTx;
+            fromProtoMsg(message: RequestCheckTxProtoMsg): _124.RequestCheckTx;
+            toProto(message: RequestCheckTx): Uint8Array;
+            toProtoMsg(message: RequestCheckTx): _124.RequestCheckTxProtoMsg;
+        };
+        RequestDeliverTx: {
+            typeUrl: string;
+            encode(message: RequestDeliverTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestDeliverTx;
+            fromJSON(object: any): _124.RequestDeliverTx;
+            toJSON(message: RequestDeliverTx): import("../json-safe.js").JsonSafe<_124.RequestDeliverTx>;
+            fromPartial(object: Partial<RequestDeliverTx>): _124.RequestDeliverTx;
+            fromProtoMsg(message: RequestDeliverTxProtoMsg): _124.RequestDeliverTx;
+            toProto(message: RequestDeliverTx): Uint8Array;
+            toProtoMsg(message: RequestDeliverTx): _124.RequestDeliverTxProtoMsg;
+        };
+        RequestEndBlock: {
+            typeUrl: string;
+            encode(message: RequestEndBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestEndBlock;
+            fromJSON(object: any): _124.RequestEndBlock;
+            toJSON(message: RequestEndBlock): import("../json-safe.js").JsonSafe<_124.RequestEndBlock>;
+            fromPartial(object: Partial<RequestEndBlock>): _124.RequestEndBlock;
+            fromProtoMsg(message: RequestEndBlockProtoMsg): _124.RequestEndBlock;
+            toProto(message: RequestEndBlock): Uint8Array;
+            toProtoMsg(message: RequestEndBlock): _124.RequestEndBlockProtoMsg;
+        };
+        RequestCommit: {
+            typeUrl: string;
+            encode(_: RequestCommit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestCommit;
+            fromJSON(_: any): _124.RequestCommit;
+            toJSON(_: RequestCommit): import("../json-safe.js").JsonSafe<_124.RequestCommit>;
+            fromPartial(_: Partial<RequestCommit>): _124.RequestCommit;
+            fromProtoMsg(message: RequestCommitProtoMsg): _124.RequestCommit;
+            toProto(message: RequestCommit): Uint8Array;
+            toProtoMsg(message: RequestCommit): _124.RequestCommitProtoMsg;
+        };
+        RequestListSnapshots: {
+            typeUrl: string;
+            encode(_: RequestListSnapshots, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestListSnapshots;
+            fromJSON(_: any): _124.RequestListSnapshots;
+            toJSON(_: RequestListSnapshots): import("../json-safe.js").JsonSafe<_124.RequestListSnapshots>;
+            fromPartial(_: Partial<RequestListSnapshots>): _124.RequestListSnapshots;
+            fromProtoMsg(message: RequestListSnapshotsProtoMsg): _124.RequestListSnapshots;
+            toProto(message: RequestListSnapshots): Uint8Array;
+            toProtoMsg(message: RequestListSnapshots): _124.RequestListSnapshotsProtoMsg;
+        };
+        RequestOfferSnapshot: {
+            typeUrl: string;
+            encode(message: RequestOfferSnapshot, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestOfferSnapshot;
+            fromJSON(object: any): _124.RequestOfferSnapshot;
+            toJSON(message: RequestOfferSnapshot): import("../json-safe.js").JsonSafe<_124.RequestOfferSnapshot>;
+            fromPartial(object: Partial<RequestOfferSnapshot>): _124.RequestOfferSnapshot;
+            fromProtoMsg(message: RequestOfferSnapshotProtoMsg): _124.RequestOfferSnapshot;
+            toProto(message: RequestOfferSnapshot): Uint8Array;
+            toProtoMsg(message: RequestOfferSnapshot): _124.RequestOfferSnapshotProtoMsg;
+        };
+        RequestLoadSnapshotChunk: {
+            typeUrl: string;
+            encode(message: RequestLoadSnapshotChunk, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestLoadSnapshotChunk;
+            fromJSON(object: any): _124.RequestLoadSnapshotChunk;
+            toJSON(message: RequestLoadSnapshotChunk): import("../json-safe.js").JsonSafe<_124.RequestLoadSnapshotChunk>;
+            fromPartial(object: Partial<RequestLoadSnapshotChunk>): _124.RequestLoadSnapshotChunk;
+            fromProtoMsg(message: RequestLoadSnapshotChunkProtoMsg): _124.RequestLoadSnapshotChunk;
+            toProto(message: RequestLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: RequestLoadSnapshotChunk): _124.RequestLoadSnapshotChunkProtoMsg;
+        };
+        RequestApplySnapshotChunk: {
+            typeUrl: string;
+            encode(message: RequestApplySnapshotChunk, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.RequestApplySnapshotChunk;
+            fromJSON(object: any): _124.RequestApplySnapshotChunk;
+            toJSON(message: RequestApplySnapshotChunk): import("../json-safe.js").JsonSafe<_124.RequestApplySnapshotChunk>;
+            fromPartial(object: Partial<RequestApplySnapshotChunk>): _124.RequestApplySnapshotChunk;
+            fromProtoMsg(message: RequestApplySnapshotChunkProtoMsg): _124.RequestApplySnapshotChunk;
+            toProto(message: RequestApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: RequestApplySnapshotChunk): _124.RequestApplySnapshotChunkProtoMsg;
+        };
+        Response: {
+            typeUrl: string;
+            encode(message: Response, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.Response;
+            fromJSON(object: any): _124.Response;
+            toJSON(message: Response): import("../json-safe.js").JsonSafe<_124.Response>;
+            fromPartial(object: Partial<Response>): _124.Response;
+            fromProtoMsg(message: ResponseProtoMsg): _124.Response;
+            toProto(message: Response): Uint8Array;
+            toProtoMsg(message: Response): _124.ResponseProtoMsg;
+        };
+        ResponseException: {
+            typeUrl: string;
+            encode(message: ResponseException, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseException;
+            fromJSON(object: any): _124.ResponseException;
+            toJSON(message: ResponseException): import("../json-safe.js").JsonSafe<_124.ResponseException>;
+            fromPartial(object: Partial<ResponseException>): _124.ResponseException;
+            fromProtoMsg(message: ResponseExceptionProtoMsg): _124.ResponseException;
+            toProto(message: ResponseException): Uint8Array;
+            toProtoMsg(message: ResponseException): _124.ResponseExceptionProtoMsg;
+        };
+        ResponseEcho: {
+            typeUrl: string;
+            encode(message: ResponseEcho, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseEcho;
+            fromJSON(object: any): _124.ResponseEcho;
+            toJSON(message: ResponseEcho): import("../json-safe.js").JsonSafe<_124.ResponseEcho>;
+            fromPartial(object: Partial<ResponseEcho>): _124.ResponseEcho;
+            fromProtoMsg(message: ResponseEchoProtoMsg): _124.ResponseEcho;
+            toProto(message: ResponseEcho): Uint8Array;
+            toProtoMsg(message: ResponseEcho): _124.ResponseEchoProtoMsg;
+        };
+        ResponseFlush: {
+            typeUrl: string;
+            encode(_: ResponseFlush, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseFlush;
+            fromJSON(_: any): _124.ResponseFlush;
+            toJSON(_: ResponseFlush): import("../json-safe.js").JsonSafe<_124.ResponseFlush>;
+            fromPartial(_: Partial<ResponseFlush>): _124.ResponseFlush;
+            fromProtoMsg(message: ResponseFlushProtoMsg): _124.ResponseFlush;
+            toProto(message: ResponseFlush): Uint8Array;
+            toProtoMsg(message: ResponseFlush): _124.ResponseFlushProtoMsg;
+        };
+        ResponseInfo: {
+            typeUrl: string;
+            encode(message: ResponseInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseInfo;
+            fromJSON(object: any): _124.ResponseInfo;
+            toJSON(message: ResponseInfo): import("../json-safe.js").JsonSafe<_124.ResponseInfo>;
+            fromPartial(object: Partial<ResponseInfo>): _124.ResponseInfo;
+            fromProtoMsg(message: ResponseInfoProtoMsg): _124.ResponseInfo;
+            toProto(message: ResponseInfo): Uint8Array;
+            toProtoMsg(message: ResponseInfo): _124.ResponseInfoProtoMsg;
+        };
+        ResponseSetOption: {
+            typeUrl: string;
+            encode(message: ResponseSetOption, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseSetOption;
+            fromJSON(object: any): _124.ResponseSetOption;
+            toJSON(message: ResponseSetOption): import("../json-safe.js").JsonSafe<_124.ResponseSetOption>;
+            fromPartial(object: Partial<ResponseSetOption>): _124.ResponseSetOption;
+            fromProtoMsg(message: ResponseSetOptionProtoMsg): _124.ResponseSetOption;
+            toProto(message: ResponseSetOption): Uint8Array;
+            toProtoMsg(message: ResponseSetOption): _124.ResponseSetOptionProtoMsg;
+        };
+        ResponseInitChain: {
+            typeUrl: string;
+            encode(message: ResponseInitChain, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseInitChain;
+            fromJSON(object: any): _124.ResponseInitChain;
+            toJSON(message: ResponseInitChain): import("../json-safe.js").JsonSafe<_124.ResponseInitChain>;
+            fromPartial(object: Partial<ResponseInitChain>): _124.ResponseInitChain;
+            fromProtoMsg(message: ResponseInitChainProtoMsg): _124.ResponseInitChain;
+            toProto(message: ResponseInitChain): Uint8Array;
+            toProtoMsg(message: ResponseInitChain): _124.ResponseInitChainProtoMsg;
+        };
+        ResponseQuery: {
+            typeUrl: string;
+            encode(message: ResponseQuery, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseQuery;
+            fromJSON(object: any): _124.ResponseQuery;
+            toJSON(message: ResponseQuery): import("../json-safe.js").JsonSafe<_124.ResponseQuery>;
+            fromPartial(object: Partial<ResponseQuery>): _124.ResponseQuery;
+            fromProtoMsg(message: ResponseQueryProtoMsg): _124.ResponseQuery;
+            toProto(message: ResponseQuery): Uint8Array;
+            toProtoMsg(message: ResponseQuery): _124.ResponseQueryProtoMsg;
+        };
+        ResponseBeginBlock: {
+            typeUrl: string;
+            encode(message: ResponseBeginBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseBeginBlock;
+            fromJSON(object: any): _124.ResponseBeginBlock;
+            toJSON(message: ResponseBeginBlock): import("../json-safe.js").JsonSafe<_124.ResponseBeginBlock>;
+            fromPartial(object: Partial<ResponseBeginBlock>): _124.ResponseBeginBlock;
+            fromProtoMsg(message: ResponseBeginBlockProtoMsg): _124.ResponseBeginBlock;
+            toProto(message: ResponseBeginBlock): Uint8Array;
+            toProtoMsg(message: ResponseBeginBlock): _124.ResponseBeginBlockProtoMsg;
+        };
+        ResponseCheckTx: {
+            typeUrl: string;
+            encode(message: ResponseCheckTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseCheckTx;
+            fromJSON(object: any): _124.ResponseCheckTx;
+            toJSON(message: ResponseCheckTx): import("../json-safe.js").JsonSafe<_124.ResponseCheckTx>;
+            fromPartial(object: Partial<ResponseCheckTx>): _124.ResponseCheckTx;
+            fromProtoMsg(message: ResponseCheckTxProtoMsg): _124.ResponseCheckTx;
+            toProto(message: ResponseCheckTx): Uint8Array;
+            toProtoMsg(message: ResponseCheckTx): _124.ResponseCheckTxProtoMsg;
+        };
+        ResponseDeliverTx: {
+            typeUrl: string;
+            encode(message: ResponseDeliverTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseDeliverTx;
+            fromJSON(object: any): _124.ResponseDeliverTx;
+            toJSON(message: ResponseDeliverTx): import("../json-safe.js").JsonSafe<_124.ResponseDeliverTx>;
+            fromPartial(object: Partial<ResponseDeliverTx>): _124.ResponseDeliverTx;
+            fromProtoMsg(message: ResponseDeliverTxProtoMsg): _124.ResponseDeliverTx;
+            toProto(message: ResponseDeliverTx): Uint8Array;
+            toProtoMsg(message: ResponseDeliverTx): _124.ResponseDeliverTxProtoMsg;
+        };
+        ResponseEndBlock: {
+            typeUrl: string;
+            encode(message: ResponseEndBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseEndBlock;
+            fromJSON(object: any): _124.ResponseEndBlock;
+            toJSON(message: ResponseEndBlock): import("../json-safe.js").JsonSafe<_124.ResponseEndBlock>;
+            fromPartial(object: Partial<ResponseEndBlock>): _124.ResponseEndBlock;
+            fromProtoMsg(message: ResponseEndBlockProtoMsg): _124.ResponseEndBlock;
+            toProto(message: ResponseEndBlock): Uint8Array;
+            toProtoMsg(message: ResponseEndBlock): _124.ResponseEndBlockProtoMsg;
+        };
+        ResponseCommit: {
+            typeUrl: string;
+            encode(message: ResponseCommit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseCommit;
+            fromJSON(object: any): _124.ResponseCommit;
+            toJSON(message: ResponseCommit): import("../json-safe.js").JsonSafe<_124.ResponseCommit>;
+            fromPartial(object: Partial<ResponseCommit>): _124.ResponseCommit;
+            fromProtoMsg(message: ResponseCommitProtoMsg): _124.ResponseCommit;
+            toProto(message: ResponseCommit): Uint8Array;
+            toProtoMsg(message: ResponseCommit): _124.ResponseCommitProtoMsg;
+        };
+        ResponseListSnapshots: {
+            typeUrl: string;
+            encode(message: ResponseListSnapshots, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseListSnapshots;
+            fromJSON(object: any): _124.ResponseListSnapshots;
+            toJSON(message: ResponseListSnapshots): import("../json-safe.js").JsonSafe<_124.ResponseListSnapshots>;
+            fromPartial(object: Partial<ResponseListSnapshots>): _124.ResponseListSnapshots;
+            fromProtoMsg(message: ResponseListSnapshotsProtoMsg): _124.ResponseListSnapshots;
+            toProto(message: ResponseListSnapshots): Uint8Array;
+            toProtoMsg(message: ResponseListSnapshots): _124.ResponseListSnapshotsProtoMsg;
+        };
+        ResponseOfferSnapshot: {
+            typeUrl: string;
+            encode(message: ResponseOfferSnapshot, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseOfferSnapshot;
+            fromJSON(object: any): _124.ResponseOfferSnapshot;
+            toJSON(message: ResponseOfferSnapshot): import("../json-safe.js").JsonSafe<_124.ResponseOfferSnapshot>;
+            fromPartial(object: Partial<ResponseOfferSnapshot>): _124.ResponseOfferSnapshot;
+            fromProtoMsg(message: ResponseOfferSnapshotProtoMsg): _124.ResponseOfferSnapshot;
+            toProto(message: ResponseOfferSnapshot): Uint8Array;
+            toProtoMsg(message: ResponseOfferSnapshot): _124.ResponseOfferSnapshotProtoMsg;
+        };
+        ResponseLoadSnapshotChunk: {
+            typeUrl: string;
+            encode(message: ResponseLoadSnapshotChunk, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseLoadSnapshotChunk;
+            fromJSON(object: any): _124.ResponseLoadSnapshotChunk;
+            toJSON(message: ResponseLoadSnapshotChunk): import("../json-safe.js").JsonSafe<_124.ResponseLoadSnapshotChunk>;
+            fromPartial(object: Partial<ResponseLoadSnapshotChunk>): _124.ResponseLoadSnapshotChunk;
+            fromProtoMsg(message: ResponseLoadSnapshotChunkProtoMsg): _124.ResponseLoadSnapshotChunk;
+            toProto(message: ResponseLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: ResponseLoadSnapshotChunk): _124.ResponseLoadSnapshotChunkProtoMsg;
+        };
+        ResponseApplySnapshotChunk: {
+            typeUrl: string;
+            encode(message: ResponseApplySnapshotChunk, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ResponseApplySnapshotChunk;
+            fromJSON(object: any): _124.ResponseApplySnapshotChunk;
+            toJSON(message: ResponseApplySnapshotChunk): import("../json-safe.js").JsonSafe<_124.ResponseApplySnapshotChunk>;
+            fromPartial(object: Partial<ResponseApplySnapshotChunk>): _124.ResponseApplySnapshotChunk;
+            fromProtoMsg(message: ResponseApplySnapshotChunkProtoMsg): _124.ResponseApplySnapshotChunk;
+            toProto(message: ResponseApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: ResponseApplySnapshotChunk): _124.ResponseApplySnapshotChunkProtoMsg;
+        };
+        ConsensusParams: {
+            typeUrl: string;
+            encode(message: ConsensusParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ConsensusParams;
+            fromJSON(object: any): _124.ConsensusParams;
+            toJSON(message: ConsensusParams): import("../json-safe.js").JsonSafe<_124.ConsensusParams>;
+            fromPartial(object: Partial<ConsensusParams>): _124.ConsensusParams;
+            fromProtoMsg(message: ConsensusParamsProtoMsg): _124.ConsensusParams;
+            toProto(message: ConsensusParams): Uint8Array;
+            toProtoMsg(message: ConsensusParams): _124.ConsensusParamsProtoMsg;
+        };
+        BlockParams: {
+            typeUrl: string;
+            encode(message: BlockParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.BlockParams;
+            fromJSON(object: any): _124.BlockParams;
+            toJSON(message: BlockParams): import("../json-safe.js").JsonSafe<_124.BlockParams>;
+            fromPartial(object: Partial<BlockParams>): _124.BlockParams;
+            fromProtoMsg(message: BlockParamsProtoMsg): _124.BlockParams;
+            toProto(message: BlockParams): Uint8Array;
+            toProtoMsg(message: BlockParams): _124.BlockParamsProtoMsg;
+        };
+        LastCommitInfo: {
+            typeUrl: string;
+            encode(message: LastCommitInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.LastCommitInfo;
+            fromJSON(object: any): _124.LastCommitInfo;
+            toJSON(message: LastCommitInfo): import("../json-safe.js").JsonSafe<_124.LastCommitInfo>;
+            fromPartial(object: Partial<LastCommitInfo>): _124.LastCommitInfo;
+            fromProtoMsg(message: LastCommitInfoProtoMsg): _124.LastCommitInfo;
+            toProto(message: LastCommitInfo): Uint8Array;
+            toProtoMsg(message: LastCommitInfo): _124.LastCommitInfoProtoMsg;
+        };
+        Event: {
+            typeUrl: string;
+            encode(message: Event, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.Event;
+            fromJSON(object: any): _124.Event;
+            toJSON(message: Event): import("../json-safe.js").JsonSafe<_124.Event>;
+            fromPartial(object: Partial<Event>): _124.Event;
+            fromProtoMsg(message: EventProtoMsg): _124.Event;
+            toProto(message: Event): Uint8Array;
+            toProtoMsg(message: Event): _124.EventProtoMsg;
+        };
+        EventAttribute: {
+            typeUrl: string;
+            encode(message: EventAttribute, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.EventAttribute;
+            fromJSON(object: any): _124.EventAttribute;
+            toJSON(message: EventAttribute): import("../json-safe.js").JsonSafe<_124.EventAttribute>;
+            fromPartial(object: Partial<EventAttribute>): _124.EventAttribute;
+            fromProtoMsg(message: EventAttributeProtoMsg): _124.EventAttribute;
+            toProto(message: EventAttribute): Uint8Array;
+            toProtoMsg(message: EventAttribute): _124.EventAttributeProtoMsg;
+        };
+        TxResult: {
+            typeUrl: string;
+            encode(message: TxResult, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.TxResult;
+            fromJSON(object: any): _124.TxResult;
+            toJSON(message: TxResult): import("../json-safe.js").JsonSafe<_124.TxResult>;
+            fromPartial(object: Partial<TxResult>): _124.TxResult;
+            fromProtoMsg(message: TxResultProtoMsg): _124.TxResult;
+            toProto(message: TxResult): Uint8Array;
+            toProtoMsg(message: TxResult): _124.TxResultProtoMsg;
+        };
+        Validator: {
+            typeUrl: string;
+            encode(message: Validator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.Validator;
+            fromJSON(object: any): _124.Validator;
+            toJSON(message: Validator): import("../json-safe.js").JsonSafe<_124.Validator>;
+            fromPartial(object: Partial<Validator>): _124.Validator;
+            fromProtoMsg(message: ValidatorProtoMsg): _124.Validator;
+            toProto(message: Validator): Uint8Array;
+            toProtoMsg(message: Validator): _124.ValidatorProtoMsg;
+        };
+        ValidatorUpdate: {
+            typeUrl: string;
+            encode(message: ValidatorUpdate, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.ValidatorUpdate;
+            fromJSON(object: any): _124.ValidatorUpdate;
+            toJSON(message: ValidatorUpdate): import("../json-safe.js").JsonSafe<_124.ValidatorUpdate>;
+            fromPartial(object: Partial<ValidatorUpdate>): _124.ValidatorUpdate;
+            fromProtoMsg(message: ValidatorUpdateProtoMsg): _124.ValidatorUpdate;
+            toProto(message: ValidatorUpdate): Uint8Array;
+            toProtoMsg(message: ValidatorUpdate): _124.ValidatorUpdateProtoMsg;
+        };
+        VoteInfo: {
+            typeUrl: string;
+            encode(message: VoteInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.VoteInfo;
+            fromJSON(object: any): _124.VoteInfo;
+            toJSON(message: VoteInfo): import("../json-safe.js").JsonSafe<_124.VoteInfo>;
+            fromPartial(object: Partial<VoteInfo>): _124.VoteInfo;
+            fromProtoMsg(message: VoteInfoProtoMsg): _124.VoteInfo;
+            toProto(message: VoteInfo): Uint8Array;
+            toProtoMsg(message: VoteInfo): _124.VoteInfoProtoMsg;
+        };
+        Evidence: {
+            typeUrl: string;
+            encode(message: Evidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.Evidence;
+            fromJSON(object: any): _124.Evidence;
+            toJSON(message: Evidence): import("../json-safe.js").JsonSafe<_124.Evidence>;
+            fromPartial(object: Partial<Evidence>): _124.Evidence;
+            fromProtoMsg(message: EvidenceProtoMsg): _124.Evidence;
+            toProto(message: Evidence): Uint8Array;
+            toProtoMsg(message: Evidence): _124.EvidenceProtoMsg;
+        };
+        Snapshot: {
+            typeUrl: string;
+            encode(message: Snapshot, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _124.Snapshot;
+            fromJSON(object: any): _124.Snapshot;
+            toJSON(message: Snapshot): import("../json-safe.js").JsonSafe<_124.Snapshot>;
+            fromPartial(object: Partial<Snapshot>): _124.Snapshot;
+            fromProtoMsg(message: SnapshotProtoMsg): _124.Snapshot;
+            toProto(message: Snapshot): Uint8Array;
+            toProtoMsg(message: Snapshot): _124.SnapshotProtoMsg;
+        };
+    };
+    const crypto: {
+        Proof: {
+            typeUrl: string;
+            encode(message: Proof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _126.Proof;
+            fromJSON(object: any): _126.Proof;
+            toJSON(message: Proof): import("../json-safe.js").JsonSafe<_126.Proof>;
+            fromPartial(object: Partial<Proof>): _126.Proof;
+            fromProtoMsg(message: ProofProtoMsg): _126.Proof;
+            toProto(message: Proof): Uint8Array;
+            toProtoMsg(message: Proof): _126.ProofProtoMsg;
+        };
+        ValueOp: {
+            typeUrl: string;
+            encode(message: ValueOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _126.ValueOp;
+            fromJSON(object: any): _126.ValueOp;
+            toJSON(message: ValueOp): import("../json-safe.js").JsonSafe<_126.ValueOp>;
+            fromPartial(object: Partial<ValueOp>): _126.ValueOp;
+            fromProtoMsg(message: ValueOpProtoMsg): _126.ValueOp;
+            toProto(message: ValueOp): Uint8Array;
+            toProtoMsg(message: ValueOp): _126.ValueOpProtoMsg;
+        };
+        DominoOp: {
+            typeUrl: string;
+            encode(message: DominoOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _126.DominoOp;
+            fromJSON(object: any): _126.DominoOp;
+            toJSON(message: DominoOp): import("../json-safe.js").JsonSafe<_126.DominoOp>;
+            fromPartial(object: Partial<DominoOp>): _126.DominoOp;
+            fromProtoMsg(message: DominoOpProtoMsg): _126.DominoOp;
+            toProto(message: DominoOp): Uint8Array;
+            toProtoMsg(message: DominoOp): _126.DominoOpProtoMsg;
+        };
+        ProofOp: {
+            typeUrl: string;
+            encode(message: ProofOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _126.ProofOp;
+            fromJSON(object: any): _126.ProofOp;
+            toJSON(message: ProofOp): import("../json-safe.js").JsonSafe<_126.ProofOp>;
+            fromPartial(object: Partial<ProofOp>): _126.ProofOp;
+            fromProtoMsg(message: ProofOpProtoMsg): _126.ProofOp;
+            toProto(message: ProofOp): Uint8Array;
+            toProtoMsg(message: ProofOp): _126.ProofOpProtoMsg;
+        };
+        ProofOps: {
+            typeUrl: string;
+            encode(message: ProofOps, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _126.ProofOps;
+            fromJSON(object: any): _126.ProofOps;
+            toJSON(message: ProofOps): import("../json-safe.js").JsonSafe<_126.ProofOps>;
+            fromPartial(object: Partial<ProofOps>): _126.ProofOps;
+            fromProtoMsg(message: ProofOpsProtoMsg): _126.ProofOps;
+            toProto(message: ProofOps): Uint8Array;
+            toProtoMsg(message: ProofOps): _126.ProofOpsProtoMsg;
+        };
+        PublicKey: {
+            typeUrl: string;
+            encode(message: PublicKey, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _125.PublicKey;
+            fromJSON(object: any): _125.PublicKey;
+            toJSON(message: PublicKey): import("../json-safe.js").JsonSafe<_125.PublicKey>;
+            fromPartial(object: Partial<PublicKey>): _125.PublicKey;
+            fromProtoMsg(message: PublicKeyProtoMsg): _125.PublicKey;
+            toProto(message: PublicKey): Uint8Array;
+            toProtoMsg(message: PublicKey): _125.PublicKeyProtoMsg;
+        };
+    };
+    namespace libs {
+        const bits: {
+            BitArray: {
+                typeUrl: string;
+                encode(message: BitArray, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _127.BitArray;
+                fromJSON(object: any): _127.BitArray;
+                toJSON(message: BitArray): import("../json-safe.js").JsonSafe<_127.BitArray>;
+                fromPartial(object: Partial<BitArray>): _127.BitArray;
+                fromProtoMsg(message: BitArrayProtoMsg): _127.BitArray;
+                toProto(message: BitArray): Uint8Array;
+                toProtoMsg(message: BitArray): _127.BitArrayProtoMsg;
+            };
+        };
+    }
+    const p2p: {
+        ProtocolVersion: {
+            typeUrl: string;
+            encode(message: ProtocolVersion, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _128.ProtocolVersion;
+            fromJSON(object: any): _128.ProtocolVersion;
+            toJSON(message: ProtocolVersion): import("../json-safe.js").JsonSafe<_128.ProtocolVersion>;
+            fromPartial(object: Partial<ProtocolVersion>): _128.ProtocolVersion;
+            fromProtoMsg(message: ProtocolVersionProtoMsg): _128.ProtocolVersion;
+            toProto(message: ProtocolVersion): Uint8Array;
+            toProtoMsg(message: ProtocolVersion): _128.ProtocolVersionProtoMsg;
+        };
+        NodeInfo: {
+            typeUrl: string;
+            encode(message: NodeInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _128.NodeInfo;
+            fromJSON(object: any): _128.NodeInfo;
+            toJSON(message: NodeInfo): import("../json-safe.js").JsonSafe<_128.NodeInfo>;
+            fromPartial(object: Partial<NodeInfo>): _128.NodeInfo;
+            fromProtoMsg(message: NodeInfoProtoMsg): _128.NodeInfo;
+            toProto(message: NodeInfo): Uint8Array;
+            toProtoMsg(message: NodeInfo): _128.NodeInfoProtoMsg;
+        };
+        NodeInfoOther: {
+            typeUrl: string;
+            encode(message: NodeInfoOther, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _128.NodeInfoOther;
+            fromJSON(object: any): _128.NodeInfoOther;
+            toJSON(message: NodeInfoOther): import("../json-safe.js").JsonSafe<_128.NodeInfoOther>;
+            fromPartial(object: Partial<NodeInfoOther>): _128.NodeInfoOther;
+            fromProtoMsg(message: NodeInfoOtherProtoMsg): _128.NodeInfoOther;
+            toProto(message: NodeInfoOther): Uint8Array;
+            toProtoMsg(message: NodeInfoOther): _128.NodeInfoOtherProtoMsg;
+        };
+        PeerInfo: {
+            typeUrl: string;
+            encode(message: PeerInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _128.PeerInfo;
+            fromJSON(object: any): _128.PeerInfo;
+            toJSON(message: PeerInfo): import("../json-safe.js").JsonSafe<_128.PeerInfo>;
+            fromPartial(object: Partial<PeerInfo>): _128.PeerInfo;
+            fromProtoMsg(message: PeerInfoProtoMsg): _128.PeerInfo;
+            toProto(message: PeerInfo): Uint8Array;
+            toProtoMsg(message: PeerInfo): _128.PeerInfoProtoMsg;
+        };
+        PeerAddressInfo: {
+            typeUrl: string;
+            encode(message: PeerAddressInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _128.PeerAddressInfo;
+            fromJSON(object: any): _128.PeerAddressInfo;
+            toJSON(message: PeerAddressInfo): import("../json-safe.js").JsonSafe<_128.PeerAddressInfo>;
+            fromPartial(object: Partial<PeerAddressInfo>): _128.PeerAddressInfo;
+            fromProtoMsg(message: PeerAddressInfoProtoMsg): _128.PeerAddressInfo;
+            toProto(message: PeerAddressInfo): Uint8Array;
+            toProtoMsg(message: PeerAddressInfo): _128.PeerAddressInfoProtoMsg;
+        };
+    };
+    const types: {
+        ValidatorSet: {
+            typeUrl: string;
+            encode(message: ValidatorSet, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _133.ValidatorSet;
+            fromJSON(object: any): _133.ValidatorSet;
+            toJSON(message: ValidatorSet): import("../json-safe.js").JsonSafe<_133.ValidatorSet>;
+            fromPartial(object: Partial<ValidatorSet>): _133.ValidatorSet;
+            fromProtoMsg(message: ValidatorSetProtoMsg): _133.ValidatorSet;
+            toProto(message: ValidatorSet): Uint8Array;
+            toProtoMsg(message: ValidatorSet): _133.ValidatorSetProtoMsg;
+        };
+        Validator: {
+            typeUrl: string;
+            encode(message: Validator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _133.Validator;
+            fromJSON(object: any): _133.Validator;
+            toJSON(message: Validator): import("../json-safe.js").JsonSafe<_133.Validator>;
+            fromPartial(object: Partial<Validator>): _133.Validator;
+            fromProtoMsg(message: ValidatorProtoMsg): _133.Validator;
+            toProto(message: Validator): Uint8Array;
+            toProtoMsg(message: Validator): _133.ValidatorProtoMsg;
+        };
+        SimpleValidator: {
+            typeUrl: string;
+            encode(message: SimpleValidator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _133.SimpleValidator;
+            fromJSON(object: any): _133.SimpleValidator;
+            toJSON(message: SimpleValidator): import("../json-safe.js").JsonSafe<_133.SimpleValidator>;
+            fromPartial(object: Partial<SimpleValidator>): _133.SimpleValidator;
+            fromProtoMsg(message: SimpleValidatorProtoMsg): _133.SimpleValidator;
+            toProto(message: SimpleValidator): Uint8Array;
+            toProtoMsg(message: SimpleValidator): _133.SimpleValidatorProtoMsg;
+        };
+        blockIDFlagFromJSON(object: any): _132.BlockIDFlag;
+        blockIDFlagToJSON(object: BlockIDFlag): string;
+        signedMsgTypeFromJSON(object: any): _132.SignedMsgType;
+        signedMsgTypeToJSON(object: SignedMsgType): string;
+        BlockIDFlag: typeof _132.BlockIDFlag;
+        BlockIDFlagSDKType: typeof _132.BlockIDFlag;
+        SignedMsgType: typeof _132.SignedMsgType;
+        SignedMsgTypeSDKType: typeof _132.SignedMsgType;
+        PartSetHeader: {
+            typeUrl: string;
+            encode(message: PartSetHeader, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.PartSetHeader;
+            fromJSON(object: any): _132.PartSetHeader;
+            toJSON(message: PartSetHeader): import("../json-safe.js").JsonSafe<_132.PartSetHeader>;
+            fromPartial(object: Partial<PartSetHeader>): _132.PartSetHeader;
+            fromProtoMsg(message: PartSetHeaderProtoMsg): _132.PartSetHeader;
+            toProto(message: PartSetHeader): Uint8Array;
+            toProtoMsg(message: PartSetHeader): _132.PartSetHeaderProtoMsg;
+        };
+        Part: {
+            typeUrl: string;
+            encode(message: Part, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.Part;
+            fromJSON(object: any): _132.Part;
+            toJSON(message: Part): import("../json-safe.js").JsonSafe<_132.Part>;
+            fromPartial(object: Partial<Part>): _132.Part;
+            fromProtoMsg(message: PartProtoMsg): _132.Part;
+            toProto(message: Part): Uint8Array;
+            toProtoMsg(message: Part): _132.PartProtoMsg;
+        };
+        BlockID: {
+            typeUrl: string;
+            encode(message: BlockID, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.BlockID;
+            fromJSON(object: any): _132.BlockID;
+            toJSON(message: BlockID): import("../json-safe.js").JsonSafe<_132.BlockID>;
+            fromPartial(object: Partial<BlockID>): _132.BlockID;
+            fromProtoMsg(message: BlockIDProtoMsg): _132.BlockID;
+            toProto(message: BlockID): Uint8Array;
+            toProtoMsg(message: BlockID): _132.BlockIDProtoMsg;
+        };
+        Header: {
+            typeUrl: string;
+            encode(message: Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.Header;
+            fromJSON(object: any): _132.Header;
+            toJSON(message: Header): import("../json-safe.js").JsonSafe<_132.Header>;
+            fromPartial(object: Partial<Header>): _132.Header;
+            fromProtoMsg(message: HeaderProtoMsg): _132.Header;
+            toProto(message: Header): Uint8Array;
+            toProtoMsg(message: Header): _132.HeaderProtoMsg;
+        };
+        Data: {
+            typeUrl: string;
+            encode(message: Data, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.Data;
+            fromJSON(object: any): _132.Data;
+            toJSON(message: Data): import("../json-safe.js").JsonSafe<_132.Data>;
+            fromPartial(object: Partial<Data>): _132.Data;
+            fromProtoMsg(message: DataProtoMsg): _132.Data;
+            toProto(message: Data): Uint8Array;
+            toProtoMsg(message: Data): _132.DataProtoMsg;
+        };
+        Vote: {
+            typeUrl: string;
+            encode(message: Vote, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.Vote;
+            fromJSON(object: any): _132.Vote;
+            toJSON(message: Vote): import("../json-safe.js").JsonSafe<_132.Vote>;
+            fromPartial(object: Partial<Vote>): _132.Vote;
+            fromProtoMsg(message: VoteProtoMsg): _132.Vote;
+            toProto(message: Vote): Uint8Array;
+            toProtoMsg(message: Vote): _132.VoteProtoMsg;
+        };
+        Commit: {
+            typeUrl: string;
+            encode(message: Commit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.Commit;
+            fromJSON(object: any): _132.Commit;
+            toJSON(message: Commit): import("../json-safe.js").JsonSafe<_132.Commit>;
+            fromPartial(object: Partial<Commit>): _132.Commit;
+            fromProtoMsg(message: CommitProtoMsg): _132.Commit;
+            toProto(message: Commit): Uint8Array;
+            toProtoMsg(message: Commit): _132.CommitProtoMsg;
+        };
+        CommitSig: {
+            typeUrl: string;
+            encode(message: CommitSig, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.CommitSig;
+            fromJSON(object: any): _132.CommitSig;
+            toJSON(message: CommitSig): import("../json-safe.js").JsonSafe<_132.CommitSig>;
+            fromPartial(object: Partial<CommitSig>): _132.CommitSig;
+            fromProtoMsg(message: CommitSigProtoMsg): _132.CommitSig;
+            toProto(message: CommitSig): Uint8Array;
+            toProtoMsg(message: CommitSig): _132.CommitSigProtoMsg;
+        };
+        Proposal: {
+            typeUrl: string;
+            encode(message: Proposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.Proposal;
+            fromJSON(object: any): _132.Proposal;
+            toJSON(message: Proposal): import("../json-safe.js").JsonSafe<_132.Proposal>;
+            fromPartial(object: Partial<Proposal>): _132.Proposal;
+            fromProtoMsg(message: ProposalProtoMsg): _132.Proposal;
+            toProto(message: Proposal): Uint8Array;
+            toProtoMsg(message: Proposal): _132.ProposalProtoMsg;
+        };
+        SignedHeader: {
+            typeUrl: string;
+            encode(message: SignedHeader, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.SignedHeader;
+            fromJSON(object: any): _132.SignedHeader;
+            toJSON(message: SignedHeader): import("../json-safe.js").JsonSafe<_132.SignedHeader>;
+            fromPartial(object: Partial<SignedHeader>): _132.SignedHeader;
+            fromProtoMsg(message: SignedHeaderProtoMsg): _132.SignedHeader;
+            toProto(message: SignedHeader): Uint8Array;
+            toProtoMsg(message: SignedHeader): _132.SignedHeaderProtoMsg;
+        };
+        LightBlock: {
+            typeUrl: string;
+            encode(message: LightBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.LightBlock;
+            fromJSON(object: any): _132.LightBlock;
+            toJSON(message: LightBlock): import("../json-safe.js").JsonSafe<_132.LightBlock>;
+            fromPartial(object: Partial<LightBlock>): _132.LightBlock;
+            fromProtoMsg(message: LightBlockProtoMsg): _132.LightBlock;
+            toProto(message: LightBlock): Uint8Array;
+            toProtoMsg(message: LightBlock): _132.LightBlockProtoMsg;
+        };
+        BlockMeta: {
+            typeUrl: string;
+            encode(message: BlockMeta, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.BlockMeta;
+            fromJSON(object: any): _132.BlockMeta;
+            toJSON(message: BlockMeta): import("../json-safe.js").JsonSafe<_132.BlockMeta>;
+            fromPartial(object: Partial<BlockMeta>): _132.BlockMeta;
+            fromProtoMsg(message: BlockMetaProtoMsg): _132.BlockMeta;
+            toProto(message: BlockMeta): Uint8Array;
+            toProtoMsg(message: BlockMeta): _132.BlockMetaProtoMsg;
+        };
+        TxProof: {
+            typeUrl: string;
+            encode(message: TxProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _132.TxProof;
+            fromJSON(object: any): _132.TxProof;
+            toJSON(message: TxProof): import("../json-safe.js").JsonSafe<_132.TxProof>;
+            fromPartial(object: Partial<TxProof>): _132.TxProof;
+            fromProtoMsg(message: TxProofProtoMsg): _132.TxProof;
+            toProto(message: TxProof): Uint8Array;
+            toProtoMsg(message: TxProof): _132.TxProofProtoMsg;
+        };
+        ConsensusParams: {
+            typeUrl: string;
+            encode(message: ConsensusParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.ConsensusParams;
+            fromJSON(object: any): _131.ConsensusParams;
+            toJSON(message: ConsensusParams): import("../json-safe.js").JsonSafe<_131.ConsensusParams>;
+            fromPartial(object: Partial<ConsensusParams>): _131.ConsensusParams;
+            fromProtoMsg(message: ConsensusParamsProtoMsg): _131.ConsensusParams;
+            toProto(message: ConsensusParams): Uint8Array;
+            toProtoMsg(message: ConsensusParams): _131.ConsensusParamsProtoMsg;
+        };
+        BlockParams: {
+            typeUrl: string;
+            encode(message: BlockParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.BlockParams;
+            fromJSON(object: any): _131.BlockParams;
+            toJSON(message: BlockParams): import("../json-safe.js").JsonSafe<_131.BlockParams>;
+            fromPartial(object: Partial<BlockParams>): _131.BlockParams;
+            fromProtoMsg(message: BlockParamsProtoMsg): _131.BlockParams;
+            toProto(message: BlockParams): Uint8Array;
+            toProtoMsg(message: BlockParams): _131.BlockParamsProtoMsg;
+        };
+        EvidenceParams: {
+            typeUrl: string;
+            encode(message: EvidenceParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.EvidenceParams;
+            fromJSON(object: any): _131.EvidenceParams;
+            toJSON(message: EvidenceParams): import("../json-safe.js").JsonSafe<_131.EvidenceParams>;
+            fromPartial(object: Partial<EvidenceParams>): _131.EvidenceParams;
+            fromProtoMsg(message: EvidenceParamsProtoMsg): _131.EvidenceParams;
+            toProto(message: EvidenceParams): Uint8Array;
+            toProtoMsg(message: EvidenceParams): _131.EvidenceParamsProtoMsg;
+        };
+        ValidatorParams: {
+            typeUrl: string;
+            encode(message: ValidatorParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.ValidatorParams;
+            fromJSON(object: any): _131.ValidatorParams;
+            toJSON(message: ValidatorParams): import("../json-safe.js").JsonSafe<_131.ValidatorParams>;
+            fromPartial(object: Partial<ValidatorParams>): _131.ValidatorParams;
+            fromProtoMsg(message: ValidatorParamsProtoMsg): _131.ValidatorParams;
+            toProto(message: ValidatorParams): Uint8Array;
+            toProtoMsg(message: ValidatorParams): _131.ValidatorParamsProtoMsg;
+        };
+        VersionParams: {
+            typeUrl: string;
+            encode(message: VersionParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.VersionParams;
+            fromJSON(object: any): _131.VersionParams;
+            toJSON(message: VersionParams): import("../json-safe.js").JsonSafe<_131.VersionParams>;
+            fromPartial(object: Partial<VersionParams>): _131.VersionParams;
+            fromProtoMsg(message: VersionParamsProtoMsg): _131.VersionParams;
+            toProto(message: VersionParams): Uint8Array;
+            toProtoMsg(message: VersionParams): _131.VersionParamsProtoMsg;
+        };
+        HashedParams: {
+            typeUrl: string;
+            encode(message: HashedParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _131.HashedParams;
+            fromJSON(object: any): _131.HashedParams;
+            toJSON(message: HashedParams): import("../json-safe.js").JsonSafe<_131.HashedParams>;
+            fromPartial(object: Partial<HashedParams>): _131.HashedParams;
+            fromProtoMsg(message: HashedParamsProtoMsg): _131.HashedParams;
+            toProto(message: HashedParams): Uint8Array;
+            toProtoMsg(message: HashedParams): _131.HashedParamsProtoMsg;
+        };
+        Evidence: {
+            typeUrl: string;
+            encode(message: Evidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _130.Evidence;
+            fromJSON(object: any): _130.Evidence;
+            toJSON(message: Evidence): import("../json-safe.js").JsonSafe<_130.Evidence>;
+            fromPartial(object: Partial<Evidence>): _130.Evidence;
+            fromProtoMsg(message: EvidenceProtoMsg): _130.Evidence;
+            toProto(message: Evidence): Uint8Array;
+            toProtoMsg(message: Evidence): _130.EvidenceProtoMsg;
+        };
+        DuplicateVoteEvidence: {
+            typeUrl: string;
+            encode(message: DuplicateVoteEvidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _130.DuplicateVoteEvidence;
+            fromJSON(object: any): _130.DuplicateVoteEvidence;
+            toJSON(message: DuplicateVoteEvidence): import("../json-safe.js").JsonSafe<_130.DuplicateVoteEvidence>;
+            fromPartial(object: Partial<DuplicateVoteEvidence>): _130.DuplicateVoteEvidence;
+            fromProtoMsg(message: DuplicateVoteEvidenceProtoMsg): _130.DuplicateVoteEvidence;
+            toProto(message: DuplicateVoteEvidence): Uint8Array;
+            toProtoMsg(message: DuplicateVoteEvidence): _130.DuplicateVoteEvidenceProtoMsg;
+        };
+        LightClientAttackEvidence: {
+            typeUrl: string;
+            encode(message: LightClientAttackEvidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _130.LightClientAttackEvidence;
+            fromJSON(object: any): _130.LightClientAttackEvidence;
+            toJSON(message: LightClientAttackEvidence): import("../json-safe.js").JsonSafe<_130.LightClientAttackEvidence>;
+            fromPartial(object: Partial<LightClientAttackEvidence>): _130.LightClientAttackEvidence;
+            fromProtoMsg(message: LightClientAttackEvidenceProtoMsg): _130.LightClientAttackEvidence;
+            toProto(message: LightClientAttackEvidence): Uint8Array;
+            toProtoMsg(message: LightClientAttackEvidence): _130.LightClientAttackEvidenceProtoMsg;
+        };
+        EvidenceList: {
+            typeUrl: string;
+            encode(message: EvidenceList, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _130.EvidenceList;
+            fromJSON(object: any): _130.EvidenceList;
+            toJSON(message: EvidenceList): import("../json-safe.js").JsonSafe<_130.EvidenceList>;
+            fromPartial(object: Partial<EvidenceList>): _130.EvidenceList;
+            fromProtoMsg(message: EvidenceListProtoMsg): _130.EvidenceList;
+            toProto(message: EvidenceList): Uint8Array;
+            toProtoMsg(message: EvidenceList): _130.EvidenceListProtoMsg;
+        };
+        Block: {
+            typeUrl: string;
+            encode(message: Block, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _129.Block;
+            fromJSON(object: any): _129.Block;
+            toJSON(message: Block): import("../json-safe.js").JsonSafe<_129.Block>;
+            fromPartial(object: Partial<Block>): _129.Block;
+            fromProtoMsg(message: BlockProtoMsg): _129.Block;
+            toProto(message: Block): Uint8Array;
+            toProtoMsg(message: Block): _129.BlockProtoMsg;
+        };
+    };
+    const version: {
+        App: {
+            typeUrl: string;
+            encode(message: App, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _134.App;
+            fromJSON(object: any): _134.App;
+            toJSON(message: App): import("../json-safe.js").JsonSafe<_134.App>;
+            fromPartial(object: Partial<App>): _134.App;
+            fromProtoMsg(message: AppProtoMsg): _134.App;
+            toProto(message: App): Uint8Array;
+            toProtoMsg(message: App): _134.AppProtoMsg;
+        };
+        Consensus: {
+            typeUrl: string;
+            encode(message: Consensus, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _134.Consensus;
+            fromJSON(object: any): _134.Consensus;
+            toJSON(message: Consensus): import("../json-safe.js").JsonSafe<_134.Consensus>;
+            fromPartial(object: Partial<Consensus>): _134.Consensus;
+            fromProtoMsg(message: ConsensusProtoMsg): _134.Consensus;
+            toProto(message: Consensus): Uint8Array;
+            toProtoMsg(message: Consensus): _134.ConsensusProtoMsg;
+        };
+    };
+}