@agoric/cosmic-proto 0.5.0-u21.0 → 0.5.0-u22.0

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

@@ -1,703 +1,1050 @@
-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';
+import * as _215 from './abci/types.js';
+import * as _216 from './crypto/keys.js';
+import * as _217 from './crypto/proof.js';
+import * as _218 from './libs/bits/types.js';
+import * as _219 from './p2p/types.js';
+import * as _220 from './types/block.js';
+import * as _221 from './types/evidence.js';
+import * as _222 from './types/params.js';
+import * as _223 from './types/types.js';
+import * as _224 from './types/validator.js';
+import * as _225 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;
+        checkTxTypeFromJSON(object: any): _215.CheckTxType;
+        checkTxTypeToJSON(object: _215.CheckTxType): string;
+        responseOfferSnapshot_ResultFromJSON(object: any): _215.ResponseOfferSnapshot_Result;
+        responseOfferSnapshot_ResultToJSON(object: _215.ResponseOfferSnapshot_Result): string;
+        responseApplySnapshotChunk_ResultFromJSON(object: any): _215.ResponseApplySnapshotChunk_Result;
+        responseApplySnapshotChunk_ResultToJSON(object: _215.ResponseApplySnapshotChunk_Result): string;
+        responseProcessProposal_ProposalStatusFromJSON(object: any): _215.ResponseProcessProposal_ProposalStatus;
+        responseProcessProposal_ProposalStatusToJSON(object: _215.ResponseProcessProposal_ProposalStatus): string;
+        responseVerifyVoteExtension_VerifyStatusFromJSON(object: any): _215.ResponseVerifyVoteExtension_VerifyStatus;
+        responseVerifyVoteExtension_VerifyStatusToJSON(object: _215.ResponseVerifyVoteExtension_VerifyStatus): string;
+        misbehaviorTypeFromJSON(object: any): _215.MisbehaviorType;
+        misbehaviorTypeToJSON(object: _215.MisbehaviorType): string;
+        CheckTxType: typeof _215.CheckTxType;
+        CheckTxTypeSDKType: typeof _215.CheckTxType;
+        ResponseOfferSnapshot_Result: typeof _215.ResponseOfferSnapshot_Result;
+        ResponseOfferSnapshot_ResultSDKType: typeof _215.ResponseOfferSnapshot_Result;
+        ResponseApplySnapshotChunk_Result: typeof _215.ResponseApplySnapshotChunk_Result;
+        ResponseApplySnapshotChunk_ResultSDKType: typeof _215.ResponseApplySnapshotChunk_Result;
+        ResponseProcessProposal_ProposalStatus: typeof _215.ResponseProcessProposal_ProposalStatus;
+        ResponseProcessProposal_ProposalStatusSDKType: typeof _215.ResponseProcessProposal_ProposalStatus;
+        ResponseVerifyVoteExtension_VerifyStatus: typeof _215.ResponseVerifyVoteExtension_VerifyStatus;
+        ResponseVerifyVoteExtension_VerifyStatusSDKType: typeof _215.ResponseVerifyVoteExtension_VerifyStatus;
+        MisbehaviorType: typeof _215.MisbehaviorType;
+        MisbehaviorTypeSDKType: typeof _215.MisbehaviorType;
+        Request: {
+            typeUrl: "/tendermint.abci.Request";
+            encode(message: _215.Request, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.Request;
+            fromJSON(object: any): _215.Request;
+            toJSON(message: _215.Request): import("../json-safe.ts").JsonSafe<_215.Request>;
+            fromPartial(object: Partial<_215.Request>): _215.Request;
+            fromProtoMsg(message: _215.RequestProtoMsg): _215.Request;
+            toProto(message: _215.Request): Uint8Array;
+            toProtoMsg(message: _215.Request): _215.RequestProtoMsg;
+        };
+        RequestEcho: {
+            typeUrl: "/tendermint.abci.RequestEcho";
+            encode(message: _215.RequestEcho, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestEcho;
+            fromJSON(object: any): _215.RequestEcho;
+            toJSON(message: _215.RequestEcho): import("../json-safe.ts").JsonSafe<_215.RequestEcho>;
+            fromPartial(object: Partial<_215.RequestEcho>): _215.RequestEcho;
+            fromProtoMsg(message: _215.RequestEchoProtoMsg): _215.RequestEcho;
+            toProto(message: _215.RequestEcho): Uint8Array;
+            toProtoMsg(message: _215.RequestEcho): _215.RequestEchoProtoMsg;
+        };
+        RequestFlush: {
+            typeUrl: "/tendermint.abci.RequestFlush";
+            encode(_: _215.RequestFlush, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestFlush;
+            fromJSON(_: any): _215.RequestFlush;
+            toJSON(_: _215.RequestFlush): import("../json-safe.ts").JsonSafe<_215.RequestFlush>;
+            fromPartial(_: Partial<_215.RequestFlush>): _215.RequestFlush;
+            fromProtoMsg(message: _215.RequestFlushProtoMsg): _215.RequestFlush;
+            toProto(message: _215.RequestFlush): Uint8Array;
+            toProtoMsg(message: _215.RequestFlush): _215.RequestFlushProtoMsg;
+        };
+        RequestInfo: {
+            typeUrl: "/tendermint.abci.RequestInfo";
+            encode(message: _215.RequestInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestInfo;
+            fromJSON(object: any): _215.RequestInfo;
+            toJSON(message: _215.RequestInfo): import("../json-safe.ts").JsonSafe<_215.RequestInfo>;
+            fromPartial(object: Partial<_215.RequestInfo>): _215.RequestInfo;
+            fromProtoMsg(message: _215.RequestInfoProtoMsg): _215.RequestInfo;
+            toProto(message: _215.RequestInfo): Uint8Array;
+            toProtoMsg(message: _215.RequestInfo): _215.RequestInfoProtoMsg;
+        };
+        RequestInitChain: {
+            typeUrl: "/tendermint.abci.RequestInitChain";
+            encode(message: _215.RequestInitChain, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestInitChain;
+            fromJSON(object: any): _215.RequestInitChain;
+            toJSON(message: _215.RequestInitChain): import("../json-safe.ts").JsonSafe<_215.RequestInitChain>;
+            fromPartial(object: Partial<_215.RequestInitChain>): _215.RequestInitChain;
+            fromProtoMsg(message: _215.RequestInitChainProtoMsg): _215.RequestInitChain;
+            toProto(message: _215.RequestInitChain): Uint8Array;
+            toProtoMsg(message: _215.RequestInitChain): _215.RequestInitChainProtoMsg;
+        };
         RequestQuery: {
-            typeUrl: string;
-            encode(message: _203.RequestQuery, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestQuery;
-            fromJSON(object: any): _203.RequestQuery;
-            toJSON(message: _203.RequestQuery): import("../json-safe.ts").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.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestBeginBlock;
-            fromJSON(object: any): _203.RequestBeginBlock;
-            toJSON(message: _203.RequestBeginBlock): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.RequestQuery";
+            encode(message: _215.RequestQuery, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestQuery;
+            fromJSON(object: any): _215.RequestQuery;
+            toJSON(message: _215.RequestQuery): import("../json-safe.ts").JsonSafe<_215.RequestQuery>;
+            fromPartial(object: Partial<_215.RequestQuery>): _215.RequestQuery;
+            fromProtoMsg(message: _215.RequestQueryProtoMsg): _215.RequestQuery;
+            toProto(message: _215.RequestQuery): Uint8Array;
+            toProtoMsg(message: _215.RequestQuery): _215.RequestQueryProtoMsg;
         };
         RequestCheckTx: {
-            typeUrl: string;
-            encode(message: _203.RequestCheckTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestCheckTx;
-            fromJSON(object: any): _203.RequestCheckTx;
-            toJSON(message: _203.RequestCheckTx): import("../json-safe.ts").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.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestDeliverTx;
-            fromJSON(object: any): _203.RequestDeliverTx;
-            toJSON(message: _203.RequestDeliverTx): import("../json-safe.ts").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.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestEndBlock;
-            fromJSON(object: any): _203.RequestEndBlock;
-            toJSON(message: _203.RequestEndBlock): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.RequestCheckTx";
+            encode(message: _215.RequestCheckTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestCheckTx;
+            fromJSON(object: any): _215.RequestCheckTx;
+            toJSON(message: _215.RequestCheckTx): import("../json-safe.ts").JsonSafe<_215.RequestCheckTx>;
+            fromPartial(object: Partial<_215.RequestCheckTx>): _215.RequestCheckTx;
+            fromProtoMsg(message: _215.RequestCheckTxProtoMsg): _215.RequestCheckTx;
+            toProto(message: _215.RequestCheckTx): Uint8Array;
+            toProtoMsg(message: _215.RequestCheckTx): _215.RequestCheckTxProtoMsg;
         };
         RequestCommit: {
-            typeUrl: string;
-            encode(_: _203.RequestCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.RequestCommit;
-            fromJSON(_: any): _203.RequestCommit;
-            toJSON(_: _203.RequestCommit): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.RequestCommit";
+            encode(_: _215.RequestCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestCommit;
+            fromJSON(_: any): _215.RequestCommit;
+            toJSON(_: _215.RequestCommit): import("../json-safe.ts").JsonSafe<_215.RequestCommit>;
+            fromPartial(_: Partial<_215.RequestCommit>): _215.RequestCommit;
+            fromProtoMsg(message: _215.RequestCommitProtoMsg): _215.RequestCommit;
+            toProto(message: _215.RequestCommit): Uint8Array;
+            toProtoMsg(message: _215.RequestCommit): _215.RequestCommitProtoMsg;
+        };
+        RequestListSnapshots: {
+            typeUrl: "/tendermint.abci.RequestListSnapshots";
+            encode(_: _215.RequestListSnapshots, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestListSnapshots;
+            fromJSON(_: any): _215.RequestListSnapshots;
+            toJSON(_: _215.RequestListSnapshots): import("../json-safe.ts").JsonSafe<_215.RequestListSnapshots>;
+            fromPartial(_: Partial<_215.RequestListSnapshots>): _215.RequestListSnapshots;
+            fromProtoMsg(message: _215.RequestListSnapshotsProtoMsg): _215.RequestListSnapshots;
+            toProto(message: _215.RequestListSnapshots): Uint8Array;
+            toProtoMsg(message: _215.RequestListSnapshots): _215.RequestListSnapshotsProtoMsg;
+        };
+        RequestOfferSnapshot: {
+            typeUrl: "/tendermint.abci.RequestOfferSnapshot";
+            encode(message: _215.RequestOfferSnapshot, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestOfferSnapshot;
+            fromJSON(object: any): _215.RequestOfferSnapshot;
+            toJSON(message: _215.RequestOfferSnapshot): import("../json-safe.ts").JsonSafe<_215.RequestOfferSnapshot>;
+            fromPartial(object: Partial<_215.RequestOfferSnapshot>): _215.RequestOfferSnapshot;
+            fromProtoMsg(message: _215.RequestOfferSnapshotProtoMsg): _215.RequestOfferSnapshot;
+            toProto(message: _215.RequestOfferSnapshot): Uint8Array;
+            toProtoMsg(message: _215.RequestOfferSnapshot): _215.RequestOfferSnapshotProtoMsg;
+        };
+        RequestLoadSnapshotChunk: {
+            typeUrl: "/tendermint.abci.RequestLoadSnapshotChunk";
+            encode(message: _215.RequestLoadSnapshotChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestLoadSnapshotChunk;
+            fromJSON(object: any): _215.RequestLoadSnapshotChunk;
+            toJSON(message: _215.RequestLoadSnapshotChunk): import("../json-safe.ts").JsonSafe<_215.RequestLoadSnapshotChunk>;
+            fromPartial(object: Partial<_215.RequestLoadSnapshotChunk>): _215.RequestLoadSnapshotChunk;
+            fromProtoMsg(message: _215.RequestLoadSnapshotChunkProtoMsg): _215.RequestLoadSnapshotChunk;
+            toProto(message: _215.RequestLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: _215.RequestLoadSnapshotChunk): _215.RequestLoadSnapshotChunkProtoMsg;
+        };
+        RequestApplySnapshotChunk: {
+            typeUrl: "/tendermint.abci.RequestApplySnapshotChunk";
+            encode(message: _215.RequestApplySnapshotChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestApplySnapshotChunk;
+            fromJSON(object: any): _215.RequestApplySnapshotChunk;
+            toJSON(message: _215.RequestApplySnapshotChunk): import("../json-safe.ts").JsonSafe<_215.RequestApplySnapshotChunk>;
+            fromPartial(object: Partial<_215.RequestApplySnapshotChunk>): _215.RequestApplySnapshotChunk;
+            fromProtoMsg(message: _215.RequestApplySnapshotChunkProtoMsg): _215.RequestApplySnapshotChunk;
+            toProto(message: _215.RequestApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: _215.RequestApplySnapshotChunk): _215.RequestApplySnapshotChunkProtoMsg;
+        };
+        RequestPrepareProposal: {
+            typeUrl: "/tendermint.abci.RequestPrepareProposal";
+            encode(message: _215.RequestPrepareProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestPrepareProposal;
+            fromJSON(object: any): _215.RequestPrepareProposal;
+            toJSON(message: _215.RequestPrepareProposal): import("../json-safe.ts").JsonSafe<_215.RequestPrepareProposal>;
+            fromPartial(object: Partial<_215.RequestPrepareProposal>): _215.RequestPrepareProposal;
+            fromProtoMsg(message: _215.RequestPrepareProposalProtoMsg): _215.RequestPrepareProposal;
+            toProto(message: _215.RequestPrepareProposal): Uint8Array;
+            toProtoMsg(message: _215.RequestPrepareProposal): _215.RequestPrepareProposalProtoMsg;
+        };
+        RequestProcessProposal: {
+            typeUrl: "/tendermint.abci.RequestProcessProposal";
+            encode(message: _215.RequestProcessProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestProcessProposal;
+            fromJSON(object: any): _215.RequestProcessProposal;
+            toJSON(message: _215.RequestProcessProposal): import("../json-safe.ts").JsonSafe<_215.RequestProcessProposal>;
+            fromPartial(object: Partial<_215.RequestProcessProposal>): _215.RequestProcessProposal;
+            fromProtoMsg(message: _215.RequestProcessProposalProtoMsg): _215.RequestProcessProposal;
+            toProto(message: _215.RequestProcessProposal): Uint8Array;
+            toProtoMsg(message: _215.RequestProcessProposal): _215.RequestProcessProposalProtoMsg;
+        };
+        RequestExtendVote: {
+            typeUrl: "/tendermint.abci.RequestExtendVote";
+            encode(message: _215.RequestExtendVote, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestExtendVote;
+            fromJSON(object: any): _215.RequestExtendVote;
+            toJSON(message: _215.RequestExtendVote): import("../json-safe.ts").JsonSafe<_215.RequestExtendVote>;
+            fromPartial(object: Partial<_215.RequestExtendVote>): _215.RequestExtendVote;
+            fromProtoMsg(message: _215.RequestExtendVoteProtoMsg): _215.RequestExtendVote;
+            toProto(message: _215.RequestExtendVote): Uint8Array;
+            toProtoMsg(message: _215.RequestExtendVote): _215.RequestExtendVoteProtoMsg;
+        };
+        RequestVerifyVoteExtension: {
+            typeUrl: "/tendermint.abci.RequestVerifyVoteExtension";
+            encode(message: _215.RequestVerifyVoteExtension, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestVerifyVoteExtension;
+            fromJSON(object: any): _215.RequestVerifyVoteExtension;
+            toJSON(message: _215.RequestVerifyVoteExtension): import("../json-safe.ts").JsonSafe<_215.RequestVerifyVoteExtension>;
+            fromPartial(object: Partial<_215.RequestVerifyVoteExtension>): _215.RequestVerifyVoteExtension;
+            fromProtoMsg(message: _215.RequestVerifyVoteExtensionProtoMsg): _215.RequestVerifyVoteExtension;
+            toProto(message: _215.RequestVerifyVoteExtension): Uint8Array;
+            toProtoMsg(message: _215.RequestVerifyVoteExtension): _215.RequestVerifyVoteExtensionProtoMsg;
+        };
+        RequestFinalizeBlock: {
+            typeUrl: "/tendermint.abci.RequestFinalizeBlock";
+            encode(message: _215.RequestFinalizeBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.RequestFinalizeBlock;
+            fromJSON(object: any): _215.RequestFinalizeBlock;
+            toJSON(message: _215.RequestFinalizeBlock): import("../json-safe.ts").JsonSafe<_215.RequestFinalizeBlock>;
+            fromPartial(object: Partial<_215.RequestFinalizeBlock>): _215.RequestFinalizeBlock;
+            fromProtoMsg(message: _215.RequestFinalizeBlockProtoMsg): _215.RequestFinalizeBlock;
+            toProto(message: _215.RequestFinalizeBlock): Uint8Array;
+            toProtoMsg(message: _215.RequestFinalizeBlock): _215.RequestFinalizeBlockProtoMsg;
+        };
+        Response: {
+            typeUrl: "/tendermint.abci.Response";
+            encode(message: _215.Response, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.Response;
+            fromJSON(object: any): _215.Response;
+            toJSON(message: _215.Response): import("../json-safe.ts").JsonSafe<_215.Response>;
+            fromPartial(object: Partial<_215.Response>): _215.Response;
+            fromProtoMsg(message: _215.ResponseProtoMsg): _215.Response;
+            toProto(message: _215.Response): Uint8Array;
+            toProtoMsg(message: _215.Response): _215.ResponseProtoMsg;
+        };
+        ResponseException: {
+            typeUrl: "/tendermint.abci.ResponseException";
+            encode(message: _215.ResponseException, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseException;
+            fromJSON(object: any): _215.ResponseException;
+            toJSON(message: _215.ResponseException): import("../json-safe.ts").JsonSafe<_215.ResponseException>;
+            fromPartial(object: Partial<_215.ResponseException>): _215.ResponseException;
+            fromProtoMsg(message: _215.ResponseExceptionProtoMsg): _215.ResponseException;
+            toProto(message: _215.ResponseException): Uint8Array;
+            toProtoMsg(message: _215.ResponseException): _215.ResponseExceptionProtoMsg;
+        };
+        ResponseEcho: {
+            typeUrl: "/tendermint.abci.ResponseEcho";
+            encode(message: _215.ResponseEcho, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseEcho;
+            fromJSON(object: any): _215.ResponseEcho;
+            toJSON(message: _215.ResponseEcho): import("../json-safe.ts").JsonSafe<_215.ResponseEcho>;
+            fromPartial(object: Partial<_215.ResponseEcho>): _215.ResponseEcho;
+            fromProtoMsg(message: _215.ResponseEchoProtoMsg): _215.ResponseEcho;
+            toProto(message: _215.ResponseEcho): Uint8Array;
+            toProtoMsg(message: _215.ResponseEcho): _215.ResponseEchoProtoMsg;
+        };
+        ResponseFlush: {
+            typeUrl: "/tendermint.abci.ResponseFlush";
+            encode(_: _215.ResponseFlush, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseFlush;
+            fromJSON(_: any): _215.ResponseFlush;
+            toJSON(_: _215.ResponseFlush): import("../json-safe.ts").JsonSafe<_215.ResponseFlush>;
+            fromPartial(_: Partial<_215.ResponseFlush>): _215.ResponseFlush;
+            fromProtoMsg(message: _215.ResponseFlushProtoMsg): _215.ResponseFlush;
+            toProto(message: _215.ResponseFlush): Uint8Array;
+            toProtoMsg(message: _215.ResponseFlush): _215.ResponseFlushProtoMsg;
+        };
+        ResponseInfo: {
+            typeUrl: "/tendermint.abci.ResponseInfo";
+            encode(message: _215.ResponseInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseInfo;
+            fromJSON(object: any): _215.ResponseInfo;
+            toJSON(message: _215.ResponseInfo): import("../json-safe.ts").JsonSafe<_215.ResponseInfo>;
+            fromPartial(object: Partial<_215.ResponseInfo>): _215.ResponseInfo;
+            fromProtoMsg(message: _215.ResponseInfoProtoMsg): _215.ResponseInfo;
+            toProto(message: _215.ResponseInfo): Uint8Array;
+            toProtoMsg(message: _215.ResponseInfo): _215.ResponseInfoProtoMsg;
+        };
+        ResponseInitChain: {
+            typeUrl: "/tendermint.abci.ResponseInitChain";
+            encode(message: _215.ResponseInitChain, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseInitChain;
+            fromJSON(object: any): _215.ResponseInitChain;
+            toJSON(message: _215.ResponseInitChain): import("../json-safe.ts").JsonSafe<_215.ResponseInitChain>;
+            fromPartial(object: Partial<_215.ResponseInitChain>): _215.ResponseInitChain;
+            fromProtoMsg(message: _215.ResponseInitChainProtoMsg): _215.ResponseInitChain;
+            toProto(message: _215.ResponseInitChain): Uint8Array;
+            toProtoMsg(message: _215.ResponseInitChain): _215.ResponseInitChainProtoMsg;
         };
         ResponseQuery: {
-            typeUrl: string;
-            encode(message: _203.ResponseQuery, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseQuery;
-            fromJSON(object: any): _203.ResponseQuery;
-            toJSON(message: _203.ResponseQuery): import("../json-safe.ts").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.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseBeginBlock;
-            fromJSON(object: any): _203.ResponseBeginBlock;
-            toJSON(message: _203.ResponseBeginBlock): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.ResponseQuery";
+            encode(message: _215.ResponseQuery, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseQuery;
+            fromJSON(object: any): _215.ResponseQuery;
+            toJSON(message: _215.ResponseQuery): import("../json-safe.ts").JsonSafe<_215.ResponseQuery>;
+            fromPartial(object: Partial<_215.ResponseQuery>): _215.ResponseQuery;
+            fromProtoMsg(message: _215.ResponseQueryProtoMsg): _215.ResponseQuery;
+            toProto(message: _215.ResponseQuery): Uint8Array;
+            toProtoMsg(message: _215.ResponseQuery): _215.ResponseQueryProtoMsg;
         };
         ResponseCheckTx: {
-            typeUrl: string;
-            encode(message: _203.ResponseCheckTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseCheckTx;
-            fromJSON(object: any): _203.ResponseCheckTx;
-            toJSON(message: _203.ResponseCheckTx): import("../json-safe.ts").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.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseDeliverTx;
-            fromJSON(object: any): _203.ResponseDeliverTx;
-            toJSON(message: _203.ResponseDeliverTx): import("../json-safe.ts").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.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseEndBlock;
-            fromJSON(object: any): _203.ResponseEndBlock;
-            toJSON(message: _203.ResponseEndBlock): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.ResponseCheckTx";
+            encode(message: _215.ResponseCheckTx, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseCheckTx;
+            fromJSON(object: any): _215.ResponseCheckTx;
+            toJSON(message: _215.ResponseCheckTx): import("../json-safe.ts").JsonSafe<_215.ResponseCheckTx>;
+            fromPartial(object: Partial<_215.ResponseCheckTx>): _215.ResponseCheckTx;
+            fromProtoMsg(message: _215.ResponseCheckTxProtoMsg): _215.ResponseCheckTx;
+            toProto(message: _215.ResponseCheckTx): Uint8Array;
+            toProtoMsg(message: _215.ResponseCheckTx): _215.ResponseCheckTxProtoMsg;
         };
         ResponseCommit: {
-            typeUrl: string;
-            encode(message: _203.ResponseCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ResponseCommit;
-            fromJSON(object: any): _203.ResponseCommit;
-            toJSON(message: _203.ResponseCommit): import("../json-safe.ts").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.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.LastCommitInfo;
-            fromJSON(object: any): _203.LastCommitInfo;
-            toJSON(message: _203.LastCommitInfo): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.ResponseCommit";
+            encode(message: _215.ResponseCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseCommit;
+            fromJSON(object: any): _215.ResponseCommit;
+            toJSON(message: _215.ResponseCommit): import("../json-safe.ts").JsonSafe<_215.ResponseCommit>;
+            fromPartial(object: Partial<_215.ResponseCommit>): _215.ResponseCommit;
+            fromProtoMsg(message: _215.ResponseCommitProtoMsg): _215.ResponseCommit;
+            toProto(message: _215.ResponseCommit): Uint8Array;
+            toProtoMsg(message: _215.ResponseCommit): _215.ResponseCommitProtoMsg;
+        };
+        ResponseListSnapshots: {
+            typeUrl: "/tendermint.abci.ResponseListSnapshots";
+            encode(message: _215.ResponseListSnapshots, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseListSnapshots;
+            fromJSON(object: any): _215.ResponseListSnapshots;
+            toJSON(message: _215.ResponseListSnapshots): import("../json-safe.ts").JsonSafe<_215.ResponseListSnapshots>;
+            fromPartial(object: Partial<_215.ResponseListSnapshots>): _215.ResponseListSnapshots;
+            fromProtoMsg(message: _215.ResponseListSnapshotsProtoMsg): _215.ResponseListSnapshots;
+            toProto(message: _215.ResponseListSnapshots): Uint8Array;
+            toProtoMsg(message: _215.ResponseListSnapshots): _215.ResponseListSnapshotsProtoMsg;
+        };
+        ResponseOfferSnapshot: {
+            typeUrl: "/tendermint.abci.ResponseOfferSnapshot";
+            encode(message: _215.ResponseOfferSnapshot, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseOfferSnapshot;
+            fromJSON(object: any): _215.ResponseOfferSnapshot;
+            toJSON(message: _215.ResponseOfferSnapshot): import("../json-safe.ts").JsonSafe<_215.ResponseOfferSnapshot>;
+            fromPartial(object: Partial<_215.ResponseOfferSnapshot>): _215.ResponseOfferSnapshot;
+            fromProtoMsg(message: _215.ResponseOfferSnapshotProtoMsg): _215.ResponseOfferSnapshot;
+            toProto(message: _215.ResponseOfferSnapshot): Uint8Array;
+            toProtoMsg(message: _215.ResponseOfferSnapshot): _215.ResponseOfferSnapshotProtoMsg;
+        };
+        ResponseLoadSnapshotChunk: {
+            typeUrl: "/tendermint.abci.ResponseLoadSnapshotChunk";
+            encode(message: _215.ResponseLoadSnapshotChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseLoadSnapshotChunk;
+            fromJSON(object: any): _215.ResponseLoadSnapshotChunk;
+            toJSON(message: _215.ResponseLoadSnapshotChunk): import("../json-safe.ts").JsonSafe<_215.ResponseLoadSnapshotChunk>;
+            fromPartial(object: Partial<_215.ResponseLoadSnapshotChunk>): _215.ResponseLoadSnapshotChunk;
+            fromProtoMsg(message: _215.ResponseLoadSnapshotChunkProtoMsg): _215.ResponseLoadSnapshotChunk;
+            toProto(message: _215.ResponseLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: _215.ResponseLoadSnapshotChunk): _215.ResponseLoadSnapshotChunkProtoMsg;
+        };
+        ResponseApplySnapshotChunk: {
+            typeUrl: "/tendermint.abci.ResponseApplySnapshotChunk";
+            encode(message: _215.ResponseApplySnapshotChunk, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseApplySnapshotChunk;
+            fromJSON(object: any): _215.ResponseApplySnapshotChunk;
+            toJSON(message: _215.ResponseApplySnapshotChunk): import("../json-safe.ts").JsonSafe<_215.ResponseApplySnapshotChunk>;
+            fromPartial(object: Partial<_215.ResponseApplySnapshotChunk>): _215.ResponseApplySnapshotChunk;
+            fromProtoMsg(message: _215.ResponseApplySnapshotChunkProtoMsg): _215.ResponseApplySnapshotChunk;
+            toProto(message: _215.ResponseApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: _215.ResponseApplySnapshotChunk): _215.ResponseApplySnapshotChunkProtoMsg;
+        };
+        ResponsePrepareProposal: {
+            typeUrl: "/tendermint.abci.ResponsePrepareProposal";
+            encode(message: _215.ResponsePrepareProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponsePrepareProposal;
+            fromJSON(object: any): _215.ResponsePrepareProposal;
+            toJSON(message: _215.ResponsePrepareProposal): import("../json-safe.ts").JsonSafe<_215.ResponsePrepareProposal>;
+            fromPartial(object: Partial<_215.ResponsePrepareProposal>): _215.ResponsePrepareProposal;
+            fromProtoMsg(message: _215.ResponsePrepareProposalProtoMsg): _215.ResponsePrepareProposal;
+            toProto(message: _215.ResponsePrepareProposal): Uint8Array;
+            toProtoMsg(message: _215.ResponsePrepareProposal): _215.ResponsePrepareProposalProtoMsg;
+        };
+        ResponseProcessProposal: {
+            typeUrl: "/tendermint.abci.ResponseProcessProposal";
+            encode(message: _215.ResponseProcessProposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseProcessProposal;
+            fromJSON(object: any): _215.ResponseProcessProposal;
+            toJSON(message: _215.ResponseProcessProposal): import("../json-safe.ts").JsonSafe<_215.ResponseProcessProposal>;
+            fromPartial(object: Partial<_215.ResponseProcessProposal>): _215.ResponseProcessProposal;
+            fromProtoMsg(message: _215.ResponseProcessProposalProtoMsg): _215.ResponseProcessProposal;
+            toProto(message: _215.ResponseProcessProposal): Uint8Array;
+            toProtoMsg(message: _215.ResponseProcessProposal): _215.ResponseProcessProposalProtoMsg;
+        };
+        ResponseExtendVote: {
+            typeUrl: "/tendermint.abci.ResponseExtendVote";
+            encode(message: _215.ResponseExtendVote, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseExtendVote;
+            fromJSON(object: any): _215.ResponseExtendVote;
+            toJSON(message: _215.ResponseExtendVote): import("../json-safe.ts").JsonSafe<_215.ResponseExtendVote>;
+            fromPartial(object: Partial<_215.ResponseExtendVote>): _215.ResponseExtendVote;
+            fromProtoMsg(message: _215.ResponseExtendVoteProtoMsg): _215.ResponseExtendVote;
+            toProto(message: _215.ResponseExtendVote): Uint8Array;
+            toProtoMsg(message: _215.ResponseExtendVote): _215.ResponseExtendVoteProtoMsg;
+        };
+        ResponseVerifyVoteExtension: {
+            typeUrl: "/tendermint.abci.ResponseVerifyVoteExtension";
+            encode(message: _215.ResponseVerifyVoteExtension, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseVerifyVoteExtension;
+            fromJSON(object: any): _215.ResponseVerifyVoteExtension;
+            toJSON(message: _215.ResponseVerifyVoteExtension): import("../json-safe.ts").JsonSafe<_215.ResponseVerifyVoteExtension>;
+            fromPartial(object: Partial<_215.ResponseVerifyVoteExtension>): _215.ResponseVerifyVoteExtension;
+            fromProtoMsg(message: _215.ResponseVerifyVoteExtensionProtoMsg): _215.ResponseVerifyVoteExtension;
+            toProto(message: _215.ResponseVerifyVoteExtension): Uint8Array;
+            toProtoMsg(message: _215.ResponseVerifyVoteExtension): _215.ResponseVerifyVoteExtensionProtoMsg;
+        };
+        ResponseFinalizeBlock: {
+            typeUrl: "/tendermint.abci.ResponseFinalizeBlock";
+            encode(message: _215.ResponseFinalizeBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ResponseFinalizeBlock;
+            fromJSON(object: any): _215.ResponseFinalizeBlock;
+            toJSON(message: _215.ResponseFinalizeBlock): import("../json-safe.ts").JsonSafe<_215.ResponseFinalizeBlock>;
+            fromPartial(object: Partial<_215.ResponseFinalizeBlock>): _215.ResponseFinalizeBlock;
+            fromProtoMsg(message: _215.ResponseFinalizeBlockProtoMsg): _215.ResponseFinalizeBlock;
+            toProto(message: _215.ResponseFinalizeBlock): Uint8Array;
+            toProtoMsg(message: _215.ResponseFinalizeBlock): _215.ResponseFinalizeBlockProtoMsg;
+        };
+        CommitInfo: {
+            typeUrl: "/tendermint.abci.CommitInfo";
+            encode(message: _215.CommitInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.CommitInfo;
+            fromJSON(object: any): _215.CommitInfo;
+            toJSON(message: _215.CommitInfo): import("../json-safe.ts").JsonSafe<_215.CommitInfo>;
+            fromPartial(object: Partial<_215.CommitInfo>): _215.CommitInfo;
+            fromProtoMsg(message: _215.CommitInfoProtoMsg): _215.CommitInfo;
+            toProto(message: _215.CommitInfo): Uint8Array;
+            toProtoMsg(message: _215.CommitInfo): _215.CommitInfoProtoMsg;
+        };
+        ExtendedCommitInfo: {
+            typeUrl: "/tendermint.abci.ExtendedCommitInfo";
+            encode(message: _215.ExtendedCommitInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ExtendedCommitInfo;
+            fromJSON(object: any): _215.ExtendedCommitInfo;
+            toJSON(message: _215.ExtendedCommitInfo): import("../json-safe.ts").JsonSafe<_215.ExtendedCommitInfo>;
+            fromPartial(object: Partial<_215.ExtendedCommitInfo>): _215.ExtendedCommitInfo;
+            fromProtoMsg(message: _215.ExtendedCommitInfoProtoMsg): _215.ExtendedCommitInfo;
+            toProto(message: _215.ExtendedCommitInfo): Uint8Array;
+            toProtoMsg(message: _215.ExtendedCommitInfo): _215.ExtendedCommitInfoProtoMsg;
         };
         Event: {
-            typeUrl: string;
-            encode(message: _203.Event, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.Event;
-            fromJSON(object: any): _203.Event;
-            toJSON(message: _203.Event): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.Event";
+            encode(message: _215.Event, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.Event;
+            fromJSON(object: any): _215.Event;
+            toJSON(message: _215.Event): import("../json-safe.ts").JsonSafe<_215.Event>;
+            fromPartial(object: Partial<_215.Event>): _215.Event;
+            fromProtoMsg(message: _215.EventProtoMsg): _215.Event;
+            toProto(message: _215.Event): Uint8Array;
+            toProtoMsg(message: _215.Event): _215.EventProtoMsg;
         };
         EventAttribute: {
-            typeUrl: string;
-            encode(message: _203.EventAttribute, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.EventAttribute;
-            fromJSON(object: any): _203.EventAttribute;
-            toJSON(message: _203.EventAttribute): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.EventAttribute";
+            encode(message: _215.EventAttribute, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.EventAttribute;
+            fromJSON(object: any): _215.EventAttribute;
+            toJSON(message: _215.EventAttribute): import("../json-safe.ts").JsonSafe<_215.EventAttribute>;
+            fromPartial(object: Partial<_215.EventAttribute>): _215.EventAttribute;
+            fromProtoMsg(message: _215.EventAttributeProtoMsg): _215.EventAttribute;
+            toProto(message: _215.EventAttribute): Uint8Array;
+            toProtoMsg(message: _215.EventAttribute): _215.EventAttributeProtoMsg;
+        };
+        ExecTxResult: {
+            typeUrl: "/tendermint.abci.ExecTxResult";
+            encode(message: _215.ExecTxResult, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ExecTxResult;
+            fromJSON(object: any): _215.ExecTxResult;
+            toJSON(message: _215.ExecTxResult): import("../json-safe.ts").JsonSafe<_215.ExecTxResult>;
+            fromPartial(object: Partial<_215.ExecTxResult>): _215.ExecTxResult;
+            fromProtoMsg(message: _215.ExecTxResultProtoMsg): _215.ExecTxResult;
+            toProto(message: _215.ExecTxResult): Uint8Array;
+            toProtoMsg(message: _215.ExecTxResult): _215.ExecTxResultProtoMsg;
         };
         TxResult: {
-            typeUrl: string;
-            encode(message: _203.TxResult, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.TxResult;
-            fromJSON(object: any): _203.TxResult;
-            toJSON(message: _203.TxResult): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.TxResult";
+            encode(message: _215.TxResult, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.TxResult;
+            fromJSON(object: any): _215.TxResult;
+            toJSON(message: _215.TxResult): import("../json-safe.ts").JsonSafe<_215.TxResult>;
+            fromPartial(object: Partial<_215.TxResult>): _215.TxResult;
+            fromProtoMsg(message: _215.TxResultProtoMsg): _215.TxResult;
+            toProto(message: _215.TxResult): Uint8Array;
+            toProtoMsg(message: _215.TxResult): _215.TxResultProtoMsg;
         };
         Validator: {
-            typeUrl: string;
-            encode(message: _203.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.Validator;
-            fromJSON(object: any): _203.Validator;
-            toJSON(message: _203.Validator): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.Validator";
+            encode(message: _215.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.Validator;
+            fromJSON(object: any): _215.Validator;
+            toJSON(message: _215.Validator): import("../json-safe.ts").JsonSafe<_215.Validator>;
+            fromPartial(object: Partial<_215.Validator>): _215.Validator;
+            fromProtoMsg(message: _215.ValidatorProtoMsg): _215.Validator;
+            toProto(message: _215.Validator): Uint8Array;
+            toProtoMsg(message: _215.Validator): _215.ValidatorProtoMsg;
         };
         ValidatorUpdate: {
-            typeUrl: string;
-            encode(message: _203.ValidatorUpdate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.ValidatorUpdate;
-            fromJSON(object: any): _203.ValidatorUpdate;
-            toJSON(message: _203.ValidatorUpdate): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.ValidatorUpdate";
+            encode(message: _215.ValidatorUpdate, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ValidatorUpdate;
+            fromJSON(object: any): _215.ValidatorUpdate;
+            toJSON(message: _215.ValidatorUpdate): import("../json-safe.ts").JsonSafe<_215.ValidatorUpdate>;
+            fromPartial(object: Partial<_215.ValidatorUpdate>): _215.ValidatorUpdate;
+            fromProtoMsg(message: _215.ValidatorUpdateProtoMsg): _215.ValidatorUpdate;
+            toProto(message: _215.ValidatorUpdate): Uint8Array;
+            toProtoMsg(message: _215.ValidatorUpdate): _215.ValidatorUpdateProtoMsg;
         };
         VoteInfo: {
-            typeUrl: string;
-            encode(message: _203.VoteInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.VoteInfo;
-            fromJSON(object: any): _203.VoteInfo;
-            toJSON(message: _203.VoteInfo): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.abci.VoteInfo";
+            encode(message: _215.VoteInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.VoteInfo;
+            fromJSON(object: any): _215.VoteInfo;
+            toJSON(message: _215.VoteInfo): import("../json-safe.ts").JsonSafe<_215.VoteInfo>;
+            fromPartial(object: Partial<_215.VoteInfo>): _215.VoteInfo;
+            fromProtoMsg(message: _215.VoteInfoProtoMsg): _215.VoteInfo;
+            toProto(message: _215.VoteInfo): Uint8Array;
+            toProtoMsg(message: _215.VoteInfo): _215.VoteInfoProtoMsg;
         };
-        Evidence: {
-            typeUrl: string;
-            encode(message: _203.Evidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _203.Evidence;
-            fromJSON(object: any): _203.Evidence;
-            toJSON(message: _203.Evidence): import("../json-safe.ts").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;
+        ExtendedVoteInfo: {
+            typeUrl: "/tendermint.abci.ExtendedVoteInfo";
+            encode(message: _215.ExtendedVoteInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.ExtendedVoteInfo;
+            fromJSON(object: any): _215.ExtendedVoteInfo;
+            toJSON(message: _215.ExtendedVoteInfo): import("../json-safe.ts").JsonSafe<_215.ExtendedVoteInfo>;
+            fromPartial(object: Partial<_215.ExtendedVoteInfo>): _215.ExtendedVoteInfo;
+            fromProtoMsg(message: _215.ExtendedVoteInfoProtoMsg): _215.ExtendedVoteInfo;
+            toProto(message: _215.ExtendedVoteInfo): Uint8Array;
+            toProtoMsg(message: _215.ExtendedVoteInfo): _215.ExtendedVoteInfoProtoMsg;
+        };
+        Misbehavior: {
+            typeUrl: "/tendermint.abci.Misbehavior";
+            encode(message: _215.Misbehavior, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.Misbehavior;
+            fromJSON(object: any): _215.Misbehavior;
+            toJSON(message: _215.Misbehavior): import("../json-safe.ts").JsonSafe<_215.Misbehavior>;
+            fromPartial(object: Partial<_215.Misbehavior>): _215.Misbehavior;
+            fromProtoMsg(message: _215.MisbehaviorProtoMsg): _215.Misbehavior;
+            toProto(message: _215.Misbehavior): Uint8Array;
+            toProtoMsg(message: _215.Misbehavior): _215.MisbehaviorProtoMsg;
+        };
+        Snapshot: {
+            typeUrl: "/tendermint.abci.Snapshot";
+            encode(message: _215.Snapshot, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _215.Snapshot;
+            fromJSON(object: any): _215.Snapshot;
+            toJSON(message: _215.Snapshot): import("../json-safe.ts").JsonSafe<_215.Snapshot>;
+            fromPartial(object: Partial<_215.Snapshot>): _215.Snapshot;
+            fromProtoMsg(message: _215.SnapshotProtoMsg): _215.Snapshot;
+            toProto(message: _215.Snapshot): Uint8Array;
+            toProtoMsg(message: _215.Snapshot): _215.SnapshotProtoMsg;
         };
     };
     const crypto: {
         Proof: {
-            typeUrl: string;
-            encode(message: _205.Proof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.Proof;
-            fromJSON(object: any): _205.Proof;
-            toJSON(message: _205.Proof): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.crypto.Proof";
+            encode(message: _217.Proof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _217.Proof;
+            fromJSON(object: any): _217.Proof;
+            toJSON(message: _217.Proof): import("../json-safe.ts").JsonSafe<_217.Proof>;
+            fromPartial(object: Partial<_217.Proof>): _217.Proof;
+            fromProtoMsg(message: _217.ProofProtoMsg): _217.Proof;
+            toProto(message: _217.Proof): Uint8Array;
+            toProtoMsg(message: _217.Proof): _217.ProofProtoMsg;
         };
         ValueOp: {
-            typeUrl: string;
-            encode(message: _205.ValueOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.ValueOp;
-            fromJSON(object: any): _205.ValueOp;
-            toJSON(message: _205.ValueOp): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.crypto.ValueOp";
+            encode(message: _217.ValueOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _217.ValueOp;
+            fromJSON(object: any): _217.ValueOp;
+            toJSON(message: _217.ValueOp): import("../json-safe.ts").JsonSafe<_217.ValueOp>;
+            fromPartial(object: Partial<_217.ValueOp>): _217.ValueOp;
+            fromProtoMsg(message: _217.ValueOpProtoMsg): _217.ValueOp;
+            toProto(message: _217.ValueOp): Uint8Array;
+            toProtoMsg(message: _217.ValueOp): _217.ValueOpProtoMsg;
         };
         DominoOp: {
-            typeUrl: string;
-            encode(message: _205.DominoOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.DominoOp;
-            fromJSON(object: any): _205.DominoOp;
-            toJSON(message: _205.DominoOp): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.crypto.DominoOp";
+            encode(message: _217.DominoOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _217.DominoOp;
+            fromJSON(object: any): _217.DominoOp;
+            toJSON(message: _217.DominoOp): import("../json-safe.ts").JsonSafe<_217.DominoOp>;
+            fromPartial(object: Partial<_217.DominoOp>): _217.DominoOp;
+            fromProtoMsg(message: _217.DominoOpProtoMsg): _217.DominoOp;
+            toProto(message: _217.DominoOp): Uint8Array;
+            toProtoMsg(message: _217.DominoOp): _217.DominoOpProtoMsg;
         };
         ProofOp: {
-            typeUrl: string;
-            encode(message: _205.ProofOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.ProofOp;
-            fromJSON(object: any): _205.ProofOp;
-            toJSON(message: _205.ProofOp): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.crypto.ProofOp";
+            encode(message: _217.ProofOp, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _217.ProofOp;
+            fromJSON(object: any): _217.ProofOp;
+            toJSON(message: _217.ProofOp): import("../json-safe.ts").JsonSafe<_217.ProofOp>;
+            fromPartial(object: Partial<_217.ProofOp>): _217.ProofOp;
+            fromProtoMsg(message: _217.ProofOpProtoMsg): _217.ProofOp;
+            toProto(message: _217.ProofOp): Uint8Array;
+            toProtoMsg(message: _217.ProofOp): _217.ProofOpProtoMsg;
         };
         ProofOps: {
-            typeUrl: string;
-            encode(message: _205.ProofOps, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _205.ProofOps;
-            fromJSON(object: any): _205.ProofOps;
-            toJSON(message: _205.ProofOps): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.crypto.ProofOps";
+            encode(message: _217.ProofOps, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _217.ProofOps;
+            fromJSON(object: any): _217.ProofOps;
+            toJSON(message: _217.ProofOps): import("../json-safe.ts").JsonSafe<_217.ProofOps>;
+            fromPartial(object: Partial<_217.ProofOps>): _217.ProofOps;
+            fromProtoMsg(message: _217.ProofOpsProtoMsg): _217.ProofOps;
+            toProto(message: _217.ProofOps): Uint8Array;
+            toProtoMsg(message: _217.ProofOps): _217.ProofOpsProtoMsg;
         };
         PublicKey: {
-            typeUrl: string;
-            encode(message: _204.PublicKey, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _204.PublicKey;
-            fromJSON(object: any): _204.PublicKey;
-            toJSON(message: _204.PublicKey): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.crypto.PublicKey";
+            encode(message: _216.PublicKey, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _216.PublicKey;
+            fromJSON(object: any): _216.PublicKey;
+            toJSON(message: _216.PublicKey): import("../json-safe.ts").JsonSafe<_216.PublicKey>;
+            fromPartial(object: Partial<_216.PublicKey>): _216.PublicKey;
+            fromProtoMsg(message: _216.PublicKeyProtoMsg): _216.PublicKey;
+            toProto(message: _216.PublicKey): Uint8Array;
+            toProtoMsg(message: _216.PublicKey): _216.PublicKeyProtoMsg;
         };
     };
     namespace libs {
         const bits: {
             BitArray: {
-                typeUrl: string;
-                encode(message: _206.BitArray, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _206.BitArray;
-                fromJSON(object: any): _206.BitArray;
-                toJSON(message: _206.BitArray): import("../json-safe.ts").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;
+                typeUrl: "/tendermint.libs.bits.BitArray";
+                encode(message: _218.BitArray, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+                decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _218.BitArray;
+                fromJSON(object: any): _218.BitArray;
+                toJSON(message: _218.BitArray): import("../json-safe.ts").JsonSafe<_218.BitArray>;
+                fromPartial(object: Partial<_218.BitArray>): _218.BitArray;
+                fromProtoMsg(message: _218.BitArrayProtoMsg): _218.BitArray;
+                toProto(message: _218.BitArray): Uint8Array;
+                toProtoMsg(message: _218.BitArray): _218.BitArrayProtoMsg;
             };
         };
     }
     const p2p: {
         NetAddress: {
-            typeUrl: string;
-            encode(message: _207.NetAddress, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _207.NetAddress;
-            fromJSON(object: any): _207.NetAddress;
-            toJSON(message: _207.NetAddress): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.p2p.NetAddress";
+            encode(message: _219.NetAddress, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _219.NetAddress;
+            fromJSON(object: any): _219.NetAddress;
+            toJSON(message: _219.NetAddress): import("../json-safe.ts").JsonSafe<_219.NetAddress>;
+            fromPartial(object: Partial<_219.NetAddress>): _219.NetAddress;
+            fromProtoMsg(message: _219.NetAddressProtoMsg): _219.NetAddress;
+            toProto(message: _219.NetAddress): Uint8Array;
+            toProtoMsg(message: _219.NetAddress): _219.NetAddressProtoMsg;
         };
         ProtocolVersion: {
-            typeUrl: string;
-            encode(message: _207.ProtocolVersion, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _207.ProtocolVersion;
-            fromJSON(object: any): _207.ProtocolVersion;
-            toJSON(message: _207.ProtocolVersion): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.p2p.ProtocolVersion";
+            encode(message: _219.ProtocolVersion, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _219.ProtocolVersion;
+            fromJSON(object: any): _219.ProtocolVersion;
+            toJSON(message: _219.ProtocolVersion): import("../json-safe.ts").JsonSafe<_219.ProtocolVersion>;
+            fromPartial(object: Partial<_219.ProtocolVersion>): _219.ProtocolVersion;
+            fromProtoMsg(message: _219.ProtocolVersionProtoMsg): _219.ProtocolVersion;
+            toProto(message: _219.ProtocolVersion): Uint8Array;
+            toProtoMsg(message: _219.ProtocolVersion): _219.ProtocolVersionProtoMsg;
         };
         DefaultNodeInfo: {
-            typeUrl: string;
-            encode(message: _207.DefaultNodeInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _207.DefaultNodeInfo;
-            fromJSON(object: any): _207.DefaultNodeInfo;
-            toJSON(message: _207.DefaultNodeInfo): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.p2p.DefaultNodeInfo";
+            encode(message: _219.DefaultNodeInfo, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _219.DefaultNodeInfo;
+            fromJSON(object: any): _219.DefaultNodeInfo;
+            toJSON(message: _219.DefaultNodeInfo): import("../json-safe.ts").JsonSafe<_219.DefaultNodeInfo>;
+            fromPartial(object: Partial<_219.DefaultNodeInfo>): _219.DefaultNodeInfo;
+            fromProtoMsg(message: _219.DefaultNodeInfoProtoMsg): _219.DefaultNodeInfo;
+            toProto(message: _219.DefaultNodeInfo): Uint8Array;
+            toProtoMsg(message: _219.DefaultNodeInfo): _219.DefaultNodeInfoProtoMsg;
         };
         DefaultNodeInfoOther: {
-            typeUrl: string;
-            encode(message: _207.DefaultNodeInfoOther, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _207.DefaultNodeInfoOther;
-            fromJSON(object: any): _207.DefaultNodeInfoOther;
-            toJSON(message: _207.DefaultNodeInfoOther): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.p2p.DefaultNodeInfoOther";
+            encode(message: _219.DefaultNodeInfoOther, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _219.DefaultNodeInfoOther;
+            fromJSON(object: any): _219.DefaultNodeInfoOther;
+            toJSON(message: _219.DefaultNodeInfoOther): import("../json-safe.ts").JsonSafe<_219.DefaultNodeInfoOther>;
+            fromPartial(object: Partial<_219.DefaultNodeInfoOther>): _219.DefaultNodeInfoOther;
+            fromProtoMsg(message: _219.DefaultNodeInfoOtherProtoMsg): _219.DefaultNodeInfoOther;
+            toProto(message: _219.DefaultNodeInfoOther): Uint8Array;
+            toProtoMsg(message: _219.DefaultNodeInfoOther): _219.DefaultNodeInfoOtherProtoMsg;
         };
     };
     const types: {
+        blockIDFlagFromJSON(object: any): _224.BlockIDFlag;
+        blockIDFlagToJSON(object: _224.BlockIDFlag): string;
+        BlockIDFlag: typeof _224.BlockIDFlag;
+        BlockIDFlagSDKType: typeof _224.BlockIDFlag;
         ValidatorSet: {
-            typeUrl: string;
-            encode(message: _212.ValidatorSet, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _212.ValidatorSet;
-            fromJSON(object: any): _212.ValidatorSet;
-            toJSON(message: _212.ValidatorSet): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.ValidatorSet";
+            encode(message: _224.ValidatorSet, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _224.ValidatorSet;
+            fromJSON(object: any): _224.ValidatorSet;
+            toJSON(message: _224.ValidatorSet): import("../json-safe.ts").JsonSafe<_224.ValidatorSet>;
+            fromPartial(object: Partial<_224.ValidatorSet>): _224.ValidatorSet;
+            fromProtoMsg(message: _224.ValidatorSetProtoMsg): _224.ValidatorSet;
+            toProto(message: _224.ValidatorSet): Uint8Array;
+            toProtoMsg(message: _224.ValidatorSet): _224.ValidatorSetProtoMsg;
         };
         Validator: {
-            typeUrl: string;
-            encode(message: _212.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _212.Validator;
-            fromJSON(object: any): _212.Validator;
-            toJSON(message: _212.Validator): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Validator";
+            encode(message: _224.Validator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _224.Validator;
+            fromJSON(object: any): _224.Validator;
+            toJSON(message: _224.Validator): import("../json-safe.ts").JsonSafe<_224.Validator>;
+            fromPartial(object: Partial<_224.Validator>): _224.Validator;
+            fromProtoMsg(message: _224.ValidatorProtoMsg): _224.Validator;
+            toProto(message: _224.Validator): Uint8Array;
+            toProtoMsg(message: _224.Validator): _224.ValidatorProtoMsg;
         };
         SimpleValidator: {
-            typeUrl: string;
-            encode(message: _212.SimpleValidator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _212.SimpleValidator;
-            fromJSON(object: any): _212.SimpleValidator;
-            toJSON(message: _212.SimpleValidator): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.SimpleValidator";
+            encode(message: _224.SimpleValidator, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _224.SimpleValidator;
+            fromJSON(object: any): _224.SimpleValidator;
+            toJSON(message: _224.SimpleValidator): import("../json-safe.ts").JsonSafe<_224.SimpleValidator>;
+            fromPartial(object: Partial<_224.SimpleValidator>): _224.SimpleValidator;
+            fromProtoMsg(message: _224.SimpleValidatorProtoMsg): _224.SimpleValidator;
+            toProto(message: _224.SimpleValidator): Uint8Array;
+            toProtoMsg(message: _224.SimpleValidator): _224.SimpleValidatorProtoMsg;
+        };
+        signedMsgTypeFromJSON(object: any): _223.SignedMsgType;
+        signedMsgTypeToJSON(object: _223.SignedMsgType): string;
+        SignedMsgType: typeof _223.SignedMsgType;
+        SignedMsgTypeSDKType: typeof _223.SignedMsgType;
         PartSetHeader: {
-            typeUrl: string;
-            encode(message: _211.PartSetHeader, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.PartSetHeader;
-            fromJSON(object: any): _211.PartSetHeader;
-            toJSON(message: _211.PartSetHeader): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.PartSetHeader";
+            encode(message: _223.PartSetHeader, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.PartSetHeader;
+            fromJSON(object: any): _223.PartSetHeader;
+            toJSON(message: _223.PartSetHeader): import("../json-safe.ts").JsonSafe<_223.PartSetHeader>;
+            fromPartial(object: Partial<_223.PartSetHeader>): _223.PartSetHeader;
+            fromProtoMsg(message: _223.PartSetHeaderProtoMsg): _223.PartSetHeader;
+            toProto(message: _223.PartSetHeader): Uint8Array;
+            toProtoMsg(message: _223.PartSetHeader): _223.PartSetHeaderProtoMsg;
         };
         Part: {
-            typeUrl: string;
-            encode(message: _211.Part, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Part;
-            fromJSON(object: any): _211.Part;
-            toJSON(message: _211.Part): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Part";
+            encode(message: _223.Part, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.Part;
+            fromJSON(object: any): _223.Part;
+            toJSON(message: _223.Part): import("../json-safe.ts").JsonSafe<_223.Part>;
+            fromPartial(object: Partial<_223.Part>): _223.Part;
+            fromProtoMsg(message: _223.PartProtoMsg): _223.Part;
+            toProto(message: _223.Part): Uint8Array;
+            toProtoMsg(message: _223.Part): _223.PartProtoMsg;
         };
         BlockID: {
-            typeUrl: string;
-            encode(message: _211.BlockID, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.BlockID;
-            fromJSON(object: any): _211.BlockID;
-            toJSON(message: _211.BlockID): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.BlockID";
+            encode(message: _223.BlockID, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.BlockID;
+            fromJSON(object: any): _223.BlockID;
+            toJSON(message: _223.BlockID): import("../json-safe.ts").JsonSafe<_223.BlockID>;
+            fromPartial(object: Partial<_223.BlockID>): _223.BlockID;
+            fromProtoMsg(message: _223.BlockIDProtoMsg): _223.BlockID;
+            toProto(message: _223.BlockID): Uint8Array;
+            toProtoMsg(message: _223.BlockID): _223.BlockIDProtoMsg;
         };
         Header: {
-            typeUrl: string;
-            encode(message: _211.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Header;
-            fromJSON(object: any): _211.Header;
-            toJSON(message: _211.Header): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Header";
+            encode(message: _223.Header, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.Header;
+            fromJSON(object: any): _223.Header;
+            toJSON(message: _223.Header): import("../json-safe.ts").JsonSafe<_223.Header>;
+            fromPartial(object: Partial<_223.Header>): _223.Header;
+            fromProtoMsg(message: _223.HeaderProtoMsg): _223.Header;
+            toProto(message: _223.Header): Uint8Array;
+            toProtoMsg(message: _223.Header): _223.HeaderProtoMsg;
         };
         Data: {
-            typeUrl: string;
-            encode(message: _211.Data, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Data;
-            fromJSON(object: any): _211.Data;
-            toJSON(message: _211.Data): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Data";
+            encode(message: _223.Data, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.Data;
+            fromJSON(object: any): _223.Data;
+            toJSON(message: _223.Data): import("../json-safe.ts").JsonSafe<_223.Data>;
+            fromPartial(object: Partial<_223.Data>): _223.Data;
+            fromProtoMsg(message: _223.DataProtoMsg): _223.Data;
+            toProto(message: _223.Data): Uint8Array;
+            toProtoMsg(message: _223.Data): _223.DataProtoMsg;
         };
         Vote: {
-            typeUrl: string;
-            encode(message: _211.Vote, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Vote;
-            fromJSON(object: any): _211.Vote;
-            toJSON(message: _211.Vote): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Vote";
+            encode(message: _223.Vote, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.Vote;
+            fromJSON(object: any): _223.Vote;
+            toJSON(message: _223.Vote): import("../json-safe.ts").JsonSafe<_223.Vote>;
+            fromPartial(object: Partial<_223.Vote>): _223.Vote;
+            fromProtoMsg(message: _223.VoteProtoMsg): _223.Vote;
+            toProto(message: _223.Vote): Uint8Array;
+            toProtoMsg(message: _223.Vote): _223.VoteProtoMsg;
         };
         Commit: {
-            typeUrl: string;
-            encode(message: _211.Commit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Commit;
-            fromJSON(object: any): _211.Commit;
-            toJSON(message: _211.Commit): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Commit";
+            encode(message: _223.Commit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.Commit;
+            fromJSON(object: any): _223.Commit;
+            toJSON(message: _223.Commit): import("../json-safe.ts").JsonSafe<_223.Commit>;
+            fromPartial(object: Partial<_223.Commit>): _223.Commit;
+            fromProtoMsg(message: _223.CommitProtoMsg): _223.Commit;
+            toProto(message: _223.Commit): Uint8Array;
+            toProtoMsg(message: _223.Commit): _223.CommitProtoMsg;
         };
         CommitSig: {
-            typeUrl: string;
-            encode(message: _211.CommitSig, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.CommitSig;
-            fromJSON(object: any): _211.CommitSig;
-            toJSON(message: _211.CommitSig): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.CommitSig";
+            encode(message: _223.CommitSig, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.CommitSig;
+            fromJSON(object: any): _223.CommitSig;
+            toJSON(message: _223.CommitSig): import("../json-safe.ts").JsonSafe<_223.CommitSig>;
+            fromPartial(object: Partial<_223.CommitSig>): _223.CommitSig;
+            fromProtoMsg(message: _223.CommitSigProtoMsg): _223.CommitSig;
+            toProto(message: _223.CommitSig): Uint8Array;
+            toProtoMsg(message: _223.CommitSig): _223.CommitSigProtoMsg;
+        };
+        ExtendedCommit: {
+            typeUrl: "/tendermint.types.ExtendedCommit";
+            encode(message: _223.ExtendedCommit, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.ExtendedCommit;
+            fromJSON(object: any): _223.ExtendedCommit;
+            toJSON(message: _223.ExtendedCommit): import("../json-safe.ts").JsonSafe<_223.ExtendedCommit>;
+            fromPartial(object: Partial<_223.ExtendedCommit>): _223.ExtendedCommit;
+            fromProtoMsg(message: _223.ExtendedCommitProtoMsg): _223.ExtendedCommit;
+            toProto(message: _223.ExtendedCommit): Uint8Array;
+            toProtoMsg(message: _223.ExtendedCommit): _223.ExtendedCommitProtoMsg;
+        };
+        ExtendedCommitSig: {
+            typeUrl: "/tendermint.types.ExtendedCommitSig";
+            encode(message: _223.ExtendedCommitSig, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.ExtendedCommitSig;
+            fromJSON(object: any): _223.ExtendedCommitSig;
+            toJSON(message: _223.ExtendedCommitSig): import("../json-safe.ts").JsonSafe<_223.ExtendedCommitSig>;
+            fromPartial(object: Partial<_223.ExtendedCommitSig>): _223.ExtendedCommitSig;
+            fromProtoMsg(message: _223.ExtendedCommitSigProtoMsg): _223.ExtendedCommitSig;
+            toProto(message: _223.ExtendedCommitSig): Uint8Array;
+            toProtoMsg(message: _223.ExtendedCommitSig): _223.ExtendedCommitSigProtoMsg;
         };
         Proposal: {
-            typeUrl: string;
-            encode(message: _211.Proposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.Proposal;
-            fromJSON(object: any): _211.Proposal;
-            toJSON(message: _211.Proposal): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Proposal";
+            encode(message: _223.Proposal, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.Proposal;
+            fromJSON(object: any): _223.Proposal;
+            toJSON(message: _223.Proposal): import("../json-safe.ts").JsonSafe<_223.Proposal>;
+            fromPartial(object: Partial<_223.Proposal>): _223.Proposal;
+            fromProtoMsg(message: _223.ProposalProtoMsg): _223.Proposal;
+            toProto(message: _223.Proposal): Uint8Array;
+            toProtoMsg(message: _223.Proposal): _223.ProposalProtoMsg;
         };
         SignedHeader: {
-            typeUrl: string;
-            encode(message: _211.SignedHeader, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.SignedHeader;
-            fromJSON(object: any): _211.SignedHeader;
-            toJSON(message: _211.SignedHeader): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.SignedHeader";
+            encode(message: _223.SignedHeader, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.SignedHeader;
+            fromJSON(object: any): _223.SignedHeader;
+            toJSON(message: _223.SignedHeader): import("../json-safe.ts").JsonSafe<_223.SignedHeader>;
+            fromPartial(object: Partial<_223.SignedHeader>): _223.SignedHeader;
+            fromProtoMsg(message: _223.SignedHeaderProtoMsg): _223.SignedHeader;
+            toProto(message: _223.SignedHeader): Uint8Array;
+            toProtoMsg(message: _223.SignedHeader): _223.SignedHeaderProtoMsg;
         };
         LightBlock: {
-            typeUrl: string;
-            encode(message: _211.LightBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.LightBlock;
-            fromJSON(object: any): _211.LightBlock;
-            toJSON(message: _211.LightBlock): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.LightBlock";
+            encode(message: _223.LightBlock, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.LightBlock;
+            fromJSON(object: any): _223.LightBlock;
+            toJSON(message: _223.LightBlock): import("../json-safe.ts").JsonSafe<_223.LightBlock>;
+            fromPartial(object: Partial<_223.LightBlock>): _223.LightBlock;
+            fromProtoMsg(message: _223.LightBlockProtoMsg): _223.LightBlock;
+            toProto(message: _223.LightBlock): Uint8Array;
+            toProtoMsg(message: _223.LightBlock): _223.LightBlockProtoMsg;
         };
         BlockMeta: {
-            typeUrl: string;
-            encode(message: _211.BlockMeta, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.BlockMeta;
-            fromJSON(object: any): _211.BlockMeta;
-            toJSON(message: _211.BlockMeta): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.BlockMeta";
+            encode(message: _223.BlockMeta, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.BlockMeta;
+            fromJSON(object: any): _223.BlockMeta;
+            toJSON(message: _223.BlockMeta): import("../json-safe.ts").JsonSafe<_223.BlockMeta>;
+            fromPartial(object: Partial<_223.BlockMeta>): _223.BlockMeta;
+            fromProtoMsg(message: _223.BlockMetaProtoMsg): _223.BlockMeta;
+            toProto(message: _223.BlockMeta): Uint8Array;
+            toProtoMsg(message: _223.BlockMeta): _223.BlockMetaProtoMsg;
         };
         TxProof: {
-            typeUrl: string;
-            encode(message: _211.TxProof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _211.TxProof;
-            fromJSON(object: any): _211.TxProof;
-            toJSON(message: _211.TxProof): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.TxProof";
+            encode(message: _223.TxProof, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _223.TxProof;
+            fromJSON(object: any): _223.TxProof;
+            toJSON(message: _223.TxProof): import("../json-safe.ts").JsonSafe<_223.TxProof>;
+            fromPartial(object: Partial<_223.TxProof>): _223.TxProof;
+            fromProtoMsg(message: _223.TxProofProtoMsg): _223.TxProof;
+            toProto(message: _223.TxProof): Uint8Array;
+            toProtoMsg(message: _223.TxProof): _223.TxProofProtoMsg;
         };
         ConsensusParams: {
-            typeUrl: string;
-            encode(message: _210.ConsensusParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.ConsensusParams;
-            fromJSON(object: any): _210.ConsensusParams;
-            toJSON(message: _210.ConsensusParams): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.ConsensusParams";
+            encode(message: _222.ConsensusParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _222.ConsensusParams;
+            fromJSON(object: any): _222.ConsensusParams;
+            toJSON(message: _222.ConsensusParams): import("../json-safe.ts").JsonSafe<_222.ConsensusParams>;
+            fromPartial(object: Partial<_222.ConsensusParams>): _222.ConsensusParams;
+            fromProtoMsg(message: _222.ConsensusParamsProtoMsg): _222.ConsensusParams;
+            toProto(message: _222.ConsensusParams): Uint8Array;
+            toProtoMsg(message: _222.ConsensusParams): _222.ConsensusParamsProtoMsg;
         };
         BlockParams: {
-            typeUrl: string;
-            encode(message: _210.BlockParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.BlockParams;
-            fromJSON(object: any): _210.BlockParams;
-            toJSON(message: _210.BlockParams): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.BlockParams";
+            encode(message: _222.BlockParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _222.BlockParams;
+            fromJSON(object: any): _222.BlockParams;
+            toJSON(message: _222.BlockParams): import("../json-safe.ts").JsonSafe<_222.BlockParams>;
+            fromPartial(object: Partial<_222.BlockParams>): _222.BlockParams;
+            fromProtoMsg(message: _222.BlockParamsProtoMsg): _222.BlockParams;
+            toProto(message: _222.BlockParams): Uint8Array;
+            toProtoMsg(message: _222.BlockParams): _222.BlockParamsProtoMsg;
         };
         EvidenceParams: {
-            typeUrl: string;
-            encode(message: _210.EvidenceParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.EvidenceParams;
-            fromJSON(object: any): _210.EvidenceParams;
-            toJSON(message: _210.EvidenceParams): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.EvidenceParams";
+            encode(message: _222.EvidenceParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _222.EvidenceParams;
+            fromJSON(object: any): _222.EvidenceParams;
+            toJSON(message: _222.EvidenceParams): import("../json-safe.ts").JsonSafe<_222.EvidenceParams>;
+            fromPartial(object: Partial<_222.EvidenceParams>): _222.EvidenceParams;
+            fromProtoMsg(message: _222.EvidenceParamsProtoMsg): _222.EvidenceParams;
+            toProto(message: _222.EvidenceParams): Uint8Array;
+            toProtoMsg(message: _222.EvidenceParams): _222.EvidenceParamsProtoMsg;
         };
         ValidatorParams: {
-            typeUrl: string;
-            encode(message: _210.ValidatorParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.ValidatorParams;
-            fromJSON(object: any): _210.ValidatorParams;
-            toJSON(message: _210.ValidatorParams): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.ValidatorParams";
+            encode(message: _222.ValidatorParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _222.ValidatorParams;
+            fromJSON(object: any): _222.ValidatorParams;
+            toJSON(message: _222.ValidatorParams): import("../json-safe.ts").JsonSafe<_222.ValidatorParams>;
+            fromPartial(object: Partial<_222.ValidatorParams>): _222.ValidatorParams;
+            fromProtoMsg(message: _222.ValidatorParamsProtoMsg): _222.ValidatorParams;
+            toProto(message: _222.ValidatorParams): Uint8Array;
+            toProtoMsg(message: _222.ValidatorParams): _222.ValidatorParamsProtoMsg;
         };
         VersionParams: {
-            typeUrl: string;
-            encode(message: _210.VersionParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.VersionParams;
-            fromJSON(object: any): _210.VersionParams;
-            toJSON(message: _210.VersionParams): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.VersionParams";
+            encode(message: _222.VersionParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _222.VersionParams;
+            fromJSON(object: any): _222.VersionParams;
+            toJSON(message: _222.VersionParams): import("../json-safe.ts").JsonSafe<_222.VersionParams>;
+            fromPartial(object: Partial<_222.VersionParams>): _222.VersionParams;
+            fromProtoMsg(message: _222.VersionParamsProtoMsg): _222.VersionParams;
+            toProto(message: _222.VersionParams): Uint8Array;
+            toProtoMsg(message: _222.VersionParams): _222.VersionParamsProtoMsg;
         };
         HashedParams: {
-            typeUrl: string;
-            encode(message: _210.HashedParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _210.HashedParams;
-            fromJSON(object: any): _210.HashedParams;
-            toJSON(message: _210.HashedParams): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.HashedParams";
+            encode(message: _222.HashedParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _222.HashedParams;
+            fromJSON(object: any): _222.HashedParams;
+            toJSON(message: _222.HashedParams): import("../json-safe.ts").JsonSafe<_222.HashedParams>;
+            fromPartial(object: Partial<_222.HashedParams>): _222.HashedParams;
+            fromProtoMsg(message: _222.HashedParamsProtoMsg): _222.HashedParams;
+            toProto(message: _222.HashedParams): Uint8Array;
+            toProtoMsg(message: _222.HashedParams): _222.HashedParamsProtoMsg;
+        };
+        ABCIParams: {
+            typeUrl: "/tendermint.types.ABCIParams";
+            encode(message: _222.ABCIParams, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _222.ABCIParams;
+            fromJSON(object: any): _222.ABCIParams;
+            toJSON(message: _222.ABCIParams): import("../json-safe.ts").JsonSafe<_222.ABCIParams>;
+            fromPartial(object: Partial<_222.ABCIParams>): _222.ABCIParams;
+            fromProtoMsg(message: _222.ABCIParamsProtoMsg): _222.ABCIParams;
+            toProto(message: _222.ABCIParams): Uint8Array;
+            toProtoMsg(message: _222.ABCIParams): _222.ABCIParamsProtoMsg;
         };
         Evidence: {
-            typeUrl: string;
-            encode(message: _209.Evidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _209.Evidence;
-            fromJSON(object: any): _209.Evidence;
-            toJSON(message: _209.Evidence): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Evidence";
+            encode(message: _221.Evidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _221.Evidence;
+            fromJSON(object: any): _221.Evidence;
+            toJSON(message: _221.Evidence): import("../json-safe.ts").JsonSafe<_221.Evidence>;
+            fromPartial(object: Partial<_221.Evidence>): _221.Evidence;
+            fromProtoMsg(message: _221.EvidenceProtoMsg): _221.Evidence;
+            toProto(message: _221.Evidence): Uint8Array;
+            toProtoMsg(message: _221.Evidence): _221.EvidenceProtoMsg;
         };
         DuplicateVoteEvidence: {
-            typeUrl: string;
-            encode(message: _209.DuplicateVoteEvidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _209.DuplicateVoteEvidence;
-            fromJSON(object: any): _209.DuplicateVoteEvidence;
-            toJSON(message: _209.DuplicateVoteEvidence): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.DuplicateVoteEvidence";
+            encode(message: _221.DuplicateVoteEvidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _221.DuplicateVoteEvidence;
+            fromJSON(object: any): _221.DuplicateVoteEvidence;
+            toJSON(message: _221.DuplicateVoteEvidence): import("../json-safe.ts").JsonSafe<_221.DuplicateVoteEvidence>;
+            fromPartial(object: Partial<_221.DuplicateVoteEvidence>): _221.DuplicateVoteEvidence;
+            fromProtoMsg(message: _221.DuplicateVoteEvidenceProtoMsg): _221.DuplicateVoteEvidence;
+            toProto(message: _221.DuplicateVoteEvidence): Uint8Array;
+            toProtoMsg(message: _221.DuplicateVoteEvidence): _221.DuplicateVoteEvidenceProtoMsg;
         };
         LightClientAttackEvidence: {
-            typeUrl: string;
-            encode(message: _209.LightClientAttackEvidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _209.LightClientAttackEvidence;
-            fromJSON(object: any): _209.LightClientAttackEvidence;
-            toJSON(message: _209.LightClientAttackEvidence): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.LightClientAttackEvidence";
+            encode(message: _221.LightClientAttackEvidence, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _221.LightClientAttackEvidence;
+            fromJSON(object: any): _221.LightClientAttackEvidence;
+            toJSON(message: _221.LightClientAttackEvidence): import("../json-safe.ts").JsonSafe<_221.LightClientAttackEvidence>;
+            fromPartial(object: Partial<_221.LightClientAttackEvidence>): _221.LightClientAttackEvidence;
+            fromProtoMsg(message: _221.LightClientAttackEvidenceProtoMsg): _221.LightClientAttackEvidence;
+            toProto(message: _221.LightClientAttackEvidence): Uint8Array;
+            toProtoMsg(message: _221.LightClientAttackEvidence): _221.LightClientAttackEvidenceProtoMsg;
         };
         EvidenceList: {
-            typeUrl: string;
-            encode(message: _209.EvidenceList, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _209.EvidenceList;
-            fromJSON(object: any): _209.EvidenceList;
-            toJSON(message: _209.EvidenceList): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.EvidenceList";
+            encode(message: _221.EvidenceList, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _221.EvidenceList;
+            fromJSON(object: any): _221.EvidenceList;
+            toJSON(message: _221.EvidenceList): import("../json-safe.ts").JsonSafe<_221.EvidenceList>;
+            fromPartial(object: Partial<_221.EvidenceList>): _221.EvidenceList;
+            fromProtoMsg(message: _221.EvidenceListProtoMsg): _221.EvidenceList;
+            toProto(message: _221.EvidenceList): Uint8Array;
+            toProtoMsg(message: _221.EvidenceList): _221.EvidenceListProtoMsg;
         };
         Block: {
-            typeUrl: string;
-            encode(message: _208.Block, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _208.Block;
-            fromJSON(object: any): _208.Block;
-            toJSON(message: _208.Block): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.types.Block";
+            encode(message: _220.Block, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _220.Block;
+            fromJSON(object: any): _220.Block;
+            toJSON(message: _220.Block): import("../json-safe.ts").JsonSafe<_220.Block>;
+            fromPartial(object: Partial<_220.Block>): _220.Block;
+            fromProtoMsg(message: _220.BlockProtoMsg): _220.Block;
+            toProto(message: _220.Block): Uint8Array;
+            toProtoMsg(message: _220.Block): _220.BlockProtoMsg;
         };
     };
     const version: {
         App: {
-            typeUrl: string;
-            encode(message: _213.App, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _213.App;
-            fromJSON(object: any): _213.App;
-            toJSON(message: _213.App): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.version.App";
+            encode(message: _225.App, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _225.App;
+            fromJSON(object: any): _225.App;
+            toJSON(message: _225.App): import("../json-safe.ts").JsonSafe<_225.App>;
+            fromPartial(object: Partial<_225.App>): _225.App;
+            fromProtoMsg(message: _225.AppProtoMsg): _225.App;
+            toProto(message: _225.App): Uint8Array;
+            toProtoMsg(message: _225.App): _225.AppProtoMsg;
         };
         Consensus: {
-            typeUrl: string;
-            encode(message: _213.Consensus, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
-            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _213.Consensus;
-            fromJSON(object: any): _213.Consensus;
-            toJSON(message: _213.Consensus): import("../json-safe.ts").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;
+            typeUrl: "/tendermint.version.Consensus";
+            encode(message: _225.Consensus, writer?: import("../binary.ts").BinaryWriter): import("../binary.ts").BinaryWriter;
+            decode(input: import("../binary.ts").BinaryReader | Uint8Array, length?: number): _225.Consensus;
+            fromJSON(object: any): _225.Consensus;
+            toJSON(message: _225.Consensus): import("../json-safe.ts").JsonSafe<_225.Consensus>;
+            fromPartial(object: Partial<_225.Consensus>): _225.Consensus;
+            fromProtoMsg(message: _225.ConsensusProtoMsg): _225.Consensus;
+            toProto(message: _225.Consensus): Uint8Array;
+            toProtoMsg(message: _225.Consensus): _225.ConsensusProtoMsg;
         };
     };
 }
+//# sourceMappingURL=bundle.d.ts.map