@agoric/client-utils 0.1.1-dev-763bc10.0.763bc10 → 0.1.1-dev-bcbee89.0.bcbee89

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

@@ -0,0 +1,703 @@
+import * as _203 from './abci/types.js';
+import * as _204 from './crypto/keys.js';
+import * as _205 from './crypto/proof.js';
+import * as _206 from './libs/bits/types.js';
+import * as _207 from './p2p/types.js';
+import * as _208 from './types/block.js';
+import * as _209 from './types/evidence.js';
+import * as _210 from './types/params.js';
+import * as _211 from './types/types.js';
+import * as _212 from './types/validator.js';
+import * as _213 from './version/types.js';
+export declare namespace tendermint {
+    const abci: {
+        checkTxTypeFromJSON(object: any): _203.CheckTxType;
+        checkTxTypeToJSON(object: _203.CheckTxType): string;
+        evidenceTypeFromJSON(object: any): _203.EvidenceType;
+        evidenceTypeToJSON(object: _203.EvidenceType): string;
+        CheckTxType: typeof _203.CheckTxType;
+        CheckTxTypeSDKType: typeof _203.CheckTxType;
+        EvidenceType: typeof _203.EvidenceType;
+        EvidenceTypeSDKType: typeof _203.EvidenceType;
+        RequestQuery: {
+            typeUrl: string;
+            encode(message: _203.RequestQuery, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.RequestQuery;
+            fromJSON(object: any): _203.RequestQuery;
+            toJSON(message: _203.RequestQuery): import("../json-safe.js").JsonSafe<_203.RequestQuery>;
+            fromPartial(object: Partial<_203.RequestQuery>): _203.RequestQuery;
+            fromProtoMsg(message: _203.RequestQueryProtoMsg): _203.RequestQuery;
+            toProto(message: _203.RequestQuery): Uint8Array;
+            toProtoMsg(message: _203.RequestQuery): _203.RequestQueryProtoMsg;
+        };
+        RequestBeginBlock: {
+            typeUrl: string;
+            encode(message: _203.RequestBeginBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.RequestBeginBlock;
+            fromJSON(object: any): _203.RequestBeginBlock;
+            toJSON(message: _203.RequestBeginBlock): import("../json-safe.js").JsonSafe<_203.RequestBeginBlock>;
+            fromPartial(object: Partial<_203.RequestBeginBlock>): _203.RequestBeginBlock;
+            fromProtoMsg(message: _203.RequestBeginBlockProtoMsg): _203.RequestBeginBlock;
+            toProto(message: _203.RequestBeginBlock): Uint8Array;
+            toProtoMsg(message: _203.RequestBeginBlock): _203.RequestBeginBlockProtoMsg;
+        };
+        RequestCheckTx: {
+            typeUrl: string;
+            encode(message: _203.RequestCheckTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.RequestCheckTx;
+            fromJSON(object: any): _203.RequestCheckTx;
+            toJSON(message: _203.RequestCheckTx): import("../json-safe.js").JsonSafe<_203.RequestCheckTx>;
+            fromPartial(object: Partial<_203.RequestCheckTx>): _203.RequestCheckTx;
+            fromProtoMsg(message: _203.RequestCheckTxProtoMsg): _203.RequestCheckTx;
+            toProto(message: _203.RequestCheckTx): Uint8Array;
+            toProtoMsg(message: _203.RequestCheckTx): _203.RequestCheckTxProtoMsg;
+        };
+        RequestDeliverTx: {
+            typeUrl: string;
+            encode(message: _203.RequestDeliverTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.RequestDeliverTx;
+            fromJSON(object: any): _203.RequestDeliverTx;
+            toJSON(message: _203.RequestDeliverTx): import("../json-safe.js").JsonSafe<_203.RequestDeliverTx>;
+            fromPartial(object: Partial<_203.RequestDeliverTx>): _203.RequestDeliverTx;
+            fromProtoMsg(message: _203.RequestDeliverTxProtoMsg): _203.RequestDeliverTx;
+            toProto(message: _203.RequestDeliverTx): Uint8Array;
+            toProtoMsg(message: _203.RequestDeliverTx): _203.RequestDeliverTxProtoMsg;
+        };
+        RequestEndBlock: {
+            typeUrl: string;
+            encode(message: _203.RequestEndBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.RequestEndBlock;
+            fromJSON(object: any): _203.RequestEndBlock;
+            toJSON(message: _203.RequestEndBlock): import("../json-safe.js").JsonSafe<_203.RequestEndBlock>;
+            fromPartial(object: Partial<_203.RequestEndBlock>): _203.RequestEndBlock;
+            fromProtoMsg(message: _203.RequestEndBlockProtoMsg): _203.RequestEndBlock;
+            toProto(message: _203.RequestEndBlock): Uint8Array;
+            toProtoMsg(message: _203.RequestEndBlock): _203.RequestEndBlockProtoMsg;
+        };
+        RequestCommit: {
+            typeUrl: string;
+            encode(_: _203.RequestCommit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.RequestCommit;
+            fromJSON(_: any): _203.RequestCommit;
+            toJSON(_: _203.RequestCommit): import("../json-safe.js").JsonSafe<_203.RequestCommit>;
+            fromPartial(_: Partial<_203.RequestCommit>): _203.RequestCommit;
+            fromProtoMsg(message: _203.RequestCommitProtoMsg): _203.RequestCommit;
+            toProto(message: _203.RequestCommit): Uint8Array;
+            toProtoMsg(message: _203.RequestCommit): _203.RequestCommitProtoMsg;
+        };
+        ResponseQuery: {
+            typeUrl: string;
+            encode(message: _203.ResponseQuery, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.ResponseQuery;
+            fromJSON(object: any): _203.ResponseQuery;
+            toJSON(message: _203.ResponseQuery): import("../json-safe.js").JsonSafe<_203.ResponseQuery>;
+            fromPartial(object: Partial<_203.ResponseQuery>): _203.ResponseQuery;
+            fromProtoMsg(message: _203.ResponseQueryProtoMsg): _203.ResponseQuery;
+            toProto(message: _203.ResponseQuery): Uint8Array;
+            toProtoMsg(message: _203.ResponseQuery): _203.ResponseQueryProtoMsg;
+        };
+        ResponseBeginBlock: {
+            typeUrl: string;
+            encode(message: _203.ResponseBeginBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.ResponseBeginBlock;
+            fromJSON(object: any): _203.ResponseBeginBlock;
+            toJSON(message: _203.ResponseBeginBlock): import("../json-safe.js").JsonSafe<_203.ResponseBeginBlock>;
+            fromPartial(object: Partial<_203.ResponseBeginBlock>): _203.ResponseBeginBlock;
+            fromProtoMsg(message: _203.ResponseBeginBlockProtoMsg): _203.ResponseBeginBlock;
+            toProto(message: _203.ResponseBeginBlock): Uint8Array;
+            toProtoMsg(message: _203.ResponseBeginBlock): _203.ResponseBeginBlockProtoMsg;
+        };
+        ResponseCheckTx: {
+            typeUrl: string;
+            encode(message: _203.ResponseCheckTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.ResponseCheckTx;
+            fromJSON(object: any): _203.ResponseCheckTx;
+            toJSON(message: _203.ResponseCheckTx): import("../json-safe.js").JsonSafe<_203.ResponseCheckTx>;
+            fromPartial(object: Partial<_203.ResponseCheckTx>): _203.ResponseCheckTx;
+            fromProtoMsg(message: _203.ResponseCheckTxProtoMsg): _203.ResponseCheckTx;
+            toProto(message: _203.ResponseCheckTx): Uint8Array;
+            toProtoMsg(message: _203.ResponseCheckTx): _203.ResponseCheckTxProtoMsg;
+        };
+        ResponseDeliverTx: {
+            typeUrl: string;
+            encode(message: _203.ResponseDeliverTx, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.ResponseDeliverTx;
+            fromJSON(object: any): _203.ResponseDeliverTx;
+            toJSON(message: _203.ResponseDeliverTx): import("../json-safe.js").JsonSafe<_203.ResponseDeliverTx>;
+            fromPartial(object: Partial<_203.ResponseDeliverTx>): _203.ResponseDeliverTx;
+            fromProtoMsg(message: _203.ResponseDeliverTxProtoMsg): _203.ResponseDeliverTx;
+            toProto(message: _203.ResponseDeliverTx): Uint8Array;
+            toProtoMsg(message: _203.ResponseDeliverTx): _203.ResponseDeliverTxProtoMsg;
+        };
+        ResponseEndBlock: {
+            typeUrl: string;
+            encode(message: _203.ResponseEndBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.ResponseEndBlock;
+            fromJSON(object: any): _203.ResponseEndBlock;
+            toJSON(message: _203.ResponseEndBlock): import("../json-safe.js").JsonSafe<_203.ResponseEndBlock>;
+            fromPartial(object: Partial<_203.ResponseEndBlock>): _203.ResponseEndBlock;
+            fromProtoMsg(message: _203.ResponseEndBlockProtoMsg): _203.ResponseEndBlock;
+            toProto(message: _203.ResponseEndBlock): Uint8Array;
+            toProtoMsg(message: _203.ResponseEndBlock): _203.ResponseEndBlockProtoMsg;
+        };
+        ResponseCommit: {
+            typeUrl: string;
+            encode(message: _203.ResponseCommit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.ResponseCommit;
+            fromJSON(object: any): _203.ResponseCommit;
+            toJSON(message: _203.ResponseCommit): import("../json-safe.js").JsonSafe<_203.ResponseCommit>;
+            fromPartial(object: Partial<_203.ResponseCommit>): _203.ResponseCommit;
+            fromProtoMsg(message: _203.ResponseCommitProtoMsg): _203.ResponseCommit;
+            toProto(message: _203.ResponseCommit): Uint8Array;
+            toProtoMsg(message: _203.ResponseCommit): _203.ResponseCommitProtoMsg;
+        };
+        LastCommitInfo: {
+            typeUrl: string;
+            encode(message: _203.LastCommitInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.LastCommitInfo;
+            fromJSON(object: any): _203.LastCommitInfo;
+            toJSON(message: _203.LastCommitInfo): import("../json-safe.js").JsonSafe<_203.LastCommitInfo>;
+            fromPartial(object: Partial<_203.LastCommitInfo>): _203.LastCommitInfo;
+            fromProtoMsg(message: _203.LastCommitInfoProtoMsg): _203.LastCommitInfo;
+            toProto(message: _203.LastCommitInfo): Uint8Array;
+            toProtoMsg(message: _203.LastCommitInfo): _203.LastCommitInfoProtoMsg;
+        };
+        Event: {
+            typeUrl: string;
+            encode(message: _203.Event, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.Event;
+            fromJSON(object: any): _203.Event;
+            toJSON(message: _203.Event): import("../json-safe.js").JsonSafe<_203.Event>;
+            fromPartial(object: Partial<_203.Event>): _203.Event;
+            fromProtoMsg(message: _203.EventProtoMsg): _203.Event;
+            toProto(message: _203.Event): Uint8Array;
+            toProtoMsg(message: _203.Event): _203.EventProtoMsg;
+        };
+        EventAttribute: {
+            typeUrl: string;
+            encode(message: _203.EventAttribute, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.EventAttribute;
+            fromJSON(object: any): _203.EventAttribute;
+            toJSON(message: _203.EventAttribute): import("../json-safe.js").JsonSafe<_203.EventAttribute>;
+            fromPartial(object: Partial<_203.EventAttribute>): _203.EventAttribute;
+            fromProtoMsg(message: _203.EventAttributeProtoMsg): _203.EventAttribute;
+            toProto(message: _203.EventAttribute): Uint8Array;
+            toProtoMsg(message: _203.EventAttribute): _203.EventAttributeProtoMsg;
+        };
+        TxResult: {
+            typeUrl: string;
+            encode(message: _203.TxResult, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.TxResult;
+            fromJSON(object: any): _203.TxResult;
+            toJSON(message: _203.TxResult): import("../json-safe.js").JsonSafe<_203.TxResult>;
+            fromPartial(object: Partial<_203.TxResult>): _203.TxResult;
+            fromProtoMsg(message: _203.TxResultProtoMsg): _203.TxResult;
+            toProto(message: _203.TxResult): Uint8Array;
+            toProtoMsg(message: _203.TxResult): _203.TxResultProtoMsg;
+        };
+        Validator: {
+            typeUrl: string;
+            encode(message: _203.Validator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.Validator;
+            fromJSON(object: any): _203.Validator;
+            toJSON(message: _203.Validator): import("../json-safe.js").JsonSafe<_203.Validator>;
+            fromPartial(object: Partial<_203.Validator>): _203.Validator;
+            fromProtoMsg(message: _203.ValidatorProtoMsg): _203.Validator;
+            toProto(message: _203.Validator): Uint8Array;
+            toProtoMsg(message: _203.Validator): _203.ValidatorProtoMsg;
+        };
+        ValidatorUpdate: {
+            typeUrl: string;
+            encode(message: _203.ValidatorUpdate, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.ValidatorUpdate;
+            fromJSON(object: any): _203.ValidatorUpdate;
+            toJSON(message: _203.ValidatorUpdate): import("../json-safe.js").JsonSafe<_203.ValidatorUpdate>;
+            fromPartial(object: Partial<_203.ValidatorUpdate>): _203.ValidatorUpdate;
+            fromProtoMsg(message: _203.ValidatorUpdateProtoMsg): _203.ValidatorUpdate;
+            toProto(message: _203.ValidatorUpdate): Uint8Array;
+            toProtoMsg(message: _203.ValidatorUpdate): _203.ValidatorUpdateProtoMsg;
+        };
+        VoteInfo: {
+            typeUrl: string;
+            encode(message: _203.VoteInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.VoteInfo;
+            fromJSON(object: any): _203.VoteInfo;
+            toJSON(message: _203.VoteInfo): import("../json-safe.js").JsonSafe<_203.VoteInfo>;
+            fromPartial(object: Partial<_203.VoteInfo>): _203.VoteInfo;
+            fromProtoMsg(message: _203.VoteInfoProtoMsg): _203.VoteInfo;
+            toProto(message: _203.VoteInfo): Uint8Array;
+            toProtoMsg(message: _203.VoteInfo): _203.VoteInfoProtoMsg;
+        };
+        Evidence: {
+            typeUrl: string;
+            encode(message: _203.Evidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _203.Evidence;
+            fromJSON(object: any): _203.Evidence;
+            toJSON(message: _203.Evidence): import("../json-safe.js").JsonSafe<_203.Evidence>;
+            fromPartial(object: Partial<_203.Evidence>): _203.Evidence;
+            fromProtoMsg(message: _203.EvidenceProtoMsg): _203.Evidence;
+            toProto(message: _203.Evidence): Uint8Array;
+            toProtoMsg(message: _203.Evidence): _203.EvidenceProtoMsg;
+        };
+    };
+    const crypto: {
+        Proof: {
+            typeUrl: string;
+            encode(message: _205.Proof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _205.Proof;
+            fromJSON(object: any): _205.Proof;
+            toJSON(message: _205.Proof): import("../json-safe.js").JsonSafe<_205.Proof>;
+            fromPartial(object: Partial<_205.Proof>): _205.Proof;
+            fromProtoMsg(message: _205.ProofProtoMsg): _205.Proof;
+            toProto(message: _205.Proof): Uint8Array;
+            toProtoMsg(message: _205.Proof): _205.ProofProtoMsg;
+        };
+        ValueOp: {
+            typeUrl: string;
+            encode(message: _205.ValueOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _205.ValueOp;
+            fromJSON(object: any): _205.ValueOp;
+            toJSON(message: _205.ValueOp): import("../json-safe.js").JsonSafe<_205.ValueOp>;
+            fromPartial(object: Partial<_205.ValueOp>): _205.ValueOp;
+            fromProtoMsg(message: _205.ValueOpProtoMsg): _205.ValueOp;
+            toProto(message: _205.ValueOp): Uint8Array;
+            toProtoMsg(message: _205.ValueOp): _205.ValueOpProtoMsg;
+        };
+        DominoOp: {
+            typeUrl: string;
+            encode(message: _205.DominoOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _205.DominoOp;
+            fromJSON(object: any): _205.DominoOp;
+            toJSON(message: _205.DominoOp): import("../json-safe.js").JsonSafe<_205.DominoOp>;
+            fromPartial(object: Partial<_205.DominoOp>): _205.DominoOp;
+            fromProtoMsg(message: _205.DominoOpProtoMsg): _205.DominoOp;
+            toProto(message: _205.DominoOp): Uint8Array;
+            toProtoMsg(message: _205.DominoOp): _205.DominoOpProtoMsg;
+        };
+        ProofOp: {
+            typeUrl: string;
+            encode(message: _205.ProofOp, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _205.ProofOp;
+            fromJSON(object: any): _205.ProofOp;
+            toJSON(message: _205.ProofOp): import("../json-safe.js").JsonSafe<_205.ProofOp>;
+            fromPartial(object: Partial<_205.ProofOp>): _205.ProofOp;
+            fromProtoMsg(message: _205.ProofOpProtoMsg): _205.ProofOp;
+            toProto(message: _205.ProofOp): Uint8Array;
+            toProtoMsg(message: _205.ProofOp): _205.ProofOpProtoMsg;
+        };
+        ProofOps: {
+            typeUrl: string;
+            encode(message: _205.ProofOps, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _205.ProofOps;
+            fromJSON(object: any): _205.ProofOps;
+            toJSON(message: _205.ProofOps): import("../json-safe.js").JsonSafe<_205.ProofOps>;
+            fromPartial(object: Partial<_205.ProofOps>): _205.ProofOps;
+            fromProtoMsg(message: _205.ProofOpsProtoMsg): _205.ProofOps;
+            toProto(message: _205.ProofOps): Uint8Array;
+            toProtoMsg(message: _205.ProofOps): _205.ProofOpsProtoMsg;
+        };
+        PublicKey: {
+            typeUrl: string;
+            encode(message: _204.PublicKey, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _204.PublicKey;
+            fromJSON(object: any): _204.PublicKey;
+            toJSON(message: _204.PublicKey): import("../json-safe.js").JsonSafe<_204.PublicKey>;
+            fromPartial(object: Partial<_204.PublicKey>): _204.PublicKey;
+            fromProtoMsg(message: _204.PublicKeyProtoMsg): _204.PublicKey;
+            toProto(message: _204.PublicKey): Uint8Array;
+            toProtoMsg(message: _204.PublicKey): _204.PublicKeyProtoMsg;
+        };
+    };
+    namespace libs {
+        const bits: {
+            BitArray: {
+                typeUrl: string;
+                encode(message: _206.BitArray, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+                decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _206.BitArray;
+                fromJSON(object: any): _206.BitArray;
+                toJSON(message: _206.BitArray): import("../json-safe.js").JsonSafe<_206.BitArray>;
+                fromPartial(object: Partial<_206.BitArray>): _206.BitArray;
+                fromProtoMsg(message: _206.BitArrayProtoMsg): _206.BitArray;
+                toProto(message: _206.BitArray): Uint8Array;
+                toProtoMsg(message: _206.BitArray): _206.BitArrayProtoMsg;
+            };
+        };
+    }
+    const p2p: {
+        NetAddress: {
+            typeUrl: string;
+            encode(message: _207.NetAddress, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _207.NetAddress;
+            fromJSON(object: any): _207.NetAddress;
+            toJSON(message: _207.NetAddress): import("../json-safe.js").JsonSafe<_207.NetAddress>;
+            fromPartial(object: Partial<_207.NetAddress>): _207.NetAddress;
+            fromProtoMsg(message: _207.NetAddressProtoMsg): _207.NetAddress;
+            toProto(message: _207.NetAddress): Uint8Array;
+            toProtoMsg(message: _207.NetAddress): _207.NetAddressProtoMsg;
+        };
+        ProtocolVersion: {
+            typeUrl: string;
+            encode(message: _207.ProtocolVersion, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _207.ProtocolVersion;
+            fromJSON(object: any): _207.ProtocolVersion;
+            toJSON(message: _207.ProtocolVersion): import("../json-safe.js").JsonSafe<_207.ProtocolVersion>;
+            fromPartial(object: Partial<_207.ProtocolVersion>): _207.ProtocolVersion;
+            fromProtoMsg(message: _207.ProtocolVersionProtoMsg): _207.ProtocolVersion;
+            toProto(message: _207.ProtocolVersion): Uint8Array;
+            toProtoMsg(message: _207.ProtocolVersion): _207.ProtocolVersionProtoMsg;
+        };
+        DefaultNodeInfo: {
+            typeUrl: string;
+            encode(message: _207.DefaultNodeInfo, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _207.DefaultNodeInfo;
+            fromJSON(object: any): _207.DefaultNodeInfo;
+            toJSON(message: _207.DefaultNodeInfo): import("../json-safe.js").JsonSafe<_207.DefaultNodeInfo>;
+            fromPartial(object: Partial<_207.DefaultNodeInfo>): _207.DefaultNodeInfo;
+            fromProtoMsg(message: _207.DefaultNodeInfoProtoMsg): _207.DefaultNodeInfo;
+            toProto(message: _207.DefaultNodeInfo): Uint8Array;
+            toProtoMsg(message: _207.DefaultNodeInfo): _207.DefaultNodeInfoProtoMsg;
+        };
+        DefaultNodeInfoOther: {
+            typeUrl: string;
+            encode(message: _207.DefaultNodeInfoOther, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _207.DefaultNodeInfoOther;
+            fromJSON(object: any): _207.DefaultNodeInfoOther;
+            toJSON(message: _207.DefaultNodeInfoOther): import("../json-safe.js").JsonSafe<_207.DefaultNodeInfoOther>;
+            fromPartial(object: Partial<_207.DefaultNodeInfoOther>): _207.DefaultNodeInfoOther;
+            fromProtoMsg(message: _207.DefaultNodeInfoOtherProtoMsg): _207.DefaultNodeInfoOther;
+            toProto(message: _207.DefaultNodeInfoOther): Uint8Array;
+            toProtoMsg(message: _207.DefaultNodeInfoOther): _207.DefaultNodeInfoOtherProtoMsg;
+        };
+    };
+    const types: {
+        ValidatorSet: {
+            typeUrl: string;
+            encode(message: _212.ValidatorSet, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _212.ValidatorSet;
+            fromJSON(object: any): _212.ValidatorSet;
+            toJSON(message: _212.ValidatorSet): import("../json-safe.js").JsonSafe<_212.ValidatorSet>;
+            fromPartial(object: Partial<_212.ValidatorSet>): _212.ValidatorSet;
+            fromProtoMsg(message: _212.ValidatorSetProtoMsg): _212.ValidatorSet;
+            toProto(message: _212.ValidatorSet): Uint8Array;
+            toProtoMsg(message: _212.ValidatorSet): _212.ValidatorSetProtoMsg;
+        };
+        Validator: {
+            typeUrl: string;
+            encode(message: _212.Validator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _212.Validator;
+            fromJSON(object: any): _212.Validator;
+            toJSON(message: _212.Validator): import("../json-safe.js").JsonSafe<_212.Validator>;
+            fromPartial(object: Partial<_212.Validator>): _212.Validator;
+            fromProtoMsg(message: _212.ValidatorProtoMsg): _212.Validator;
+            toProto(message: _212.Validator): Uint8Array;
+            toProtoMsg(message: _212.Validator): _212.ValidatorProtoMsg;
+        };
+        SimpleValidator: {
+            typeUrl: string;
+            encode(message: _212.SimpleValidator, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _212.SimpleValidator;
+            fromJSON(object: any): _212.SimpleValidator;
+            toJSON(message: _212.SimpleValidator): import("../json-safe.js").JsonSafe<_212.SimpleValidator>;
+            fromPartial(object: Partial<_212.SimpleValidator>): _212.SimpleValidator;
+            fromProtoMsg(message: _212.SimpleValidatorProtoMsg): _212.SimpleValidator;
+            toProto(message: _212.SimpleValidator): Uint8Array;
+            toProtoMsg(message: _212.SimpleValidator): _212.SimpleValidatorProtoMsg;
+        };
+        blockIDFlagFromJSON(object: any): _211.BlockIDFlag;
+        blockIDFlagToJSON(object: _211.BlockIDFlag): string;
+        signedMsgTypeFromJSON(object: any): _211.SignedMsgType;
+        signedMsgTypeToJSON(object: _211.SignedMsgType): string;
+        BlockIDFlag: typeof _211.BlockIDFlag;
+        BlockIDFlagSDKType: typeof _211.BlockIDFlag;
+        SignedMsgType: typeof _211.SignedMsgType;
+        SignedMsgTypeSDKType: typeof _211.SignedMsgType;
+        PartSetHeader: {
+            typeUrl: string;
+            encode(message: _211.PartSetHeader, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.PartSetHeader;
+            fromJSON(object: any): _211.PartSetHeader;
+            toJSON(message: _211.PartSetHeader): import("../json-safe.js").JsonSafe<_211.PartSetHeader>;
+            fromPartial(object: Partial<_211.PartSetHeader>): _211.PartSetHeader;
+            fromProtoMsg(message: _211.PartSetHeaderProtoMsg): _211.PartSetHeader;
+            toProto(message: _211.PartSetHeader): Uint8Array;
+            toProtoMsg(message: _211.PartSetHeader): _211.PartSetHeaderProtoMsg;
+        };
+        Part: {
+            typeUrl: string;
+            encode(message: _211.Part, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.Part;
+            fromJSON(object: any): _211.Part;
+            toJSON(message: _211.Part): import("../json-safe.js").JsonSafe<_211.Part>;
+            fromPartial(object: Partial<_211.Part>): _211.Part;
+            fromProtoMsg(message: _211.PartProtoMsg): _211.Part;
+            toProto(message: _211.Part): Uint8Array;
+            toProtoMsg(message: _211.Part): _211.PartProtoMsg;
+        };
+        BlockID: {
+            typeUrl: string;
+            encode(message: _211.BlockID, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.BlockID;
+            fromJSON(object: any): _211.BlockID;
+            toJSON(message: _211.BlockID): import("../json-safe.js").JsonSafe<_211.BlockID>;
+            fromPartial(object: Partial<_211.BlockID>): _211.BlockID;
+            fromProtoMsg(message: _211.BlockIDProtoMsg): _211.BlockID;
+            toProto(message: _211.BlockID): Uint8Array;
+            toProtoMsg(message: _211.BlockID): _211.BlockIDProtoMsg;
+        };
+        Header: {
+            typeUrl: string;
+            encode(message: _211.Header, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.Header;
+            fromJSON(object: any): _211.Header;
+            toJSON(message: _211.Header): import("../json-safe.js").JsonSafe<_211.Header>;
+            fromPartial(object: Partial<_211.Header>): _211.Header;
+            fromProtoMsg(message: _211.HeaderProtoMsg): _211.Header;
+            toProto(message: _211.Header): Uint8Array;
+            toProtoMsg(message: _211.Header): _211.HeaderProtoMsg;
+        };
+        Data: {
+            typeUrl: string;
+            encode(message: _211.Data, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.Data;
+            fromJSON(object: any): _211.Data;
+            toJSON(message: _211.Data): import("../json-safe.js").JsonSafe<_211.Data>;
+            fromPartial(object: Partial<_211.Data>): _211.Data;
+            fromProtoMsg(message: _211.DataProtoMsg): _211.Data;
+            toProto(message: _211.Data): Uint8Array;
+            toProtoMsg(message: _211.Data): _211.DataProtoMsg;
+        };
+        Vote: {
+            typeUrl: string;
+            encode(message: _211.Vote, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.Vote;
+            fromJSON(object: any): _211.Vote;
+            toJSON(message: _211.Vote): import("../json-safe.js").JsonSafe<_211.Vote>;
+            fromPartial(object: Partial<_211.Vote>): _211.Vote;
+            fromProtoMsg(message: _211.VoteProtoMsg): _211.Vote;
+            toProto(message: _211.Vote): Uint8Array;
+            toProtoMsg(message: _211.Vote): _211.VoteProtoMsg;
+        };
+        Commit: {
+            typeUrl: string;
+            encode(message: _211.Commit, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.Commit;
+            fromJSON(object: any): _211.Commit;
+            toJSON(message: _211.Commit): import("../json-safe.js").JsonSafe<_211.Commit>;
+            fromPartial(object: Partial<_211.Commit>): _211.Commit;
+            fromProtoMsg(message: _211.CommitProtoMsg): _211.Commit;
+            toProto(message: _211.Commit): Uint8Array;
+            toProtoMsg(message: _211.Commit): _211.CommitProtoMsg;
+        };
+        CommitSig: {
+            typeUrl: string;
+            encode(message: _211.CommitSig, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.CommitSig;
+            fromJSON(object: any): _211.CommitSig;
+            toJSON(message: _211.CommitSig): import("../json-safe.js").JsonSafe<_211.CommitSig>;
+            fromPartial(object: Partial<_211.CommitSig>): _211.CommitSig;
+            fromProtoMsg(message: _211.CommitSigProtoMsg): _211.CommitSig;
+            toProto(message: _211.CommitSig): Uint8Array;
+            toProtoMsg(message: _211.CommitSig): _211.CommitSigProtoMsg;
+        };
+        Proposal: {
+            typeUrl: string;
+            encode(message: _211.Proposal, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.Proposal;
+            fromJSON(object: any): _211.Proposal;
+            toJSON(message: _211.Proposal): import("../json-safe.js").JsonSafe<_211.Proposal>;
+            fromPartial(object: Partial<_211.Proposal>): _211.Proposal;
+            fromProtoMsg(message: _211.ProposalProtoMsg): _211.Proposal;
+            toProto(message: _211.Proposal): Uint8Array;
+            toProtoMsg(message: _211.Proposal): _211.ProposalProtoMsg;
+        };
+        SignedHeader: {
+            typeUrl: string;
+            encode(message: _211.SignedHeader, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.SignedHeader;
+            fromJSON(object: any): _211.SignedHeader;
+            toJSON(message: _211.SignedHeader): import("../json-safe.js").JsonSafe<_211.SignedHeader>;
+            fromPartial(object: Partial<_211.SignedHeader>): _211.SignedHeader;
+            fromProtoMsg(message: _211.SignedHeaderProtoMsg): _211.SignedHeader;
+            toProto(message: _211.SignedHeader): Uint8Array;
+            toProtoMsg(message: _211.SignedHeader): _211.SignedHeaderProtoMsg;
+        };
+        LightBlock: {
+            typeUrl: string;
+            encode(message: _211.LightBlock, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.LightBlock;
+            fromJSON(object: any): _211.LightBlock;
+            toJSON(message: _211.LightBlock): import("../json-safe.js").JsonSafe<_211.LightBlock>;
+            fromPartial(object: Partial<_211.LightBlock>): _211.LightBlock;
+            fromProtoMsg(message: _211.LightBlockProtoMsg): _211.LightBlock;
+            toProto(message: _211.LightBlock): Uint8Array;
+            toProtoMsg(message: _211.LightBlock): _211.LightBlockProtoMsg;
+        };
+        BlockMeta: {
+            typeUrl: string;
+            encode(message: _211.BlockMeta, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.BlockMeta;
+            fromJSON(object: any): _211.BlockMeta;
+            toJSON(message: _211.BlockMeta): import("../json-safe.js").JsonSafe<_211.BlockMeta>;
+            fromPartial(object: Partial<_211.BlockMeta>): _211.BlockMeta;
+            fromProtoMsg(message: _211.BlockMetaProtoMsg): _211.BlockMeta;
+            toProto(message: _211.BlockMeta): Uint8Array;
+            toProtoMsg(message: _211.BlockMeta): _211.BlockMetaProtoMsg;
+        };
+        TxProof: {
+            typeUrl: string;
+            encode(message: _211.TxProof, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _211.TxProof;
+            fromJSON(object: any): _211.TxProof;
+            toJSON(message: _211.TxProof): import("../json-safe.js").JsonSafe<_211.TxProof>;
+            fromPartial(object: Partial<_211.TxProof>): _211.TxProof;
+            fromProtoMsg(message: _211.TxProofProtoMsg): _211.TxProof;
+            toProto(message: _211.TxProof): Uint8Array;
+            toProtoMsg(message: _211.TxProof): _211.TxProofProtoMsg;
+        };
+        ConsensusParams: {
+            typeUrl: string;
+            encode(message: _210.ConsensusParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _210.ConsensusParams;
+            fromJSON(object: any): _210.ConsensusParams;
+            toJSON(message: _210.ConsensusParams): import("../json-safe.js").JsonSafe<_210.ConsensusParams>;
+            fromPartial(object: Partial<_210.ConsensusParams>): _210.ConsensusParams;
+            fromProtoMsg(message: _210.ConsensusParamsProtoMsg): _210.ConsensusParams;
+            toProto(message: _210.ConsensusParams): Uint8Array;
+            toProtoMsg(message: _210.ConsensusParams): _210.ConsensusParamsProtoMsg;
+        };
+        BlockParams: {
+            typeUrl: string;
+            encode(message: _210.BlockParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _210.BlockParams;
+            fromJSON(object: any): _210.BlockParams;
+            toJSON(message: _210.BlockParams): import("../json-safe.js").JsonSafe<_210.BlockParams>;
+            fromPartial(object: Partial<_210.BlockParams>): _210.BlockParams;
+            fromProtoMsg(message: _210.BlockParamsProtoMsg): _210.BlockParams;
+            toProto(message: _210.BlockParams): Uint8Array;
+            toProtoMsg(message: _210.BlockParams): _210.BlockParamsProtoMsg;
+        };
+        EvidenceParams: {
+            typeUrl: string;
+            encode(message: _210.EvidenceParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _210.EvidenceParams;
+            fromJSON(object: any): _210.EvidenceParams;
+            toJSON(message: _210.EvidenceParams): import("../json-safe.js").JsonSafe<_210.EvidenceParams>;
+            fromPartial(object: Partial<_210.EvidenceParams>): _210.EvidenceParams;
+            fromProtoMsg(message: _210.EvidenceParamsProtoMsg): _210.EvidenceParams;
+            toProto(message: _210.EvidenceParams): Uint8Array;
+            toProtoMsg(message: _210.EvidenceParams): _210.EvidenceParamsProtoMsg;
+        };
+        ValidatorParams: {
+            typeUrl: string;
+            encode(message: _210.ValidatorParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _210.ValidatorParams;
+            fromJSON(object: any): _210.ValidatorParams;
+            toJSON(message: _210.ValidatorParams): import("../json-safe.js").JsonSafe<_210.ValidatorParams>;
+            fromPartial(object: Partial<_210.ValidatorParams>): _210.ValidatorParams;
+            fromProtoMsg(message: _210.ValidatorParamsProtoMsg): _210.ValidatorParams;
+            toProto(message: _210.ValidatorParams): Uint8Array;
+            toProtoMsg(message: _210.ValidatorParams): _210.ValidatorParamsProtoMsg;
+        };
+        VersionParams: {
+            typeUrl: string;
+            encode(message: _210.VersionParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _210.VersionParams;
+            fromJSON(object: any): _210.VersionParams;
+            toJSON(message: _210.VersionParams): import("../json-safe.js").JsonSafe<_210.VersionParams>;
+            fromPartial(object: Partial<_210.VersionParams>): _210.VersionParams;
+            fromProtoMsg(message: _210.VersionParamsProtoMsg): _210.VersionParams;
+            toProto(message: _210.VersionParams): Uint8Array;
+            toProtoMsg(message: _210.VersionParams): _210.VersionParamsProtoMsg;
+        };
+        HashedParams: {
+            typeUrl: string;
+            encode(message: _210.HashedParams, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _210.HashedParams;
+            fromJSON(object: any): _210.HashedParams;
+            toJSON(message: _210.HashedParams): import("../json-safe.js").JsonSafe<_210.HashedParams>;
+            fromPartial(object: Partial<_210.HashedParams>): _210.HashedParams;
+            fromProtoMsg(message: _210.HashedParamsProtoMsg): _210.HashedParams;
+            toProto(message: _210.HashedParams): Uint8Array;
+            toProtoMsg(message: _210.HashedParams): _210.HashedParamsProtoMsg;
+        };
+        Evidence: {
+            typeUrl: string;
+            encode(message: _209.Evidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _209.Evidence;
+            fromJSON(object: any): _209.Evidence;
+            toJSON(message: _209.Evidence): import("../json-safe.js").JsonSafe<_209.Evidence>;
+            fromPartial(object: Partial<_209.Evidence>): _209.Evidence;
+            fromProtoMsg(message: _209.EvidenceProtoMsg): _209.Evidence;
+            toProto(message: _209.Evidence): Uint8Array;
+            toProtoMsg(message: _209.Evidence): _209.EvidenceProtoMsg;
+        };
+        DuplicateVoteEvidence: {
+            typeUrl: string;
+            encode(message: _209.DuplicateVoteEvidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _209.DuplicateVoteEvidence;
+            fromJSON(object: any): _209.DuplicateVoteEvidence;
+            toJSON(message: _209.DuplicateVoteEvidence): import("../json-safe.js").JsonSafe<_209.DuplicateVoteEvidence>;
+            fromPartial(object: Partial<_209.DuplicateVoteEvidence>): _209.DuplicateVoteEvidence;
+            fromProtoMsg(message: _209.DuplicateVoteEvidenceProtoMsg): _209.DuplicateVoteEvidence;
+            toProto(message: _209.DuplicateVoteEvidence): Uint8Array;
+            toProtoMsg(message: _209.DuplicateVoteEvidence): _209.DuplicateVoteEvidenceProtoMsg;
+        };
+        LightClientAttackEvidence: {
+            typeUrl: string;
+            encode(message: _209.LightClientAttackEvidence, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _209.LightClientAttackEvidence;
+            fromJSON(object: any): _209.LightClientAttackEvidence;
+            toJSON(message: _209.LightClientAttackEvidence): import("../json-safe.js").JsonSafe<_209.LightClientAttackEvidence>;
+            fromPartial(object: Partial<_209.LightClientAttackEvidence>): _209.LightClientAttackEvidence;
+            fromProtoMsg(message: _209.LightClientAttackEvidenceProtoMsg): _209.LightClientAttackEvidence;
+            toProto(message: _209.LightClientAttackEvidence): Uint8Array;
+            toProtoMsg(message: _209.LightClientAttackEvidence): _209.LightClientAttackEvidenceProtoMsg;
+        };
+        EvidenceList: {
+            typeUrl: string;
+            encode(message: _209.EvidenceList, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _209.EvidenceList;
+            fromJSON(object: any): _209.EvidenceList;
+            toJSON(message: _209.EvidenceList): import("../json-safe.js").JsonSafe<_209.EvidenceList>;
+            fromPartial(object: Partial<_209.EvidenceList>): _209.EvidenceList;
+            fromProtoMsg(message: _209.EvidenceListProtoMsg): _209.EvidenceList;
+            toProto(message: _209.EvidenceList): Uint8Array;
+            toProtoMsg(message: _209.EvidenceList): _209.EvidenceListProtoMsg;
+        };
+        Block: {
+            typeUrl: string;
+            encode(message: _208.Block, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _208.Block;
+            fromJSON(object: any): _208.Block;
+            toJSON(message: _208.Block): import("../json-safe.js").JsonSafe<_208.Block>;
+            fromPartial(object: Partial<_208.Block>): _208.Block;
+            fromProtoMsg(message: _208.BlockProtoMsg): _208.Block;
+            toProto(message: _208.Block): Uint8Array;
+            toProtoMsg(message: _208.Block): _208.BlockProtoMsg;
+        };
+    };
+    const version: {
+        App: {
+            typeUrl: string;
+            encode(message: _213.App, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _213.App;
+            fromJSON(object: any): _213.App;
+            toJSON(message: _213.App): import("../json-safe.js").JsonSafe<_213.App>;
+            fromPartial(object: Partial<_213.App>): _213.App;
+            fromProtoMsg(message: _213.AppProtoMsg): _213.App;
+            toProto(message: _213.App): Uint8Array;
+            toProtoMsg(message: _213.App): _213.AppProtoMsg;
+        };
+        Consensus: {
+            typeUrl: string;
+            encode(message: _213.Consensus, writer?: import("../binary.js").BinaryWriter): import("../binary.js").BinaryWriter;
+            decode(input: import("../binary.js").BinaryReader | Uint8Array, length?: number): _213.Consensus;
+            fromJSON(object: any): _213.Consensus;
+            toJSON(message: _213.Consensus): import("../json-safe.js").JsonSafe<_213.Consensus>;
+            fromPartial(object: Partial<_213.Consensus>): _213.Consensus;
+            fromProtoMsg(message: _213.ConsensusProtoMsg): _213.Consensus;
+            toProto(message: _213.Consensus): Uint8Array;
+            toProtoMsg(message: _213.Consensus): _213.ConsensusProtoMsg;
+        };
+    };
+}