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

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

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