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