@agoric/cosmic-proto 0.4.1-orchestration-dev-096c4e8.0 → 0.4.1-other-dev-3eb1a1d.0

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

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