@sparkdreamnft/sparkdreamjs 0.0.29 → 0.0.31

package/tendermint/bundle.d.ts

@@ -1,1122 +1,1122 @@
-import * as _475 from "./abci/types";
-import * as _476 from "./crypto/keys";
-import * as _477 from "./crypto/proof";
-import * as _478 from "./p2p/types";
-import * as _479 from "./types/block";
-import * as _480 from "./types/evidence";
-import * as _481 from "./types/params";
-import * as _482 from "./types/types";
-import * as _483 from "./types/validator";
-import * as _484 from "./version/types";
+import * as _536 from "./abci/types";
+import * as _537 from "./crypto/keys";
+import * as _538 from "./crypto/proof";
+import * as _539 from "./p2p/types";
+import * as _540 from "./types/block";
+import * as _541 from "./types/evidence";
+import * as _542 from "./types/params";
+import * as _543 from "./types/types";
+import * as _544 from "./types/validator";
+import * as _545 from "./version/types";
 export declare namespace tendermint {
     const abci: {
-        checkTxTypeFromJSON(object: any): _475.CheckTxType;
-        checkTxTypeToJSON(object: _475.CheckTxType): string;
-        responseOfferSnapshot_ResultFromJSON(object: any): _475.ResponseOfferSnapshot_Result;
-        responseOfferSnapshot_ResultToJSON(object: _475.ResponseOfferSnapshot_Result): string;
-        responseApplySnapshotChunk_ResultFromJSON(object: any): _475.ResponseApplySnapshotChunk_Result;
-        responseApplySnapshotChunk_ResultToJSON(object: _475.ResponseApplySnapshotChunk_Result): string;
-        responseProcessProposal_ProposalStatusFromJSON(object: any): _475.ResponseProcessProposal_ProposalStatus;
-        responseProcessProposal_ProposalStatusToJSON(object: _475.ResponseProcessProposal_ProposalStatus): string;
-        responseVerifyVoteExtension_VerifyStatusFromJSON(object: any): _475.ResponseVerifyVoteExtension_VerifyStatus;
-        responseVerifyVoteExtension_VerifyStatusToJSON(object: _475.ResponseVerifyVoteExtension_VerifyStatus): string;
-        misbehaviorTypeFromJSON(object: any): _475.MisbehaviorType;
-        misbehaviorTypeToJSON(object: _475.MisbehaviorType): string;
-        CheckTxType: typeof _475.CheckTxType;
-        CheckTxTypeAmino: typeof _475.CheckTxType;
-        ResponseOfferSnapshot_Result: typeof _475.ResponseOfferSnapshot_Result;
-        ResponseOfferSnapshot_ResultAmino: typeof _475.ResponseOfferSnapshot_Result;
-        ResponseApplySnapshotChunk_Result: typeof _475.ResponseApplySnapshotChunk_Result;
-        ResponseApplySnapshotChunk_ResultAmino: typeof _475.ResponseApplySnapshotChunk_Result;
-        ResponseProcessProposal_ProposalStatus: typeof _475.ResponseProcessProposal_ProposalStatus;
-        ResponseProcessProposal_ProposalStatusAmino: typeof _475.ResponseProcessProposal_ProposalStatus;
-        ResponseVerifyVoteExtension_VerifyStatus: typeof _475.ResponseVerifyVoteExtension_VerifyStatus;
-        ResponseVerifyVoteExtension_VerifyStatusAmino: typeof _475.ResponseVerifyVoteExtension_VerifyStatus;
-        MisbehaviorType: typeof _475.MisbehaviorType;
-        MisbehaviorTypeAmino: typeof _475.MisbehaviorType;
+        checkTxTypeFromJSON(object: any): _536.CheckTxType;
+        checkTxTypeToJSON(object: _536.CheckTxType): string;
+        responseOfferSnapshot_ResultFromJSON(object: any): _536.ResponseOfferSnapshot_Result;
+        responseOfferSnapshot_ResultToJSON(object: _536.ResponseOfferSnapshot_Result): string;
+        responseApplySnapshotChunk_ResultFromJSON(object: any): _536.ResponseApplySnapshotChunk_Result;
+        responseApplySnapshotChunk_ResultToJSON(object: _536.ResponseApplySnapshotChunk_Result): string;
+        responseProcessProposal_ProposalStatusFromJSON(object: any): _536.ResponseProcessProposal_ProposalStatus;
+        responseProcessProposal_ProposalStatusToJSON(object: _536.ResponseProcessProposal_ProposalStatus): string;
+        responseVerifyVoteExtension_VerifyStatusFromJSON(object: any): _536.ResponseVerifyVoteExtension_VerifyStatus;
+        responseVerifyVoteExtension_VerifyStatusToJSON(object: _536.ResponseVerifyVoteExtension_VerifyStatus): string;
+        misbehaviorTypeFromJSON(object: any): _536.MisbehaviorType;
+        misbehaviorTypeToJSON(object: _536.MisbehaviorType): string;
+        CheckTxType: typeof _536.CheckTxType;
+        CheckTxTypeAmino: typeof _536.CheckTxType;
+        ResponseOfferSnapshot_Result: typeof _536.ResponseOfferSnapshot_Result;
+        ResponseOfferSnapshot_ResultAmino: typeof _536.ResponseOfferSnapshot_Result;
+        ResponseApplySnapshotChunk_Result: typeof _536.ResponseApplySnapshotChunk_Result;
+        ResponseApplySnapshotChunk_ResultAmino: typeof _536.ResponseApplySnapshotChunk_Result;
+        ResponseProcessProposal_ProposalStatus: typeof _536.ResponseProcessProposal_ProposalStatus;
+        ResponseProcessProposal_ProposalStatusAmino: typeof _536.ResponseProcessProposal_ProposalStatus;
+        ResponseVerifyVoteExtension_VerifyStatus: typeof _536.ResponseVerifyVoteExtension_VerifyStatus;
+        ResponseVerifyVoteExtension_VerifyStatusAmino: typeof _536.ResponseVerifyVoteExtension_VerifyStatus;
+        MisbehaviorType: typeof _536.MisbehaviorType;
+        MisbehaviorTypeAmino: typeof _536.MisbehaviorType;
         Request: {
             typeUrl: string;
-            encode(message: _475.Request, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.Request;
-            fromPartial(object: import("../helpers").DeepPartial<_475.Request>): _475.Request;
-            fromAmino(object: _475.RequestAmino): _475.Request;
-            toAmino(message: _475.Request): _475.RequestAmino;
-            fromAminoMsg(object: _475.RequestAminoMsg): _475.Request;
-            fromProtoMsg(message: _475.RequestProtoMsg): _475.Request;
-            toProto(message: _475.Request): Uint8Array;
-            toProtoMsg(message: _475.Request): _475.RequestProtoMsg;
+            encode(message: _536.Request, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Request;
+            fromPartial(object: import("../helpers").DeepPartial<_536.Request>): _536.Request;
+            fromAmino(object: _536.RequestAmino): _536.Request;
+            toAmino(message: _536.Request): _536.RequestAmino;
+            fromAminoMsg(object: _536.RequestAminoMsg): _536.Request;
+            fromProtoMsg(message: _536.RequestProtoMsg): _536.Request;
+            toProto(message: _536.Request): Uint8Array;
+            toProtoMsg(message: _536.Request): _536.RequestProtoMsg;
         };
         RequestEcho: {
             typeUrl: string;
-            encode(message: _475.RequestEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestEcho;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestEcho>): _475.RequestEcho;
-            fromAmino(object: _475.RequestEchoAmino): _475.RequestEcho;
-            toAmino(message: _475.RequestEcho): _475.RequestEchoAmino;
-            fromAminoMsg(object: _475.RequestEchoAminoMsg): _475.RequestEcho;
-            fromProtoMsg(message: _475.RequestEchoProtoMsg): _475.RequestEcho;
-            toProto(message: _475.RequestEcho): Uint8Array;
-            toProtoMsg(message: _475.RequestEcho): _475.RequestEchoProtoMsg;
+            encode(message: _536.RequestEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestEcho;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestEcho>): _536.RequestEcho;
+            fromAmino(object: _536.RequestEchoAmino): _536.RequestEcho;
+            toAmino(message: _536.RequestEcho): _536.RequestEchoAmino;
+            fromAminoMsg(object: _536.RequestEchoAminoMsg): _536.RequestEcho;
+            fromProtoMsg(message: _536.RequestEchoProtoMsg): _536.RequestEcho;
+            toProto(message: _536.RequestEcho): Uint8Array;
+            toProtoMsg(message: _536.RequestEcho): _536.RequestEchoProtoMsg;
         };
         RequestFlush: {
             typeUrl: string;
-            encode(_: _475.RequestFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestFlush;
-            fromPartial(_: import("../helpers").DeepPartial<_475.RequestFlush>): _475.RequestFlush;
-            fromAmino(_: _475.RequestFlushAmino): _475.RequestFlush;
-            toAmino(_: _475.RequestFlush): _475.RequestFlushAmino;
-            fromAminoMsg(object: _475.RequestFlushAminoMsg): _475.RequestFlush;
-            fromProtoMsg(message: _475.RequestFlushProtoMsg): _475.RequestFlush;
-            toProto(message: _475.RequestFlush): Uint8Array;
-            toProtoMsg(message: _475.RequestFlush): _475.RequestFlushProtoMsg;
+            encode(_: _536.RequestFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestFlush;
+            fromPartial(_: import("../helpers").DeepPartial<_536.RequestFlush>): _536.RequestFlush;
+            fromAmino(_: _536.RequestFlushAmino): _536.RequestFlush;
+            toAmino(_: _536.RequestFlush): _536.RequestFlushAmino;
+            fromAminoMsg(object: _536.RequestFlushAminoMsg): _536.RequestFlush;
+            fromProtoMsg(message: _536.RequestFlushProtoMsg): _536.RequestFlush;
+            toProto(message: _536.RequestFlush): Uint8Array;
+            toProtoMsg(message: _536.RequestFlush): _536.RequestFlushProtoMsg;
         };
         RequestInfo: {
             typeUrl: string;
-            encode(message: _475.RequestInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestInfo>): _475.RequestInfo;
-            fromAmino(object: _475.RequestInfoAmino): _475.RequestInfo;
-            toAmino(message: _475.RequestInfo): _475.RequestInfoAmino;
-            fromAminoMsg(object: _475.RequestInfoAminoMsg): _475.RequestInfo;
-            fromProtoMsg(message: _475.RequestInfoProtoMsg): _475.RequestInfo;
-            toProto(message: _475.RequestInfo): Uint8Array;
-            toProtoMsg(message: _475.RequestInfo): _475.RequestInfoProtoMsg;
+            encode(message: _536.RequestInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestInfo>): _536.RequestInfo;
+            fromAmino(object: _536.RequestInfoAmino): _536.RequestInfo;
+            toAmino(message: _536.RequestInfo): _536.RequestInfoAmino;
+            fromAminoMsg(object: _536.RequestInfoAminoMsg): _536.RequestInfo;
+            fromProtoMsg(message: _536.RequestInfoProtoMsg): _536.RequestInfo;
+            toProto(message: _536.RequestInfo): Uint8Array;
+            toProtoMsg(message: _536.RequestInfo): _536.RequestInfoProtoMsg;
         };
         RequestInitChain: {
             typeUrl: string;
-            encode(message: _475.RequestInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestInitChain;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestInitChain>): _475.RequestInitChain;
-            fromAmino(object: _475.RequestInitChainAmino): _475.RequestInitChain;
-            toAmino(message: _475.RequestInitChain): _475.RequestInitChainAmino;
-            fromAminoMsg(object: _475.RequestInitChainAminoMsg): _475.RequestInitChain;
-            fromProtoMsg(message: _475.RequestInitChainProtoMsg): _475.RequestInitChain;
-            toProto(message: _475.RequestInitChain): Uint8Array;
-            toProtoMsg(message: _475.RequestInitChain): _475.RequestInitChainProtoMsg;
+            encode(message: _536.RequestInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestInitChain;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestInitChain>): _536.RequestInitChain;
+            fromAmino(object: _536.RequestInitChainAmino): _536.RequestInitChain;
+            toAmino(message: _536.RequestInitChain): _536.RequestInitChainAmino;
+            fromAminoMsg(object: _536.RequestInitChainAminoMsg): _536.RequestInitChain;
+            fromProtoMsg(message: _536.RequestInitChainProtoMsg): _536.RequestInitChain;
+            toProto(message: _536.RequestInitChain): Uint8Array;
+            toProtoMsg(message: _536.RequestInitChain): _536.RequestInitChainProtoMsg;
         };
         RequestQuery: {
             typeUrl: string;
-            encode(message: _475.RequestQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestQuery;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestQuery>): _475.RequestQuery;
-            fromAmino(object: _475.RequestQueryAmino): _475.RequestQuery;
-            toAmino(message: _475.RequestQuery): _475.RequestQueryAmino;
-            fromAminoMsg(object: _475.RequestQueryAminoMsg): _475.RequestQuery;
-            fromProtoMsg(message: _475.RequestQueryProtoMsg): _475.RequestQuery;
-            toProto(message: _475.RequestQuery): Uint8Array;
-            toProtoMsg(message: _475.RequestQuery): _475.RequestQueryProtoMsg;
+            encode(message: _536.RequestQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestQuery;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestQuery>): _536.RequestQuery;
+            fromAmino(object: _536.RequestQueryAmino): _536.RequestQuery;
+            toAmino(message: _536.RequestQuery): _536.RequestQueryAmino;
+            fromAminoMsg(object: _536.RequestQueryAminoMsg): _536.RequestQuery;
+            fromProtoMsg(message: _536.RequestQueryProtoMsg): _536.RequestQuery;
+            toProto(message: _536.RequestQuery): Uint8Array;
+            toProtoMsg(message: _536.RequestQuery): _536.RequestQueryProtoMsg;
         };
         RequestCheckTx: {
             typeUrl: string;
-            encode(message: _475.RequestCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestCheckTx;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestCheckTx>): _475.RequestCheckTx;
-            fromAmino(object: _475.RequestCheckTxAmino): _475.RequestCheckTx;
-            toAmino(message: _475.RequestCheckTx): _475.RequestCheckTxAmino;
-            fromAminoMsg(object: _475.RequestCheckTxAminoMsg): _475.RequestCheckTx;
-            fromProtoMsg(message: _475.RequestCheckTxProtoMsg): _475.RequestCheckTx;
-            toProto(message: _475.RequestCheckTx): Uint8Array;
-            toProtoMsg(message: _475.RequestCheckTx): _475.RequestCheckTxProtoMsg;
+            encode(message: _536.RequestCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestCheckTx;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestCheckTx>): _536.RequestCheckTx;
+            fromAmino(object: _536.RequestCheckTxAmino): _536.RequestCheckTx;
+            toAmino(message: _536.RequestCheckTx): _536.RequestCheckTxAmino;
+            fromAminoMsg(object: _536.RequestCheckTxAminoMsg): _536.RequestCheckTx;
+            fromProtoMsg(message: _536.RequestCheckTxProtoMsg): _536.RequestCheckTx;
+            toProto(message: _536.RequestCheckTx): Uint8Array;
+            toProtoMsg(message: _536.RequestCheckTx): _536.RequestCheckTxProtoMsg;
         };
         RequestCommit: {
             typeUrl: string;
-            encode(_: _475.RequestCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestCommit;
-            fromPartial(_: import("../helpers").DeepPartial<_475.RequestCommit>): _475.RequestCommit;
-            fromAmino(_: _475.RequestCommitAmino): _475.RequestCommit;
-            toAmino(_: _475.RequestCommit): _475.RequestCommitAmino;
-            fromAminoMsg(object: _475.RequestCommitAminoMsg): _475.RequestCommit;
-            fromProtoMsg(message: _475.RequestCommitProtoMsg): _475.RequestCommit;
-            toProto(message: _475.RequestCommit): Uint8Array;
-            toProtoMsg(message: _475.RequestCommit): _475.RequestCommitProtoMsg;
+            encode(_: _536.RequestCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestCommit;
+            fromPartial(_: import("../helpers").DeepPartial<_536.RequestCommit>): _536.RequestCommit;
+            fromAmino(_: _536.RequestCommitAmino): _536.RequestCommit;
+            toAmino(_: _536.RequestCommit): _536.RequestCommitAmino;
+            fromAminoMsg(object: _536.RequestCommitAminoMsg): _536.RequestCommit;
+            fromProtoMsg(message: _536.RequestCommitProtoMsg): _536.RequestCommit;
+            toProto(message: _536.RequestCommit): Uint8Array;
+            toProtoMsg(message: _536.RequestCommit): _536.RequestCommitProtoMsg;
         };
         RequestListSnapshots: {
             typeUrl: string;
-            encode(_: _475.RequestListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestListSnapshots;
-            fromPartial(_: import("../helpers").DeepPartial<_475.RequestListSnapshots>): _475.RequestListSnapshots;
-            fromAmino(_: _475.RequestListSnapshotsAmino): _475.RequestListSnapshots;
-            toAmino(_: _475.RequestListSnapshots): _475.RequestListSnapshotsAmino;
-            fromAminoMsg(object: _475.RequestListSnapshotsAminoMsg): _475.RequestListSnapshots;
-            fromProtoMsg(message: _475.RequestListSnapshotsProtoMsg): _475.RequestListSnapshots;
-            toProto(message: _475.RequestListSnapshots): Uint8Array;
-            toProtoMsg(message: _475.RequestListSnapshots): _475.RequestListSnapshotsProtoMsg;
+            encode(_: _536.RequestListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestListSnapshots;
+            fromPartial(_: import("../helpers").DeepPartial<_536.RequestListSnapshots>): _536.RequestListSnapshots;
+            fromAmino(_: _536.RequestListSnapshotsAmino): _536.RequestListSnapshots;
+            toAmino(_: _536.RequestListSnapshots): _536.RequestListSnapshotsAmino;
+            fromAminoMsg(object: _536.RequestListSnapshotsAminoMsg): _536.RequestListSnapshots;
+            fromProtoMsg(message: _536.RequestListSnapshotsProtoMsg): _536.RequestListSnapshots;
+            toProto(message: _536.RequestListSnapshots): Uint8Array;
+            toProtoMsg(message: _536.RequestListSnapshots): _536.RequestListSnapshotsProtoMsg;
         };
         RequestOfferSnapshot: {
             typeUrl: string;
-            encode(message: _475.RequestOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestOfferSnapshot;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestOfferSnapshot>): _475.RequestOfferSnapshot;
-            fromAmino(object: _475.RequestOfferSnapshotAmino): _475.RequestOfferSnapshot;
-            toAmino(message: _475.RequestOfferSnapshot): _475.RequestOfferSnapshotAmino;
-            fromAminoMsg(object: _475.RequestOfferSnapshotAminoMsg): _475.RequestOfferSnapshot;
-            fromProtoMsg(message: _475.RequestOfferSnapshotProtoMsg): _475.RequestOfferSnapshot;
-            toProto(message: _475.RequestOfferSnapshot): Uint8Array;
-            toProtoMsg(message: _475.RequestOfferSnapshot): _475.RequestOfferSnapshotProtoMsg;
+            encode(message: _536.RequestOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestOfferSnapshot;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestOfferSnapshot>): _536.RequestOfferSnapshot;
+            fromAmino(object: _536.RequestOfferSnapshotAmino): _536.RequestOfferSnapshot;
+            toAmino(message: _536.RequestOfferSnapshot): _536.RequestOfferSnapshotAmino;
+            fromAminoMsg(object: _536.RequestOfferSnapshotAminoMsg): _536.RequestOfferSnapshot;
+            fromProtoMsg(message: _536.RequestOfferSnapshotProtoMsg): _536.RequestOfferSnapshot;
+            toProto(message: _536.RequestOfferSnapshot): Uint8Array;
+            toProtoMsg(message: _536.RequestOfferSnapshot): _536.RequestOfferSnapshotProtoMsg;
         };
         RequestLoadSnapshotChunk: {
             typeUrl: string;
-            encode(message: _475.RequestLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestLoadSnapshotChunk;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestLoadSnapshotChunk>): _475.RequestLoadSnapshotChunk;
-            fromAmino(object: _475.RequestLoadSnapshotChunkAmino): _475.RequestLoadSnapshotChunk;
-            toAmino(message: _475.RequestLoadSnapshotChunk): _475.RequestLoadSnapshotChunkAmino;
-            fromAminoMsg(object: _475.RequestLoadSnapshotChunkAminoMsg): _475.RequestLoadSnapshotChunk;
-            fromProtoMsg(message: _475.RequestLoadSnapshotChunkProtoMsg): _475.RequestLoadSnapshotChunk;
-            toProto(message: _475.RequestLoadSnapshotChunk): Uint8Array;
-            toProtoMsg(message: _475.RequestLoadSnapshotChunk): _475.RequestLoadSnapshotChunkProtoMsg;
+            encode(message: _536.RequestLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestLoadSnapshotChunk;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestLoadSnapshotChunk>): _536.RequestLoadSnapshotChunk;
+            fromAmino(object: _536.RequestLoadSnapshotChunkAmino): _536.RequestLoadSnapshotChunk;
+            toAmino(message: _536.RequestLoadSnapshotChunk): _536.RequestLoadSnapshotChunkAmino;
+            fromAminoMsg(object: _536.RequestLoadSnapshotChunkAminoMsg): _536.RequestLoadSnapshotChunk;
+            fromProtoMsg(message: _536.RequestLoadSnapshotChunkProtoMsg): _536.RequestLoadSnapshotChunk;
+            toProto(message: _536.RequestLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: _536.RequestLoadSnapshotChunk): _536.RequestLoadSnapshotChunkProtoMsg;
         };
         RequestApplySnapshotChunk: {
             typeUrl: string;
-            encode(message: _475.RequestApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestApplySnapshotChunk;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestApplySnapshotChunk>): _475.RequestApplySnapshotChunk;
-            fromAmino(object: _475.RequestApplySnapshotChunkAmino): _475.RequestApplySnapshotChunk;
-            toAmino(message: _475.RequestApplySnapshotChunk): _475.RequestApplySnapshotChunkAmino;
-            fromAminoMsg(object: _475.RequestApplySnapshotChunkAminoMsg): _475.RequestApplySnapshotChunk;
-            fromProtoMsg(message: _475.RequestApplySnapshotChunkProtoMsg): _475.RequestApplySnapshotChunk;
-            toProto(message: _475.RequestApplySnapshotChunk): Uint8Array;
-            toProtoMsg(message: _475.RequestApplySnapshotChunk): _475.RequestApplySnapshotChunkProtoMsg;
+            encode(message: _536.RequestApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestApplySnapshotChunk;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestApplySnapshotChunk>): _536.RequestApplySnapshotChunk;
+            fromAmino(object: _536.RequestApplySnapshotChunkAmino): _536.RequestApplySnapshotChunk;
+            toAmino(message: _536.RequestApplySnapshotChunk): _536.RequestApplySnapshotChunkAmino;
+            fromAminoMsg(object: _536.RequestApplySnapshotChunkAminoMsg): _536.RequestApplySnapshotChunk;
+            fromProtoMsg(message: _536.RequestApplySnapshotChunkProtoMsg): _536.RequestApplySnapshotChunk;
+            toProto(message: _536.RequestApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: _536.RequestApplySnapshotChunk): _536.RequestApplySnapshotChunkProtoMsg;
         };
         RequestPrepareProposal: {
             typeUrl: string;
-            encode(message: _475.RequestPrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestPrepareProposal;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestPrepareProposal>): _475.RequestPrepareProposal;
-            fromAmino(object: _475.RequestPrepareProposalAmino): _475.RequestPrepareProposal;
-            toAmino(message: _475.RequestPrepareProposal): _475.RequestPrepareProposalAmino;
-            fromAminoMsg(object: _475.RequestPrepareProposalAminoMsg): _475.RequestPrepareProposal;
-            fromProtoMsg(message: _475.RequestPrepareProposalProtoMsg): _475.RequestPrepareProposal;
-            toProto(message: _475.RequestPrepareProposal): Uint8Array;
-            toProtoMsg(message: _475.RequestPrepareProposal): _475.RequestPrepareProposalProtoMsg;
+            encode(message: _536.RequestPrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestPrepareProposal;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestPrepareProposal>): _536.RequestPrepareProposal;
+            fromAmino(object: _536.RequestPrepareProposalAmino): _536.RequestPrepareProposal;
+            toAmino(message: _536.RequestPrepareProposal): _536.RequestPrepareProposalAmino;
+            fromAminoMsg(object: _536.RequestPrepareProposalAminoMsg): _536.RequestPrepareProposal;
+            fromProtoMsg(message: _536.RequestPrepareProposalProtoMsg): _536.RequestPrepareProposal;
+            toProto(message: _536.RequestPrepareProposal): Uint8Array;
+            toProtoMsg(message: _536.RequestPrepareProposal): _536.RequestPrepareProposalProtoMsg;
         };
         RequestProcessProposal: {
             typeUrl: string;
-            encode(message: _475.RequestProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestProcessProposal;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestProcessProposal>): _475.RequestProcessProposal;
-            fromAmino(object: _475.RequestProcessProposalAmino): _475.RequestProcessProposal;
-            toAmino(message: _475.RequestProcessProposal): _475.RequestProcessProposalAmino;
-            fromAminoMsg(object: _475.RequestProcessProposalAminoMsg): _475.RequestProcessProposal;
-            fromProtoMsg(message: _475.RequestProcessProposalProtoMsg): _475.RequestProcessProposal;
-            toProto(message: _475.RequestProcessProposal): Uint8Array;
-            toProtoMsg(message: _475.RequestProcessProposal): _475.RequestProcessProposalProtoMsg;
+            encode(message: _536.RequestProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestProcessProposal;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestProcessProposal>): _536.RequestProcessProposal;
+            fromAmino(object: _536.RequestProcessProposalAmino): _536.RequestProcessProposal;
+            toAmino(message: _536.RequestProcessProposal): _536.RequestProcessProposalAmino;
+            fromAminoMsg(object: _536.RequestProcessProposalAminoMsg): _536.RequestProcessProposal;
+            fromProtoMsg(message: _536.RequestProcessProposalProtoMsg): _536.RequestProcessProposal;
+            toProto(message: _536.RequestProcessProposal): Uint8Array;
+            toProtoMsg(message: _536.RequestProcessProposal): _536.RequestProcessProposalProtoMsg;
         };
         RequestExtendVote: {
             typeUrl: string;
-            encode(message: _475.RequestExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestExtendVote;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestExtendVote>): _475.RequestExtendVote;
-            fromAmino(object: _475.RequestExtendVoteAmino): _475.RequestExtendVote;
-            toAmino(message: _475.RequestExtendVote): _475.RequestExtendVoteAmino;
-            fromAminoMsg(object: _475.RequestExtendVoteAminoMsg): _475.RequestExtendVote;
-            fromProtoMsg(message: _475.RequestExtendVoteProtoMsg): _475.RequestExtendVote;
-            toProto(message: _475.RequestExtendVote): Uint8Array;
-            toProtoMsg(message: _475.RequestExtendVote): _475.RequestExtendVoteProtoMsg;
+            encode(message: _536.RequestExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestExtendVote;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestExtendVote>): _536.RequestExtendVote;
+            fromAmino(object: _536.RequestExtendVoteAmino): _536.RequestExtendVote;
+            toAmino(message: _536.RequestExtendVote): _536.RequestExtendVoteAmino;
+            fromAminoMsg(object: _536.RequestExtendVoteAminoMsg): _536.RequestExtendVote;
+            fromProtoMsg(message: _536.RequestExtendVoteProtoMsg): _536.RequestExtendVote;
+            toProto(message: _536.RequestExtendVote): Uint8Array;
+            toProtoMsg(message: _536.RequestExtendVote): _536.RequestExtendVoteProtoMsg;
         };
         RequestVerifyVoteExtension: {
             typeUrl: string;
-            encode(message: _475.RequestVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestVerifyVoteExtension;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestVerifyVoteExtension>): _475.RequestVerifyVoteExtension;
-            fromAmino(object: _475.RequestVerifyVoteExtensionAmino): _475.RequestVerifyVoteExtension;
-            toAmino(message: _475.RequestVerifyVoteExtension): _475.RequestVerifyVoteExtensionAmino;
-            fromAminoMsg(object: _475.RequestVerifyVoteExtensionAminoMsg): _475.RequestVerifyVoteExtension;
-            fromProtoMsg(message: _475.RequestVerifyVoteExtensionProtoMsg): _475.RequestVerifyVoteExtension;
-            toProto(message: _475.RequestVerifyVoteExtension): Uint8Array;
-            toProtoMsg(message: _475.RequestVerifyVoteExtension): _475.RequestVerifyVoteExtensionProtoMsg;
+            encode(message: _536.RequestVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestVerifyVoteExtension;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestVerifyVoteExtension>): _536.RequestVerifyVoteExtension;
+            fromAmino(object: _536.RequestVerifyVoteExtensionAmino): _536.RequestVerifyVoteExtension;
+            toAmino(message: _536.RequestVerifyVoteExtension): _536.RequestVerifyVoteExtensionAmino;
+            fromAminoMsg(object: _536.RequestVerifyVoteExtensionAminoMsg): _536.RequestVerifyVoteExtension;
+            fromProtoMsg(message: _536.RequestVerifyVoteExtensionProtoMsg): _536.RequestVerifyVoteExtension;
+            toProto(message: _536.RequestVerifyVoteExtension): Uint8Array;
+            toProtoMsg(message: _536.RequestVerifyVoteExtension): _536.RequestVerifyVoteExtensionProtoMsg;
         };
         RequestFinalizeBlock: {
             typeUrl: string;
-            encode(message: _475.RequestFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.RequestFinalizeBlock;
-            fromPartial(object: import("../helpers").DeepPartial<_475.RequestFinalizeBlock>): _475.RequestFinalizeBlock;
-            fromAmino(object: _475.RequestFinalizeBlockAmino): _475.RequestFinalizeBlock;
-            toAmino(message: _475.RequestFinalizeBlock): _475.RequestFinalizeBlockAmino;
-            fromAminoMsg(object: _475.RequestFinalizeBlockAminoMsg): _475.RequestFinalizeBlock;
-            fromProtoMsg(message: _475.RequestFinalizeBlockProtoMsg): _475.RequestFinalizeBlock;
-            toProto(message: _475.RequestFinalizeBlock): Uint8Array;
-            toProtoMsg(message: _475.RequestFinalizeBlock): _475.RequestFinalizeBlockProtoMsg;
+            encode(message: _536.RequestFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.RequestFinalizeBlock;
+            fromPartial(object: import("../helpers").DeepPartial<_536.RequestFinalizeBlock>): _536.RequestFinalizeBlock;
+            fromAmino(object: _536.RequestFinalizeBlockAmino): _536.RequestFinalizeBlock;
+            toAmino(message: _536.RequestFinalizeBlock): _536.RequestFinalizeBlockAmino;
+            fromAminoMsg(object: _536.RequestFinalizeBlockAminoMsg): _536.RequestFinalizeBlock;
+            fromProtoMsg(message: _536.RequestFinalizeBlockProtoMsg): _536.RequestFinalizeBlock;
+            toProto(message: _536.RequestFinalizeBlock): Uint8Array;
+            toProtoMsg(message: _536.RequestFinalizeBlock): _536.RequestFinalizeBlockProtoMsg;
         };
         Response: {
             typeUrl: string;
-            encode(message: _475.Response, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.Response;
-            fromPartial(object: import("../helpers").DeepPartial<_475.Response>): _475.Response;
-            fromAmino(object: _475.ResponseAmino): _475.Response;
-            toAmino(message: _475.Response): _475.ResponseAmino;
-            fromAminoMsg(object: _475.ResponseAminoMsg): _475.Response;
-            fromProtoMsg(message: _475.ResponseProtoMsg): _475.Response;
-            toProto(message: _475.Response): Uint8Array;
-            toProtoMsg(message: _475.Response): _475.ResponseProtoMsg;
+            encode(message: _536.Response, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Response;
+            fromPartial(object: import("../helpers").DeepPartial<_536.Response>): _536.Response;
+            fromAmino(object: _536.ResponseAmino): _536.Response;
+            toAmino(message: _536.Response): _536.ResponseAmino;
+            fromAminoMsg(object: _536.ResponseAminoMsg): _536.Response;
+            fromProtoMsg(message: _536.ResponseProtoMsg): _536.Response;
+            toProto(message: _536.Response): Uint8Array;
+            toProtoMsg(message: _536.Response): _536.ResponseProtoMsg;
         };
         ResponseException: {
             typeUrl: string;
-            encode(message: _475.ResponseException, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseException;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseException>): _475.ResponseException;
-            fromAmino(object: _475.ResponseExceptionAmino): _475.ResponseException;
-            toAmino(message: _475.ResponseException): _475.ResponseExceptionAmino;
-            fromAminoMsg(object: _475.ResponseExceptionAminoMsg): _475.ResponseException;
-            fromProtoMsg(message: _475.ResponseExceptionProtoMsg): _475.ResponseException;
-            toProto(message: _475.ResponseException): Uint8Array;
-            toProtoMsg(message: _475.ResponseException): _475.ResponseExceptionProtoMsg;
+            encode(message: _536.ResponseException, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseException;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseException>): _536.ResponseException;
+            fromAmino(object: _536.ResponseExceptionAmino): _536.ResponseException;
+            toAmino(message: _536.ResponseException): _536.ResponseExceptionAmino;
+            fromAminoMsg(object: _536.ResponseExceptionAminoMsg): _536.ResponseException;
+            fromProtoMsg(message: _536.ResponseExceptionProtoMsg): _536.ResponseException;
+            toProto(message: _536.ResponseException): Uint8Array;
+            toProtoMsg(message: _536.ResponseException): _536.ResponseExceptionProtoMsg;
         };
         ResponseEcho: {
             typeUrl: string;
-            encode(message: _475.ResponseEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseEcho;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseEcho>): _475.ResponseEcho;
-            fromAmino(object: _475.ResponseEchoAmino): _475.ResponseEcho;
-            toAmino(message: _475.ResponseEcho): _475.ResponseEchoAmino;
-            fromAminoMsg(object: _475.ResponseEchoAminoMsg): _475.ResponseEcho;
-            fromProtoMsg(message: _475.ResponseEchoProtoMsg): _475.ResponseEcho;
-            toProto(message: _475.ResponseEcho): Uint8Array;
-            toProtoMsg(message: _475.ResponseEcho): _475.ResponseEchoProtoMsg;
+            encode(message: _536.ResponseEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseEcho;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseEcho>): _536.ResponseEcho;
+            fromAmino(object: _536.ResponseEchoAmino): _536.ResponseEcho;
+            toAmino(message: _536.ResponseEcho): _536.ResponseEchoAmino;
+            fromAminoMsg(object: _536.ResponseEchoAminoMsg): _536.ResponseEcho;
+            fromProtoMsg(message: _536.ResponseEchoProtoMsg): _536.ResponseEcho;
+            toProto(message: _536.ResponseEcho): Uint8Array;
+            toProtoMsg(message: _536.ResponseEcho): _536.ResponseEchoProtoMsg;
         };
         ResponseFlush: {
             typeUrl: string;
-            encode(_: _475.ResponseFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseFlush;
-            fromPartial(_: import("../helpers").DeepPartial<_475.ResponseFlush>): _475.ResponseFlush;
-            fromAmino(_: _475.ResponseFlushAmino): _475.ResponseFlush;
-            toAmino(_: _475.ResponseFlush): _475.ResponseFlushAmino;
-            fromAminoMsg(object: _475.ResponseFlushAminoMsg): _475.ResponseFlush;
-            fromProtoMsg(message: _475.ResponseFlushProtoMsg): _475.ResponseFlush;
-            toProto(message: _475.ResponseFlush): Uint8Array;
-            toProtoMsg(message: _475.ResponseFlush): _475.ResponseFlushProtoMsg;
+            encode(_: _536.ResponseFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseFlush;
+            fromPartial(_: import("../helpers").DeepPartial<_536.ResponseFlush>): _536.ResponseFlush;
+            fromAmino(_: _536.ResponseFlushAmino): _536.ResponseFlush;
+            toAmino(_: _536.ResponseFlush): _536.ResponseFlushAmino;
+            fromAminoMsg(object: _536.ResponseFlushAminoMsg): _536.ResponseFlush;
+            fromProtoMsg(message: _536.ResponseFlushProtoMsg): _536.ResponseFlush;
+            toProto(message: _536.ResponseFlush): Uint8Array;
+            toProtoMsg(message: _536.ResponseFlush): _536.ResponseFlushProtoMsg;
         };
         ResponseInfo: {
             typeUrl: string;
-            encode(message: _475.ResponseInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseInfo>): _475.ResponseInfo;
-            fromAmino(object: _475.ResponseInfoAmino): _475.ResponseInfo;
-            toAmino(message: _475.ResponseInfo): _475.ResponseInfoAmino;
-            fromAminoMsg(object: _475.ResponseInfoAminoMsg): _475.ResponseInfo;
-            fromProtoMsg(message: _475.ResponseInfoProtoMsg): _475.ResponseInfo;
-            toProto(message: _475.ResponseInfo): Uint8Array;
-            toProtoMsg(message: _475.ResponseInfo): _475.ResponseInfoProtoMsg;
+            encode(message: _536.ResponseInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseInfo>): _536.ResponseInfo;
+            fromAmino(object: _536.ResponseInfoAmino): _536.ResponseInfo;
+            toAmino(message: _536.ResponseInfo): _536.ResponseInfoAmino;
+            fromAminoMsg(object: _536.ResponseInfoAminoMsg): _536.ResponseInfo;
+            fromProtoMsg(message: _536.ResponseInfoProtoMsg): _536.ResponseInfo;
+            toProto(message: _536.ResponseInfo): Uint8Array;
+            toProtoMsg(message: _536.ResponseInfo): _536.ResponseInfoProtoMsg;
         };
         ResponseInitChain: {
             typeUrl: string;
-            encode(message: _475.ResponseInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseInitChain;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseInitChain>): _475.ResponseInitChain;
-            fromAmino(object: _475.ResponseInitChainAmino): _475.ResponseInitChain;
-            toAmino(message: _475.ResponseInitChain): _475.ResponseInitChainAmino;
-            fromAminoMsg(object: _475.ResponseInitChainAminoMsg): _475.ResponseInitChain;
-            fromProtoMsg(message: _475.ResponseInitChainProtoMsg): _475.ResponseInitChain;
-            toProto(message: _475.ResponseInitChain): Uint8Array;
-            toProtoMsg(message: _475.ResponseInitChain): _475.ResponseInitChainProtoMsg;
+            encode(message: _536.ResponseInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseInitChain;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseInitChain>): _536.ResponseInitChain;
+            fromAmino(object: _536.ResponseInitChainAmino): _536.ResponseInitChain;
+            toAmino(message: _536.ResponseInitChain): _536.ResponseInitChainAmino;
+            fromAminoMsg(object: _536.ResponseInitChainAminoMsg): _536.ResponseInitChain;
+            fromProtoMsg(message: _536.ResponseInitChainProtoMsg): _536.ResponseInitChain;
+            toProto(message: _536.ResponseInitChain): Uint8Array;
+            toProtoMsg(message: _536.ResponseInitChain): _536.ResponseInitChainProtoMsg;
         };
         ResponseQuery: {
             typeUrl: string;
-            encode(message: _475.ResponseQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseQuery;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseQuery>): _475.ResponseQuery;
-            fromAmino(object: _475.ResponseQueryAmino): _475.ResponseQuery;
-            toAmino(message: _475.ResponseQuery): _475.ResponseQueryAmino;
-            fromAminoMsg(object: _475.ResponseQueryAminoMsg): _475.ResponseQuery;
-            fromProtoMsg(message: _475.ResponseQueryProtoMsg): _475.ResponseQuery;
-            toProto(message: _475.ResponseQuery): Uint8Array;
-            toProtoMsg(message: _475.ResponseQuery): _475.ResponseQueryProtoMsg;
+            encode(message: _536.ResponseQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseQuery;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseQuery>): _536.ResponseQuery;
+            fromAmino(object: _536.ResponseQueryAmino): _536.ResponseQuery;
+            toAmino(message: _536.ResponseQuery): _536.ResponseQueryAmino;
+            fromAminoMsg(object: _536.ResponseQueryAminoMsg): _536.ResponseQuery;
+            fromProtoMsg(message: _536.ResponseQueryProtoMsg): _536.ResponseQuery;
+            toProto(message: _536.ResponseQuery): Uint8Array;
+            toProtoMsg(message: _536.ResponseQuery): _536.ResponseQueryProtoMsg;
         };
         ResponseCheckTx: {
             typeUrl: string;
-            encode(message: _475.ResponseCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseCheckTx;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseCheckTx>): _475.ResponseCheckTx;
-            fromAmino(object: _475.ResponseCheckTxAmino): _475.ResponseCheckTx;
-            toAmino(message: _475.ResponseCheckTx): _475.ResponseCheckTxAmino;
-            fromAminoMsg(object: _475.ResponseCheckTxAminoMsg): _475.ResponseCheckTx;
-            fromProtoMsg(message: _475.ResponseCheckTxProtoMsg): _475.ResponseCheckTx;
-            toProto(message: _475.ResponseCheckTx): Uint8Array;
-            toProtoMsg(message: _475.ResponseCheckTx): _475.ResponseCheckTxProtoMsg;
+            encode(message: _536.ResponseCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseCheckTx;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseCheckTx>): _536.ResponseCheckTx;
+            fromAmino(object: _536.ResponseCheckTxAmino): _536.ResponseCheckTx;
+            toAmino(message: _536.ResponseCheckTx): _536.ResponseCheckTxAmino;
+            fromAminoMsg(object: _536.ResponseCheckTxAminoMsg): _536.ResponseCheckTx;
+            fromProtoMsg(message: _536.ResponseCheckTxProtoMsg): _536.ResponseCheckTx;
+            toProto(message: _536.ResponseCheckTx): Uint8Array;
+            toProtoMsg(message: _536.ResponseCheckTx): _536.ResponseCheckTxProtoMsg;
         };
         ResponseCommit: {
             typeUrl: string;
-            encode(message: _475.ResponseCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseCommit;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseCommit>): _475.ResponseCommit;
-            fromAmino(object: _475.ResponseCommitAmino): _475.ResponseCommit;
-            toAmino(message: _475.ResponseCommit): _475.ResponseCommitAmino;
-            fromAminoMsg(object: _475.ResponseCommitAminoMsg): _475.ResponseCommit;
-            fromProtoMsg(message: _475.ResponseCommitProtoMsg): _475.ResponseCommit;
-            toProto(message: _475.ResponseCommit): Uint8Array;
-            toProtoMsg(message: _475.ResponseCommit): _475.ResponseCommitProtoMsg;
+            encode(message: _536.ResponseCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseCommit;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseCommit>): _536.ResponseCommit;
+            fromAmino(object: _536.ResponseCommitAmino): _536.ResponseCommit;
+            toAmino(message: _536.ResponseCommit): _536.ResponseCommitAmino;
+            fromAminoMsg(object: _536.ResponseCommitAminoMsg): _536.ResponseCommit;
+            fromProtoMsg(message: _536.ResponseCommitProtoMsg): _536.ResponseCommit;
+            toProto(message: _536.ResponseCommit): Uint8Array;
+            toProtoMsg(message: _536.ResponseCommit): _536.ResponseCommitProtoMsg;
         };
         ResponseListSnapshots: {
             typeUrl: string;
-            encode(message: _475.ResponseListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseListSnapshots;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseListSnapshots>): _475.ResponseListSnapshots;
-            fromAmino(object: _475.ResponseListSnapshotsAmino): _475.ResponseListSnapshots;
-            toAmino(message: _475.ResponseListSnapshots): _475.ResponseListSnapshotsAmino;
-            fromAminoMsg(object: _475.ResponseListSnapshotsAminoMsg): _475.ResponseListSnapshots;
-            fromProtoMsg(message: _475.ResponseListSnapshotsProtoMsg): _475.ResponseListSnapshots;
-            toProto(message: _475.ResponseListSnapshots): Uint8Array;
-            toProtoMsg(message: _475.ResponseListSnapshots): _475.ResponseListSnapshotsProtoMsg;
+            encode(message: _536.ResponseListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseListSnapshots;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseListSnapshots>): _536.ResponseListSnapshots;
+            fromAmino(object: _536.ResponseListSnapshotsAmino): _536.ResponseListSnapshots;
+            toAmino(message: _536.ResponseListSnapshots): _536.ResponseListSnapshotsAmino;
+            fromAminoMsg(object: _536.ResponseListSnapshotsAminoMsg): _536.ResponseListSnapshots;
+            fromProtoMsg(message: _536.ResponseListSnapshotsProtoMsg): _536.ResponseListSnapshots;
+            toProto(message: _536.ResponseListSnapshots): Uint8Array;
+            toProtoMsg(message: _536.ResponseListSnapshots): _536.ResponseListSnapshotsProtoMsg;
         };
         ResponseOfferSnapshot: {
             typeUrl: string;
-            encode(message: _475.ResponseOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseOfferSnapshot;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseOfferSnapshot>): _475.ResponseOfferSnapshot;
-            fromAmino(object: _475.ResponseOfferSnapshotAmino): _475.ResponseOfferSnapshot;
-            toAmino(message: _475.ResponseOfferSnapshot): _475.ResponseOfferSnapshotAmino;
-            fromAminoMsg(object: _475.ResponseOfferSnapshotAminoMsg): _475.ResponseOfferSnapshot;
-            fromProtoMsg(message: _475.ResponseOfferSnapshotProtoMsg): _475.ResponseOfferSnapshot;
-            toProto(message: _475.ResponseOfferSnapshot): Uint8Array;
-            toProtoMsg(message: _475.ResponseOfferSnapshot): _475.ResponseOfferSnapshotProtoMsg;
+            encode(message: _536.ResponseOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseOfferSnapshot;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseOfferSnapshot>): _536.ResponseOfferSnapshot;
+            fromAmino(object: _536.ResponseOfferSnapshotAmino): _536.ResponseOfferSnapshot;
+            toAmino(message: _536.ResponseOfferSnapshot): _536.ResponseOfferSnapshotAmino;
+            fromAminoMsg(object: _536.ResponseOfferSnapshotAminoMsg): _536.ResponseOfferSnapshot;
+            fromProtoMsg(message: _536.ResponseOfferSnapshotProtoMsg): _536.ResponseOfferSnapshot;
+            toProto(message: _536.ResponseOfferSnapshot): Uint8Array;
+            toProtoMsg(message: _536.ResponseOfferSnapshot): _536.ResponseOfferSnapshotProtoMsg;
         };
         ResponseLoadSnapshotChunk: {
             typeUrl: string;
-            encode(message: _475.ResponseLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseLoadSnapshotChunk;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseLoadSnapshotChunk>): _475.ResponseLoadSnapshotChunk;
-            fromAmino(object: _475.ResponseLoadSnapshotChunkAmino): _475.ResponseLoadSnapshotChunk;
-            toAmino(message: _475.ResponseLoadSnapshotChunk): _475.ResponseLoadSnapshotChunkAmino;
-            fromAminoMsg(object: _475.ResponseLoadSnapshotChunkAminoMsg): _475.ResponseLoadSnapshotChunk;
-            fromProtoMsg(message: _475.ResponseLoadSnapshotChunkProtoMsg): _475.ResponseLoadSnapshotChunk;
-            toProto(message: _475.ResponseLoadSnapshotChunk): Uint8Array;
-            toProtoMsg(message: _475.ResponseLoadSnapshotChunk): _475.ResponseLoadSnapshotChunkProtoMsg;
+            encode(message: _536.ResponseLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseLoadSnapshotChunk;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseLoadSnapshotChunk>): _536.ResponseLoadSnapshotChunk;
+            fromAmino(object: _536.ResponseLoadSnapshotChunkAmino): _536.ResponseLoadSnapshotChunk;
+            toAmino(message: _536.ResponseLoadSnapshotChunk): _536.ResponseLoadSnapshotChunkAmino;
+            fromAminoMsg(object: _536.ResponseLoadSnapshotChunkAminoMsg): _536.ResponseLoadSnapshotChunk;
+            fromProtoMsg(message: _536.ResponseLoadSnapshotChunkProtoMsg): _536.ResponseLoadSnapshotChunk;
+            toProto(message: _536.ResponseLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: _536.ResponseLoadSnapshotChunk): _536.ResponseLoadSnapshotChunkProtoMsg;
         };
         ResponseApplySnapshotChunk: {
             typeUrl: string;
-            encode(message: _475.ResponseApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseApplySnapshotChunk;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseApplySnapshotChunk>): _475.ResponseApplySnapshotChunk;
-            fromAmino(object: _475.ResponseApplySnapshotChunkAmino): _475.ResponseApplySnapshotChunk;
-            toAmino(message: _475.ResponseApplySnapshotChunk): _475.ResponseApplySnapshotChunkAmino;
-            fromAminoMsg(object: _475.ResponseApplySnapshotChunkAminoMsg): _475.ResponseApplySnapshotChunk;
-            fromProtoMsg(message: _475.ResponseApplySnapshotChunkProtoMsg): _475.ResponseApplySnapshotChunk;
-            toProto(message: _475.ResponseApplySnapshotChunk): Uint8Array;
-            toProtoMsg(message: _475.ResponseApplySnapshotChunk): _475.ResponseApplySnapshotChunkProtoMsg;
+            encode(message: _536.ResponseApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseApplySnapshotChunk;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseApplySnapshotChunk>): _536.ResponseApplySnapshotChunk;
+            fromAmino(object: _536.ResponseApplySnapshotChunkAmino): _536.ResponseApplySnapshotChunk;
+            toAmino(message: _536.ResponseApplySnapshotChunk): _536.ResponseApplySnapshotChunkAmino;
+            fromAminoMsg(object: _536.ResponseApplySnapshotChunkAminoMsg): _536.ResponseApplySnapshotChunk;
+            fromProtoMsg(message: _536.ResponseApplySnapshotChunkProtoMsg): _536.ResponseApplySnapshotChunk;
+            toProto(message: _536.ResponseApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: _536.ResponseApplySnapshotChunk): _536.ResponseApplySnapshotChunkProtoMsg;
         };
         ResponsePrepareProposal: {
             typeUrl: string;
-            encode(message: _475.ResponsePrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponsePrepareProposal;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponsePrepareProposal>): _475.ResponsePrepareProposal;
-            fromAmino(object: _475.ResponsePrepareProposalAmino): _475.ResponsePrepareProposal;
-            toAmino(message: _475.ResponsePrepareProposal): _475.ResponsePrepareProposalAmino;
-            fromAminoMsg(object: _475.ResponsePrepareProposalAminoMsg): _475.ResponsePrepareProposal;
-            fromProtoMsg(message: _475.ResponsePrepareProposalProtoMsg): _475.ResponsePrepareProposal;
-            toProto(message: _475.ResponsePrepareProposal): Uint8Array;
-            toProtoMsg(message: _475.ResponsePrepareProposal): _475.ResponsePrepareProposalProtoMsg;
+            encode(message: _536.ResponsePrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponsePrepareProposal;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponsePrepareProposal>): _536.ResponsePrepareProposal;
+            fromAmino(object: _536.ResponsePrepareProposalAmino): _536.ResponsePrepareProposal;
+            toAmino(message: _536.ResponsePrepareProposal): _536.ResponsePrepareProposalAmino;
+            fromAminoMsg(object: _536.ResponsePrepareProposalAminoMsg): _536.ResponsePrepareProposal;
+            fromProtoMsg(message: _536.ResponsePrepareProposalProtoMsg): _536.ResponsePrepareProposal;
+            toProto(message: _536.ResponsePrepareProposal): Uint8Array;
+            toProtoMsg(message: _536.ResponsePrepareProposal): _536.ResponsePrepareProposalProtoMsg;
         };
         ResponseProcessProposal: {
             typeUrl: string;
-            encode(message: _475.ResponseProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseProcessProposal;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseProcessProposal>): _475.ResponseProcessProposal;
-            fromAmino(object: _475.ResponseProcessProposalAmino): _475.ResponseProcessProposal;
-            toAmino(message: _475.ResponseProcessProposal): _475.ResponseProcessProposalAmino;
-            fromAminoMsg(object: _475.ResponseProcessProposalAminoMsg): _475.ResponseProcessProposal;
-            fromProtoMsg(message: _475.ResponseProcessProposalProtoMsg): _475.ResponseProcessProposal;
-            toProto(message: _475.ResponseProcessProposal): Uint8Array;
-            toProtoMsg(message: _475.ResponseProcessProposal): _475.ResponseProcessProposalProtoMsg;
+            encode(message: _536.ResponseProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseProcessProposal;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseProcessProposal>): _536.ResponseProcessProposal;
+            fromAmino(object: _536.ResponseProcessProposalAmino): _536.ResponseProcessProposal;
+            toAmino(message: _536.ResponseProcessProposal): _536.ResponseProcessProposalAmino;
+            fromAminoMsg(object: _536.ResponseProcessProposalAminoMsg): _536.ResponseProcessProposal;
+            fromProtoMsg(message: _536.ResponseProcessProposalProtoMsg): _536.ResponseProcessProposal;
+            toProto(message: _536.ResponseProcessProposal): Uint8Array;
+            toProtoMsg(message: _536.ResponseProcessProposal): _536.ResponseProcessProposalProtoMsg;
         };
         ResponseExtendVote: {
             typeUrl: string;
-            encode(message: _475.ResponseExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseExtendVote;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseExtendVote>): _475.ResponseExtendVote;
-            fromAmino(object: _475.ResponseExtendVoteAmino): _475.ResponseExtendVote;
-            toAmino(message: _475.ResponseExtendVote): _475.ResponseExtendVoteAmino;
-            fromAminoMsg(object: _475.ResponseExtendVoteAminoMsg): _475.ResponseExtendVote;
-            fromProtoMsg(message: _475.ResponseExtendVoteProtoMsg): _475.ResponseExtendVote;
-            toProto(message: _475.ResponseExtendVote): Uint8Array;
-            toProtoMsg(message: _475.ResponseExtendVote): _475.ResponseExtendVoteProtoMsg;
+            encode(message: _536.ResponseExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseExtendVote;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseExtendVote>): _536.ResponseExtendVote;
+            fromAmino(object: _536.ResponseExtendVoteAmino): _536.ResponseExtendVote;
+            toAmino(message: _536.ResponseExtendVote): _536.ResponseExtendVoteAmino;
+            fromAminoMsg(object: _536.ResponseExtendVoteAminoMsg): _536.ResponseExtendVote;
+            fromProtoMsg(message: _536.ResponseExtendVoteProtoMsg): _536.ResponseExtendVote;
+            toProto(message: _536.ResponseExtendVote): Uint8Array;
+            toProtoMsg(message: _536.ResponseExtendVote): _536.ResponseExtendVoteProtoMsg;
         };
         ResponseVerifyVoteExtension: {
             typeUrl: string;
-            encode(message: _475.ResponseVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseVerifyVoteExtension;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseVerifyVoteExtension>): _475.ResponseVerifyVoteExtension;
-            fromAmino(object: _475.ResponseVerifyVoteExtensionAmino): _475.ResponseVerifyVoteExtension;
-            toAmino(message: _475.ResponseVerifyVoteExtension): _475.ResponseVerifyVoteExtensionAmino;
-            fromAminoMsg(object: _475.ResponseVerifyVoteExtensionAminoMsg): _475.ResponseVerifyVoteExtension;
-            fromProtoMsg(message: _475.ResponseVerifyVoteExtensionProtoMsg): _475.ResponseVerifyVoteExtension;
-            toProto(message: _475.ResponseVerifyVoteExtension): Uint8Array;
-            toProtoMsg(message: _475.ResponseVerifyVoteExtension): _475.ResponseVerifyVoteExtensionProtoMsg;
+            encode(message: _536.ResponseVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseVerifyVoteExtension;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseVerifyVoteExtension>): _536.ResponseVerifyVoteExtension;
+            fromAmino(object: _536.ResponseVerifyVoteExtensionAmino): _536.ResponseVerifyVoteExtension;
+            toAmino(message: _536.ResponseVerifyVoteExtension): _536.ResponseVerifyVoteExtensionAmino;
+            fromAminoMsg(object: _536.ResponseVerifyVoteExtensionAminoMsg): _536.ResponseVerifyVoteExtension;
+            fromProtoMsg(message: _536.ResponseVerifyVoteExtensionProtoMsg): _536.ResponseVerifyVoteExtension;
+            toProto(message: _536.ResponseVerifyVoteExtension): Uint8Array;
+            toProtoMsg(message: _536.ResponseVerifyVoteExtension): _536.ResponseVerifyVoteExtensionProtoMsg;
         };
         ResponseFinalizeBlock: {
             typeUrl: string;
-            encode(message: _475.ResponseFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ResponseFinalizeBlock;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ResponseFinalizeBlock>): _475.ResponseFinalizeBlock;
-            fromAmino(object: _475.ResponseFinalizeBlockAmino): _475.ResponseFinalizeBlock;
-            toAmino(message: _475.ResponseFinalizeBlock): _475.ResponseFinalizeBlockAmino;
-            fromAminoMsg(object: _475.ResponseFinalizeBlockAminoMsg): _475.ResponseFinalizeBlock;
-            fromProtoMsg(message: _475.ResponseFinalizeBlockProtoMsg): _475.ResponseFinalizeBlock;
-            toProto(message: _475.ResponseFinalizeBlock): Uint8Array;
-            toProtoMsg(message: _475.ResponseFinalizeBlock): _475.ResponseFinalizeBlockProtoMsg;
+            encode(message: _536.ResponseFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ResponseFinalizeBlock;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ResponseFinalizeBlock>): _536.ResponseFinalizeBlock;
+            fromAmino(object: _536.ResponseFinalizeBlockAmino): _536.ResponseFinalizeBlock;
+            toAmino(message: _536.ResponseFinalizeBlock): _536.ResponseFinalizeBlockAmino;
+            fromAminoMsg(object: _536.ResponseFinalizeBlockAminoMsg): _536.ResponseFinalizeBlock;
+            fromProtoMsg(message: _536.ResponseFinalizeBlockProtoMsg): _536.ResponseFinalizeBlock;
+            toProto(message: _536.ResponseFinalizeBlock): Uint8Array;
+            toProtoMsg(message: _536.ResponseFinalizeBlock): _536.ResponseFinalizeBlockProtoMsg;
         };
         CommitInfo: {
             typeUrl: string;
-            encode(message: _475.CommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.CommitInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_475.CommitInfo>): _475.CommitInfo;
-            fromAmino(object: _475.CommitInfoAmino): _475.CommitInfo;
-            toAmino(message: _475.CommitInfo): _475.CommitInfoAmino;
-            fromAminoMsg(object: _475.CommitInfoAminoMsg): _475.CommitInfo;
-            fromProtoMsg(message: _475.CommitInfoProtoMsg): _475.CommitInfo;
-            toProto(message: _475.CommitInfo): Uint8Array;
-            toProtoMsg(message: _475.CommitInfo): _475.CommitInfoProtoMsg;
+            encode(message: _536.CommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.CommitInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_536.CommitInfo>): _536.CommitInfo;
+            fromAmino(object: _536.CommitInfoAmino): _536.CommitInfo;
+            toAmino(message: _536.CommitInfo): _536.CommitInfoAmino;
+            fromAminoMsg(object: _536.CommitInfoAminoMsg): _536.CommitInfo;
+            fromProtoMsg(message: _536.CommitInfoProtoMsg): _536.CommitInfo;
+            toProto(message: _536.CommitInfo): Uint8Array;
+            toProtoMsg(message: _536.CommitInfo): _536.CommitInfoProtoMsg;
         };
         ExtendedCommitInfo: {
             typeUrl: string;
-            encode(message: _475.ExtendedCommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ExtendedCommitInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ExtendedCommitInfo>): _475.ExtendedCommitInfo;
-            fromAmino(object: _475.ExtendedCommitInfoAmino): _475.ExtendedCommitInfo;
-            toAmino(message: _475.ExtendedCommitInfo): _475.ExtendedCommitInfoAmino;
-            fromAminoMsg(object: _475.ExtendedCommitInfoAminoMsg): _475.ExtendedCommitInfo;
-            fromProtoMsg(message: _475.ExtendedCommitInfoProtoMsg): _475.ExtendedCommitInfo;
-            toProto(message: _475.ExtendedCommitInfo): Uint8Array;
-            toProtoMsg(message: _475.ExtendedCommitInfo): _475.ExtendedCommitInfoProtoMsg;
+            encode(message: _536.ExtendedCommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ExtendedCommitInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ExtendedCommitInfo>): _536.ExtendedCommitInfo;
+            fromAmino(object: _536.ExtendedCommitInfoAmino): _536.ExtendedCommitInfo;
+            toAmino(message: _536.ExtendedCommitInfo): _536.ExtendedCommitInfoAmino;
+            fromAminoMsg(object: _536.ExtendedCommitInfoAminoMsg): _536.ExtendedCommitInfo;
+            fromProtoMsg(message: _536.ExtendedCommitInfoProtoMsg): _536.ExtendedCommitInfo;
+            toProto(message: _536.ExtendedCommitInfo): Uint8Array;
+            toProtoMsg(message: _536.ExtendedCommitInfo): _536.ExtendedCommitInfoProtoMsg;
         };
         Event: {
             typeUrl: string;
-            encode(message: _475.Event, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.Event;
-            fromPartial(object: import("../helpers").DeepPartial<_475.Event>): _475.Event;
-            fromAmino(object: _475.EventAmino): _475.Event;
-            toAmino(message: _475.Event): _475.EventAmino;
-            fromAminoMsg(object: _475.EventAminoMsg): _475.Event;
-            fromProtoMsg(message: _475.EventProtoMsg): _475.Event;
-            toProto(message: _475.Event): Uint8Array;
-            toProtoMsg(message: _475.Event): _475.EventProtoMsg;
+            encode(message: _536.Event, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Event;
+            fromPartial(object: import("../helpers").DeepPartial<_536.Event>): _536.Event;
+            fromAmino(object: _536.EventAmino): _536.Event;
+            toAmino(message: _536.Event): _536.EventAmino;
+            fromAminoMsg(object: _536.EventAminoMsg): _536.Event;
+            fromProtoMsg(message: _536.EventProtoMsg): _536.Event;
+            toProto(message: _536.Event): Uint8Array;
+            toProtoMsg(message: _536.Event): _536.EventProtoMsg;
         };
         EventAttribute: {
             typeUrl: string;
-            encode(message: _475.EventAttribute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.EventAttribute;
-            fromPartial(object: import("../helpers").DeepPartial<_475.EventAttribute>): _475.EventAttribute;
-            fromAmino(object: _475.EventAttributeAmino): _475.EventAttribute;
-            toAmino(message: _475.EventAttribute): _475.EventAttributeAmino;
-            fromAminoMsg(object: _475.EventAttributeAminoMsg): _475.EventAttribute;
-            fromProtoMsg(message: _475.EventAttributeProtoMsg): _475.EventAttribute;
-            toProto(message: _475.EventAttribute): Uint8Array;
-            toProtoMsg(message: _475.EventAttribute): _475.EventAttributeProtoMsg;
+            encode(message: _536.EventAttribute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.EventAttribute;
+            fromPartial(object: import("../helpers").DeepPartial<_536.EventAttribute>): _536.EventAttribute;
+            fromAmino(object: _536.EventAttributeAmino): _536.EventAttribute;
+            toAmino(message: _536.EventAttribute): _536.EventAttributeAmino;
+            fromAminoMsg(object: _536.EventAttributeAminoMsg): _536.EventAttribute;
+            fromProtoMsg(message: _536.EventAttributeProtoMsg): _536.EventAttribute;
+            toProto(message: _536.EventAttribute): Uint8Array;
+            toProtoMsg(message: _536.EventAttribute): _536.EventAttributeProtoMsg;
         };
         ExecTxResult: {
             typeUrl: string;
-            encode(message: _475.ExecTxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ExecTxResult;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ExecTxResult>): _475.ExecTxResult;
-            fromAmino(object: _475.ExecTxResultAmino): _475.ExecTxResult;
-            toAmino(message: _475.ExecTxResult): _475.ExecTxResultAmino;
-            fromAminoMsg(object: _475.ExecTxResultAminoMsg): _475.ExecTxResult;
-            fromProtoMsg(message: _475.ExecTxResultProtoMsg): _475.ExecTxResult;
-            toProto(message: _475.ExecTxResult): Uint8Array;
-            toProtoMsg(message: _475.ExecTxResult): _475.ExecTxResultProtoMsg;
+            encode(message: _536.ExecTxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ExecTxResult;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ExecTxResult>): _536.ExecTxResult;
+            fromAmino(object: _536.ExecTxResultAmino): _536.ExecTxResult;
+            toAmino(message: _536.ExecTxResult): _536.ExecTxResultAmino;
+            fromAminoMsg(object: _536.ExecTxResultAminoMsg): _536.ExecTxResult;
+            fromProtoMsg(message: _536.ExecTxResultProtoMsg): _536.ExecTxResult;
+            toProto(message: _536.ExecTxResult): Uint8Array;
+            toProtoMsg(message: _536.ExecTxResult): _536.ExecTxResultProtoMsg;
         };
         TxResult: {
             typeUrl: string;
-            encode(message: _475.TxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.TxResult;
-            fromPartial(object: import("../helpers").DeepPartial<_475.TxResult>): _475.TxResult;
-            fromAmino(object: _475.TxResultAmino): _475.TxResult;
-            toAmino(message: _475.TxResult): _475.TxResultAmino;
-            fromAminoMsg(object: _475.TxResultAminoMsg): _475.TxResult;
-            fromProtoMsg(message: _475.TxResultProtoMsg): _475.TxResult;
-            toProto(message: _475.TxResult): Uint8Array;
-            toProtoMsg(message: _475.TxResult): _475.TxResultProtoMsg;
+            encode(message: _536.TxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.TxResult;
+            fromPartial(object: import("../helpers").DeepPartial<_536.TxResult>): _536.TxResult;
+            fromAmino(object: _536.TxResultAmino): _536.TxResult;
+            toAmino(message: _536.TxResult): _536.TxResultAmino;
+            fromAminoMsg(object: _536.TxResultAminoMsg): _536.TxResult;
+            fromProtoMsg(message: _536.TxResultProtoMsg): _536.TxResult;
+            toProto(message: _536.TxResult): Uint8Array;
+            toProtoMsg(message: _536.TxResult): _536.TxResultProtoMsg;
         };
         Validator: {
             typeUrl: string;
-            encode(message: _475.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.Validator;
-            fromPartial(object: import("../helpers").DeepPartial<_475.Validator>): _475.Validator;
-            fromAmino(object: _475.ValidatorAmino): _475.Validator;
-            toAmino(message: _475.Validator): _475.ValidatorAmino;
-            fromAminoMsg(object: _475.ValidatorAminoMsg): _475.Validator;
-            fromProtoMsg(message: _475.ValidatorProtoMsg): _475.Validator;
-            toProto(message: _475.Validator): Uint8Array;
-            toProtoMsg(message: _475.Validator): _475.ValidatorProtoMsg;
+            encode(message: _536.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Validator;
+            fromPartial(object: import("../helpers").DeepPartial<_536.Validator>): _536.Validator;
+            fromAmino(object: _536.ValidatorAmino): _536.Validator;
+            toAmino(message: _536.Validator): _536.ValidatorAmino;
+            fromAminoMsg(object: _536.ValidatorAminoMsg): _536.Validator;
+            fromProtoMsg(message: _536.ValidatorProtoMsg): _536.Validator;
+            toProto(message: _536.Validator): Uint8Array;
+            toProtoMsg(message: _536.Validator): _536.ValidatorProtoMsg;
         };
         ValidatorUpdate: {
             typeUrl: string;
-            encode(message: _475.ValidatorUpdate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ValidatorUpdate;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ValidatorUpdate>): _475.ValidatorUpdate;
-            fromAmino(object: _475.ValidatorUpdateAmino): _475.ValidatorUpdate;
-            toAmino(message: _475.ValidatorUpdate): _475.ValidatorUpdateAmino;
-            fromAminoMsg(object: _475.ValidatorUpdateAminoMsg): _475.ValidatorUpdate;
-            fromProtoMsg(message: _475.ValidatorUpdateProtoMsg): _475.ValidatorUpdate;
-            toProto(message: _475.ValidatorUpdate): Uint8Array;
-            toProtoMsg(message: _475.ValidatorUpdate): _475.ValidatorUpdateProtoMsg;
+            encode(message: _536.ValidatorUpdate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ValidatorUpdate;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ValidatorUpdate>): _536.ValidatorUpdate;
+            fromAmino(object: _536.ValidatorUpdateAmino): _536.ValidatorUpdate;
+            toAmino(message: _536.ValidatorUpdate): _536.ValidatorUpdateAmino;
+            fromAminoMsg(object: _536.ValidatorUpdateAminoMsg): _536.ValidatorUpdate;
+            fromProtoMsg(message: _536.ValidatorUpdateProtoMsg): _536.ValidatorUpdate;
+            toProto(message: _536.ValidatorUpdate): Uint8Array;
+            toProtoMsg(message: _536.ValidatorUpdate): _536.ValidatorUpdateProtoMsg;
         };
         VoteInfo: {
             typeUrl: string;
-            encode(message: _475.VoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.VoteInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_475.VoteInfo>): _475.VoteInfo;
-            fromAmino(object: _475.VoteInfoAmino): _475.VoteInfo;
-            toAmino(message: _475.VoteInfo): _475.VoteInfoAmino;
-            fromAminoMsg(object: _475.VoteInfoAminoMsg): _475.VoteInfo;
-            fromProtoMsg(message: _475.VoteInfoProtoMsg): _475.VoteInfo;
-            toProto(message: _475.VoteInfo): Uint8Array;
-            toProtoMsg(message: _475.VoteInfo): _475.VoteInfoProtoMsg;
+            encode(message: _536.VoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.VoteInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_536.VoteInfo>): _536.VoteInfo;
+            fromAmino(object: _536.VoteInfoAmino): _536.VoteInfo;
+            toAmino(message: _536.VoteInfo): _536.VoteInfoAmino;
+            fromAminoMsg(object: _536.VoteInfoAminoMsg): _536.VoteInfo;
+            fromProtoMsg(message: _536.VoteInfoProtoMsg): _536.VoteInfo;
+            toProto(message: _536.VoteInfo): Uint8Array;
+            toProtoMsg(message: _536.VoteInfo): _536.VoteInfoProtoMsg;
         };
         ExtendedVoteInfo: {
             typeUrl: string;
-            encode(message: _475.ExtendedVoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.ExtendedVoteInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_475.ExtendedVoteInfo>): _475.ExtendedVoteInfo;
-            fromAmino(object: _475.ExtendedVoteInfoAmino): _475.ExtendedVoteInfo;
-            toAmino(message: _475.ExtendedVoteInfo): _475.ExtendedVoteInfoAmino;
-            fromAminoMsg(object: _475.ExtendedVoteInfoAminoMsg): _475.ExtendedVoteInfo;
-            fromProtoMsg(message: _475.ExtendedVoteInfoProtoMsg): _475.ExtendedVoteInfo;
-            toProto(message: _475.ExtendedVoteInfo): Uint8Array;
-            toProtoMsg(message: _475.ExtendedVoteInfo): _475.ExtendedVoteInfoProtoMsg;
+            encode(message: _536.ExtendedVoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.ExtendedVoteInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_536.ExtendedVoteInfo>): _536.ExtendedVoteInfo;
+            fromAmino(object: _536.ExtendedVoteInfoAmino): _536.ExtendedVoteInfo;
+            toAmino(message: _536.ExtendedVoteInfo): _536.ExtendedVoteInfoAmino;
+            fromAminoMsg(object: _536.ExtendedVoteInfoAminoMsg): _536.ExtendedVoteInfo;
+            fromProtoMsg(message: _536.ExtendedVoteInfoProtoMsg): _536.ExtendedVoteInfo;
+            toProto(message: _536.ExtendedVoteInfo): Uint8Array;
+            toProtoMsg(message: _536.ExtendedVoteInfo): _536.ExtendedVoteInfoProtoMsg;
         };
         Misbehavior: {
             typeUrl: string;
-            encode(message: _475.Misbehavior, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.Misbehavior;
-            fromPartial(object: import("../helpers").DeepPartial<_475.Misbehavior>): _475.Misbehavior;
-            fromAmino(object: _475.MisbehaviorAmino): _475.Misbehavior;
-            toAmino(message: _475.Misbehavior): _475.MisbehaviorAmino;
-            fromAminoMsg(object: _475.MisbehaviorAminoMsg): _475.Misbehavior;
-            fromProtoMsg(message: _475.MisbehaviorProtoMsg): _475.Misbehavior;
-            toProto(message: _475.Misbehavior): Uint8Array;
-            toProtoMsg(message: _475.Misbehavior): _475.MisbehaviorProtoMsg;
+            encode(message: _536.Misbehavior, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Misbehavior;
+            fromPartial(object: import("../helpers").DeepPartial<_536.Misbehavior>): _536.Misbehavior;
+            fromAmino(object: _536.MisbehaviorAmino): _536.Misbehavior;
+            toAmino(message: _536.Misbehavior): _536.MisbehaviorAmino;
+            fromAminoMsg(object: _536.MisbehaviorAminoMsg): _536.Misbehavior;
+            fromProtoMsg(message: _536.MisbehaviorProtoMsg): _536.Misbehavior;
+            toProto(message: _536.Misbehavior): Uint8Array;
+            toProtoMsg(message: _536.Misbehavior): _536.MisbehaviorProtoMsg;
         };
         Snapshot: {
             typeUrl: string;
-            encode(message: _475.Snapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _475.Snapshot;
-            fromPartial(object: import("../helpers").DeepPartial<_475.Snapshot>): _475.Snapshot;
-            fromAmino(object: _475.SnapshotAmino): _475.Snapshot;
-            toAmino(message: _475.Snapshot): _475.SnapshotAmino;
-            fromAminoMsg(object: _475.SnapshotAminoMsg): _475.Snapshot;
-            fromProtoMsg(message: _475.SnapshotProtoMsg): _475.Snapshot;
-            toProto(message: _475.Snapshot): Uint8Array;
-            toProtoMsg(message: _475.Snapshot): _475.SnapshotProtoMsg;
+            encode(message: _536.Snapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _536.Snapshot;
+            fromPartial(object: import("../helpers").DeepPartial<_536.Snapshot>): _536.Snapshot;
+            fromAmino(object: _536.SnapshotAmino): _536.Snapshot;
+            toAmino(message: _536.Snapshot): _536.SnapshotAmino;
+            fromAminoMsg(object: _536.SnapshotAminoMsg): _536.Snapshot;
+            fromProtoMsg(message: _536.SnapshotProtoMsg): _536.Snapshot;
+            toProto(message: _536.Snapshot): Uint8Array;
+            toProtoMsg(message: _536.Snapshot): _536.SnapshotProtoMsg;
         };
     };
     const crypto: {
         Proof: {
             typeUrl: string;
-            encode(message: _477.Proof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _477.Proof;
-            fromPartial(object: import("../helpers").DeepPartial<_477.Proof>): _477.Proof;
-            fromAmino(object: _477.ProofAmino): _477.Proof;
-            toAmino(message: _477.Proof): _477.ProofAmino;
-            fromAminoMsg(object: _477.ProofAminoMsg): _477.Proof;
-            fromProtoMsg(message: _477.ProofProtoMsg): _477.Proof;
-            toProto(message: _477.Proof): Uint8Array;
-            toProtoMsg(message: _477.Proof): _477.ProofProtoMsg;
+            encode(message: _538.Proof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.Proof;
+            fromPartial(object: import("../helpers").DeepPartial<_538.Proof>): _538.Proof;
+            fromAmino(object: _538.ProofAmino): _538.Proof;
+            toAmino(message: _538.Proof): _538.ProofAmino;
+            fromAminoMsg(object: _538.ProofAminoMsg): _538.Proof;
+            fromProtoMsg(message: _538.ProofProtoMsg): _538.Proof;
+            toProto(message: _538.Proof): Uint8Array;
+            toProtoMsg(message: _538.Proof): _538.ProofProtoMsg;
         };
         ValueOp: {
             typeUrl: string;
-            encode(message: _477.ValueOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _477.ValueOp;
-            fromPartial(object: import("../helpers").DeepPartial<_477.ValueOp>): _477.ValueOp;
-            fromAmino(object: _477.ValueOpAmino): _477.ValueOp;
-            toAmino(message: _477.ValueOp): _477.ValueOpAmino;
-            fromAminoMsg(object: _477.ValueOpAminoMsg): _477.ValueOp;
-            fromProtoMsg(message: _477.ValueOpProtoMsg): _477.ValueOp;
-            toProto(message: _477.ValueOp): Uint8Array;
-            toProtoMsg(message: _477.ValueOp): _477.ValueOpProtoMsg;
+            encode(message: _538.ValueOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ValueOp;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ValueOp>): _538.ValueOp;
+            fromAmino(object: _538.ValueOpAmino): _538.ValueOp;
+            toAmino(message: _538.ValueOp): _538.ValueOpAmino;
+            fromAminoMsg(object: _538.ValueOpAminoMsg): _538.ValueOp;
+            fromProtoMsg(message: _538.ValueOpProtoMsg): _538.ValueOp;
+            toProto(message: _538.ValueOp): Uint8Array;
+            toProtoMsg(message: _538.ValueOp): _538.ValueOpProtoMsg;
         };
         DominoOp: {
             typeUrl: string;
-            encode(message: _477.DominoOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _477.DominoOp;
-            fromPartial(object: import("../helpers").DeepPartial<_477.DominoOp>): _477.DominoOp;
-            fromAmino(object: _477.DominoOpAmino): _477.DominoOp;
-            toAmino(message: _477.DominoOp): _477.DominoOpAmino;
-            fromAminoMsg(object: _477.DominoOpAminoMsg): _477.DominoOp;
-            fromProtoMsg(message: _477.DominoOpProtoMsg): _477.DominoOp;
-            toProto(message: _477.DominoOp): Uint8Array;
-            toProtoMsg(message: _477.DominoOp): _477.DominoOpProtoMsg;
+            encode(message: _538.DominoOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.DominoOp;
+            fromPartial(object: import("../helpers").DeepPartial<_538.DominoOp>): _538.DominoOp;
+            fromAmino(object: _538.DominoOpAmino): _538.DominoOp;
+            toAmino(message: _538.DominoOp): _538.DominoOpAmino;
+            fromAminoMsg(object: _538.DominoOpAminoMsg): _538.DominoOp;
+            fromProtoMsg(message: _538.DominoOpProtoMsg): _538.DominoOp;
+            toProto(message: _538.DominoOp): Uint8Array;
+            toProtoMsg(message: _538.DominoOp): _538.DominoOpProtoMsg;
         };
         ProofOp: {
             typeUrl: string;
-            encode(message: _477.ProofOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _477.ProofOp;
-            fromPartial(object: import("../helpers").DeepPartial<_477.ProofOp>): _477.ProofOp;
-            fromAmino(object: _477.ProofOpAmino): _477.ProofOp;
-            toAmino(message: _477.ProofOp): _477.ProofOpAmino;
-            fromAminoMsg(object: _477.ProofOpAminoMsg): _477.ProofOp;
-            fromProtoMsg(message: _477.ProofOpProtoMsg): _477.ProofOp;
-            toProto(message: _477.ProofOp): Uint8Array;
-            toProtoMsg(message: _477.ProofOp): _477.ProofOpProtoMsg;
+            encode(message: _538.ProofOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ProofOp;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ProofOp>): _538.ProofOp;
+            fromAmino(object: _538.ProofOpAmino): _538.ProofOp;
+            toAmino(message: _538.ProofOp): _538.ProofOpAmino;
+            fromAminoMsg(object: _538.ProofOpAminoMsg): _538.ProofOp;
+            fromProtoMsg(message: _538.ProofOpProtoMsg): _538.ProofOp;
+            toProto(message: _538.ProofOp): Uint8Array;
+            toProtoMsg(message: _538.ProofOp): _538.ProofOpProtoMsg;
         };
         ProofOps: {
             typeUrl: string;
-            encode(message: _477.ProofOps, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _477.ProofOps;
-            fromPartial(object: import("../helpers").DeepPartial<_477.ProofOps>): _477.ProofOps;
-            fromAmino(object: _477.ProofOpsAmino): _477.ProofOps;
-            toAmino(message: _477.ProofOps): _477.ProofOpsAmino;
-            fromAminoMsg(object: _477.ProofOpsAminoMsg): _477.ProofOps;
-            fromProtoMsg(message: _477.ProofOpsProtoMsg): _477.ProofOps;
-            toProto(message: _477.ProofOps): Uint8Array;
-            toProtoMsg(message: _477.ProofOps): _477.ProofOpsProtoMsg;
+            encode(message: _538.ProofOps, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _538.ProofOps;
+            fromPartial(object: import("../helpers").DeepPartial<_538.ProofOps>): _538.ProofOps;
+            fromAmino(object: _538.ProofOpsAmino): _538.ProofOps;
+            toAmino(message: _538.ProofOps): _538.ProofOpsAmino;
+            fromAminoMsg(object: _538.ProofOpsAminoMsg): _538.ProofOps;
+            fromProtoMsg(message: _538.ProofOpsProtoMsg): _538.ProofOps;
+            toProto(message: _538.ProofOps): Uint8Array;
+            toProtoMsg(message: _538.ProofOps): _538.ProofOpsProtoMsg;
         };
         PublicKey: {
             typeUrl: string;
-            encode(message: _476.PublicKey, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _476.PublicKey;
-            fromPartial(object: import("../helpers").DeepPartial<_476.PublicKey>): _476.PublicKey;
-            fromAmino(object: _476.PublicKeyAmino): _476.PublicKey;
-            toAmino(message: _476.PublicKey): _476.PublicKeyAmino;
-            fromAminoMsg(object: _476.PublicKeyAminoMsg): _476.PublicKey;
-            fromProtoMsg(message: _476.PublicKeyProtoMsg): _476.PublicKey;
-            toProto(message: _476.PublicKey): Uint8Array;
-            toProtoMsg(message: _476.PublicKey): _476.PublicKeyProtoMsg;
+            encode(message: _537.PublicKey, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _537.PublicKey;
+            fromPartial(object: import("../helpers").DeepPartial<_537.PublicKey>): _537.PublicKey;
+            fromAmino(object: _537.PublicKeyAmino): _537.PublicKey;
+            toAmino(message: _537.PublicKey): _537.PublicKeyAmino;
+            fromAminoMsg(object: _537.PublicKeyAminoMsg): _537.PublicKey;
+            fromProtoMsg(message: _537.PublicKeyProtoMsg): _537.PublicKey;
+            toProto(message: _537.PublicKey): Uint8Array;
+            toProtoMsg(message: _537.PublicKey): _537.PublicKeyProtoMsg;
         };
     };
     const p2p: {
         NetAddress: {
             typeUrl: string;
-            encode(message: _478.NetAddress, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _478.NetAddress;
-            fromPartial(object: import("../helpers").DeepPartial<_478.NetAddress>): _478.NetAddress;
-            fromAmino(object: _478.NetAddressAmino): _478.NetAddress;
-            toAmino(message: _478.NetAddress): _478.NetAddressAmino;
-            fromAminoMsg(object: _478.NetAddressAminoMsg): _478.NetAddress;
-            fromProtoMsg(message: _478.NetAddressProtoMsg): _478.NetAddress;
-            toProto(message: _478.NetAddress): Uint8Array;
-            toProtoMsg(message: _478.NetAddress): _478.NetAddressProtoMsg;
+            encode(message: _539.NetAddress, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.NetAddress;
+            fromPartial(object: import("../helpers").DeepPartial<_539.NetAddress>): _539.NetAddress;
+            fromAmino(object: _539.NetAddressAmino): _539.NetAddress;
+            toAmino(message: _539.NetAddress): _539.NetAddressAmino;
+            fromAminoMsg(object: _539.NetAddressAminoMsg): _539.NetAddress;
+            fromProtoMsg(message: _539.NetAddressProtoMsg): _539.NetAddress;
+            toProto(message: _539.NetAddress): Uint8Array;
+            toProtoMsg(message: _539.NetAddress): _539.NetAddressProtoMsg;
         };
         ProtocolVersion: {
             typeUrl: string;
-            encode(message: _478.ProtocolVersion, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _478.ProtocolVersion;
-            fromPartial(object: import("../helpers").DeepPartial<_478.ProtocolVersion>): _478.ProtocolVersion;
-            fromAmino(object: _478.ProtocolVersionAmino): _478.ProtocolVersion;
-            toAmino(message: _478.ProtocolVersion): _478.ProtocolVersionAmino;
-            fromAminoMsg(object: _478.ProtocolVersionAminoMsg): _478.ProtocolVersion;
-            fromProtoMsg(message: _478.ProtocolVersionProtoMsg): _478.ProtocolVersion;
-            toProto(message: _478.ProtocolVersion): Uint8Array;
-            toProtoMsg(message: _478.ProtocolVersion): _478.ProtocolVersionProtoMsg;
+            encode(message: _539.ProtocolVersion, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.ProtocolVersion;
+            fromPartial(object: import("../helpers").DeepPartial<_539.ProtocolVersion>): _539.ProtocolVersion;
+            fromAmino(object: _539.ProtocolVersionAmino): _539.ProtocolVersion;
+            toAmino(message: _539.ProtocolVersion): _539.ProtocolVersionAmino;
+            fromAminoMsg(object: _539.ProtocolVersionAminoMsg): _539.ProtocolVersion;
+            fromProtoMsg(message: _539.ProtocolVersionProtoMsg): _539.ProtocolVersion;
+            toProto(message: _539.ProtocolVersion): Uint8Array;
+            toProtoMsg(message: _539.ProtocolVersion): _539.ProtocolVersionProtoMsg;
         };
         DefaultNodeInfo: {
             typeUrl: string;
-            encode(message: _478.DefaultNodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _478.DefaultNodeInfo;
-            fromPartial(object: import("../helpers").DeepPartial<_478.DefaultNodeInfo>): _478.DefaultNodeInfo;
-            fromAmino(object: _478.DefaultNodeInfoAmino): _478.DefaultNodeInfo;
-            toAmino(message: _478.DefaultNodeInfo): _478.DefaultNodeInfoAmino;
-            fromAminoMsg(object: _478.DefaultNodeInfoAminoMsg): _478.DefaultNodeInfo;
-            fromProtoMsg(message: _478.DefaultNodeInfoProtoMsg): _478.DefaultNodeInfo;
-            toProto(message: _478.DefaultNodeInfo): Uint8Array;
-            toProtoMsg(message: _478.DefaultNodeInfo): _478.DefaultNodeInfoProtoMsg;
+            encode(message: _539.DefaultNodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.DefaultNodeInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_539.DefaultNodeInfo>): _539.DefaultNodeInfo;
+            fromAmino(object: _539.DefaultNodeInfoAmino): _539.DefaultNodeInfo;
+            toAmino(message: _539.DefaultNodeInfo): _539.DefaultNodeInfoAmino;
+            fromAminoMsg(object: _539.DefaultNodeInfoAminoMsg): _539.DefaultNodeInfo;
+            fromProtoMsg(message: _539.DefaultNodeInfoProtoMsg): _539.DefaultNodeInfo;
+            toProto(message: _539.DefaultNodeInfo): Uint8Array;
+            toProtoMsg(message: _539.DefaultNodeInfo): _539.DefaultNodeInfoProtoMsg;
         };
         DefaultNodeInfoOther: {
             typeUrl: string;
-            encode(message: _478.DefaultNodeInfoOther, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _478.DefaultNodeInfoOther;
-            fromPartial(object: import("../helpers").DeepPartial<_478.DefaultNodeInfoOther>): _478.DefaultNodeInfoOther;
-            fromAmino(object: _478.DefaultNodeInfoOtherAmino): _478.DefaultNodeInfoOther;
-            toAmino(message: _478.DefaultNodeInfoOther): _478.DefaultNodeInfoOtherAmino;
-            fromAminoMsg(object: _478.DefaultNodeInfoOtherAminoMsg): _478.DefaultNodeInfoOther;
-            fromProtoMsg(message: _478.DefaultNodeInfoOtherProtoMsg): _478.DefaultNodeInfoOther;
-            toProto(message: _478.DefaultNodeInfoOther): Uint8Array;
-            toProtoMsg(message: _478.DefaultNodeInfoOther): _478.DefaultNodeInfoOtherProtoMsg;
+            encode(message: _539.DefaultNodeInfoOther, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _539.DefaultNodeInfoOther;
+            fromPartial(object: import("../helpers").DeepPartial<_539.DefaultNodeInfoOther>): _539.DefaultNodeInfoOther;
+            fromAmino(object: _539.DefaultNodeInfoOtherAmino): _539.DefaultNodeInfoOther;
+            toAmino(message: _539.DefaultNodeInfoOther): _539.DefaultNodeInfoOtherAmino;
+            fromAminoMsg(object: _539.DefaultNodeInfoOtherAminoMsg): _539.DefaultNodeInfoOther;
+            fromProtoMsg(message: _539.DefaultNodeInfoOtherProtoMsg): _539.DefaultNodeInfoOther;
+            toProto(message: _539.DefaultNodeInfoOther): Uint8Array;
+            toProtoMsg(message: _539.DefaultNodeInfoOther): _539.DefaultNodeInfoOtherProtoMsg;
         };
     };
     const types: {
-        blockIDFlagFromJSON(object: any): _483.BlockIDFlag;
-        blockIDFlagToJSON(object: _483.BlockIDFlag): string;
-        BlockIDFlag: typeof _483.BlockIDFlag;
-        BlockIDFlagAmino: typeof _483.BlockIDFlag;
+        blockIDFlagFromJSON(object: any): _544.BlockIDFlag;
+        blockIDFlagToJSON(object: _544.BlockIDFlag): string;
+        BlockIDFlag: typeof _544.BlockIDFlag;
+        BlockIDFlagAmino: typeof _544.BlockIDFlag;
         ValidatorSet: {
             typeUrl: string;
-            encode(message: _483.ValidatorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _483.ValidatorSet;
-            fromPartial(object: import("../helpers").DeepPartial<_483.ValidatorSet>): _483.ValidatorSet;
-            fromAmino(object: _483.ValidatorSetAmino): _483.ValidatorSet;
-            toAmino(message: _483.ValidatorSet): _483.ValidatorSetAmino;
-            fromAminoMsg(object: _483.ValidatorSetAminoMsg): _483.ValidatorSet;
-            fromProtoMsg(message: _483.ValidatorSetProtoMsg): _483.ValidatorSet;
-            toProto(message: _483.ValidatorSet): Uint8Array;
-            toProtoMsg(message: _483.ValidatorSet): _483.ValidatorSetProtoMsg;
+            encode(message: _544.ValidatorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.ValidatorSet;
+            fromPartial(object: import("../helpers").DeepPartial<_544.ValidatorSet>): _544.ValidatorSet;
+            fromAmino(object: _544.ValidatorSetAmino): _544.ValidatorSet;
+            toAmino(message: _544.ValidatorSet): _544.ValidatorSetAmino;
+            fromAminoMsg(object: _544.ValidatorSetAminoMsg): _544.ValidatorSet;
+            fromProtoMsg(message: _544.ValidatorSetProtoMsg): _544.ValidatorSet;
+            toProto(message: _544.ValidatorSet): Uint8Array;
+            toProtoMsg(message: _544.ValidatorSet): _544.ValidatorSetProtoMsg;
         };
         Validator: {
             typeUrl: string;
-            encode(message: _483.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _483.Validator;
-            fromPartial(object: import("../helpers").DeepPartial<_483.Validator>): _483.Validator;
-            fromAmino(object: _483.ValidatorAmino): _483.Validator;
-            toAmino(message: _483.Validator): _483.ValidatorAmino;
-            fromAminoMsg(object: _483.ValidatorAminoMsg): _483.Validator;
-            fromProtoMsg(message: _483.ValidatorProtoMsg): _483.Validator;
-            toProto(message: _483.Validator): Uint8Array;
-            toProtoMsg(message: _483.Validator): _483.ValidatorProtoMsg;
+            encode(message: _544.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.Validator;
+            fromPartial(object: import("../helpers").DeepPartial<_544.Validator>): _544.Validator;
+            fromAmino(object: _544.ValidatorAmino): _544.Validator;
+            toAmino(message: _544.Validator): _544.ValidatorAmino;
+            fromAminoMsg(object: _544.ValidatorAminoMsg): _544.Validator;
+            fromProtoMsg(message: _544.ValidatorProtoMsg): _544.Validator;
+            toProto(message: _544.Validator): Uint8Array;
+            toProtoMsg(message: _544.Validator): _544.ValidatorProtoMsg;
         };
         SimpleValidator: {
             typeUrl: string;
-            encode(message: _483.SimpleValidator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _483.SimpleValidator;
-            fromPartial(object: import("../helpers").DeepPartial<_483.SimpleValidator>): _483.SimpleValidator;
-            fromAmino(object: _483.SimpleValidatorAmino): _483.SimpleValidator;
-            toAmino(message: _483.SimpleValidator): _483.SimpleValidatorAmino;
-            fromAminoMsg(object: _483.SimpleValidatorAminoMsg): _483.SimpleValidator;
-            fromProtoMsg(message: _483.SimpleValidatorProtoMsg): _483.SimpleValidator;
-            toProto(message: _483.SimpleValidator): Uint8Array;
-            toProtoMsg(message: _483.SimpleValidator): _483.SimpleValidatorProtoMsg;
-        };
-        signedMsgTypeFromJSON(object: any): _482.SignedMsgType;
-        signedMsgTypeToJSON(object: _482.SignedMsgType): string;
-        SignedMsgType: typeof _482.SignedMsgType;
-        SignedMsgTypeAmino: typeof _482.SignedMsgType;
+            encode(message: _544.SimpleValidator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _544.SimpleValidator;
+            fromPartial(object: import("../helpers").DeepPartial<_544.SimpleValidator>): _544.SimpleValidator;
+            fromAmino(object: _544.SimpleValidatorAmino): _544.SimpleValidator;
+            toAmino(message: _544.SimpleValidator): _544.SimpleValidatorAmino;
+            fromAminoMsg(object: _544.SimpleValidatorAminoMsg): _544.SimpleValidator;
+            fromProtoMsg(message: _544.SimpleValidatorProtoMsg): _544.SimpleValidator;
+            toProto(message: _544.SimpleValidator): Uint8Array;
+            toProtoMsg(message: _544.SimpleValidator): _544.SimpleValidatorProtoMsg;
+        };
+        signedMsgTypeFromJSON(object: any): _543.SignedMsgType;
+        signedMsgTypeToJSON(object: _543.SignedMsgType): string;
+        SignedMsgType: typeof _543.SignedMsgType;
+        SignedMsgTypeAmino: typeof _543.SignedMsgType;
         PartSetHeader: {
             typeUrl: string;
-            encode(message: _482.PartSetHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.PartSetHeader;
-            fromPartial(object: import("../helpers").DeepPartial<_482.PartSetHeader>): _482.PartSetHeader;
-            fromAmino(object: _482.PartSetHeaderAmino): _482.PartSetHeader;
-            toAmino(message: _482.PartSetHeader): _482.PartSetHeaderAmino;
-            fromAminoMsg(object: _482.PartSetHeaderAminoMsg): _482.PartSetHeader;
-            fromProtoMsg(message: _482.PartSetHeaderProtoMsg): _482.PartSetHeader;
-            toProto(message: _482.PartSetHeader): Uint8Array;
-            toProtoMsg(message: _482.PartSetHeader): _482.PartSetHeaderProtoMsg;
+            encode(message: _543.PartSetHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.PartSetHeader;
+            fromPartial(object: import("../helpers").DeepPartial<_543.PartSetHeader>): _543.PartSetHeader;
+            fromAmino(object: _543.PartSetHeaderAmino): _543.PartSetHeader;
+            toAmino(message: _543.PartSetHeader): _543.PartSetHeaderAmino;
+            fromAminoMsg(object: _543.PartSetHeaderAminoMsg): _543.PartSetHeader;
+            fromProtoMsg(message: _543.PartSetHeaderProtoMsg): _543.PartSetHeader;
+            toProto(message: _543.PartSetHeader): Uint8Array;
+            toProtoMsg(message: _543.PartSetHeader): _543.PartSetHeaderProtoMsg;
         };
         Part: {
             typeUrl: string;
-            encode(message: _482.Part, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.Part;
-            fromPartial(object: import("../helpers").DeepPartial<_482.Part>): _482.Part;
-            fromAmino(object: _482.PartAmino): _482.Part;
-            toAmino(message: _482.Part): _482.PartAmino;
-            fromAminoMsg(object: _482.PartAminoMsg): _482.Part;
-            fromProtoMsg(message: _482.PartProtoMsg): _482.Part;
-            toProto(message: _482.Part): Uint8Array;
-            toProtoMsg(message: _482.Part): _482.PartProtoMsg;
+            encode(message: _543.Part, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Part;
+            fromPartial(object: import("../helpers").DeepPartial<_543.Part>): _543.Part;
+            fromAmino(object: _543.PartAmino): _543.Part;
+            toAmino(message: _543.Part): _543.PartAmino;
+            fromAminoMsg(object: _543.PartAminoMsg): _543.Part;
+            fromProtoMsg(message: _543.PartProtoMsg): _543.Part;
+            toProto(message: _543.Part): Uint8Array;
+            toProtoMsg(message: _543.Part): _543.PartProtoMsg;
         };
         BlockID: {
             typeUrl: string;
-            encode(message: _482.BlockID, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.BlockID;
-            fromPartial(object: import("../helpers").DeepPartial<_482.BlockID>): _482.BlockID;
-            fromAmino(object: _482.BlockIDAmino): _482.BlockID;
-            toAmino(message: _482.BlockID): _482.BlockIDAmino;
-            fromAminoMsg(object: _482.BlockIDAminoMsg): _482.BlockID;
-            fromProtoMsg(message: _482.BlockIDProtoMsg): _482.BlockID;
-            toProto(message: _482.BlockID): Uint8Array;
-            toProtoMsg(message: _482.BlockID): _482.BlockIDProtoMsg;
+            encode(message: _543.BlockID, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.BlockID;
+            fromPartial(object: import("../helpers").DeepPartial<_543.BlockID>): _543.BlockID;
+            fromAmino(object: _543.BlockIDAmino): _543.BlockID;
+            toAmino(message: _543.BlockID): _543.BlockIDAmino;
+            fromAminoMsg(object: _543.BlockIDAminoMsg): _543.BlockID;
+            fromProtoMsg(message: _543.BlockIDProtoMsg): _543.BlockID;
+            toProto(message: _543.BlockID): Uint8Array;
+            toProtoMsg(message: _543.BlockID): _543.BlockIDProtoMsg;
         };
         Header: {
             typeUrl: string;
-            encode(message: _482.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.Header;
-            fromPartial(object: import("../helpers").DeepPartial<_482.Header>): _482.Header;
-            fromAmino(object: _482.HeaderAmino): _482.Header;
-            toAmino(message: _482.Header): _482.HeaderAmino;
-            fromAminoMsg(object: _482.HeaderAminoMsg): _482.Header;
-            fromProtoMsg(message: _482.HeaderProtoMsg): _482.Header;
-            toProto(message: _482.Header): Uint8Array;
-            toProtoMsg(message: _482.Header): _482.HeaderProtoMsg;
+            encode(message: _543.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Header;
+            fromPartial(object: import("../helpers").DeepPartial<_543.Header>): _543.Header;
+            fromAmino(object: _543.HeaderAmino): _543.Header;
+            toAmino(message: _543.Header): _543.HeaderAmino;
+            fromAminoMsg(object: _543.HeaderAminoMsg): _543.Header;
+            fromProtoMsg(message: _543.HeaderProtoMsg): _543.Header;
+            toProto(message: _543.Header): Uint8Array;
+            toProtoMsg(message: _543.Header): _543.HeaderProtoMsg;
         };
         Data: {
             typeUrl: string;
-            encode(message: _482.Data, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.Data;
-            fromPartial(object: import("../helpers").DeepPartial<_482.Data>): _482.Data;
-            fromAmino(object: _482.DataAmino): _482.Data;
-            toAmino(message: _482.Data): _482.DataAmino;
-            fromAminoMsg(object: _482.DataAminoMsg): _482.Data;
-            fromProtoMsg(message: _482.DataProtoMsg): _482.Data;
-            toProto(message: _482.Data): Uint8Array;
-            toProtoMsg(message: _482.Data): _482.DataProtoMsg;
+            encode(message: _543.Data, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Data;
+            fromPartial(object: import("../helpers").DeepPartial<_543.Data>): _543.Data;
+            fromAmino(object: _543.DataAmino): _543.Data;
+            toAmino(message: _543.Data): _543.DataAmino;
+            fromAminoMsg(object: _543.DataAminoMsg): _543.Data;
+            fromProtoMsg(message: _543.DataProtoMsg): _543.Data;
+            toProto(message: _543.Data): Uint8Array;
+            toProtoMsg(message: _543.Data): _543.DataProtoMsg;
         };
         Vote: {
             typeUrl: string;
-            encode(message: _482.Vote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.Vote;
-            fromPartial(object: import("../helpers").DeepPartial<_482.Vote>): _482.Vote;
-            fromAmino(object: _482.VoteAmino): _482.Vote;
-            toAmino(message: _482.Vote): _482.VoteAmino;
-            fromAminoMsg(object: _482.VoteAminoMsg): _482.Vote;
-            fromProtoMsg(message: _482.VoteProtoMsg): _482.Vote;
-            toProto(message: _482.Vote): Uint8Array;
-            toProtoMsg(message: _482.Vote): _482.VoteProtoMsg;
+            encode(message: _543.Vote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Vote;
+            fromPartial(object: import("../helpers").DeepPartial<_543.Vote>): _543.Vote;
+            fromAmino(object: _543.VoteAmino): _543.Vote;
+            toAmino(message: _543.Vote): _543.VoteAmino;
+            fromAminoMsg(object: _543.VoteAminoMsg): _543.Vote;
+            fromProtoMsg(message: _543.VoteProtoMsg): _543.Vote;
+            toProto(message: _543.Vote): Uint8Array;
+            toProtoMsg(message: _543.Vote): _543.VoteProtoMsg;
         };
         Commit: {
             typeUrl: string;
-            encode(message: _482.Commit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.Commit;
-            fromPartial(object: import("../helpers").DeepPartial<_482.Commit>): _482.Commit;
-            fromAmino(object: _482.CommitAmino): _482.Commit;
-            toAmino(message: _482.Commit): _482.CommitAmino;
-            fromAminoMsg(object: _482.CommitAminoMsg): _482.Commit;
-            fromProtoMsg(message: _482.CommitProtoMsg): _482.Commit;
-            toProto(message: _482.Commit): Uint8Array;
-            toProtoMsg(message: _482.Commit): _482.CommitProtoMsg;
+            encode(message: _543.Commit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Commit;
+            fromPartial(object: import("../helpers").DeepPartial<_543.Commit>): _543.Commit;
+            fromAmino(object: _543.CommitAmino): _543.Commit;
+            toAmino(message: _543.Commit): _543.CommitAmino;
+            fromAminoMsg(object: _543.CommitAminoMsg): _543.Commit;
+            fromProtoMsg(message: _543.CommitProtoMsg): _543.Commit;
+            toProto(message: _543.Commit): Uint8Array;
+            toProtoMsg(message: _543.Commit): _543.CommitProtoMsg;
         };
         CommitSig: {
             typeUrl: string;
-            encode(message: _482.CommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.CommitSig;
-            fromPartial(object: import("../helpers").DeepPartial<_482.CommitSig>): _482.CommitSig;
-            fromAmino(object: _482.CommitSigAmino): _482.CommitSig;
-            toAmino(message: _482.CommitSig): _482.CommitSigAmino;
-            fromAminoMsg(object: _482.CommitSigAminoMsg): _482.CommitSig;
-            fromProtoMsg(message: _482.CommitSigProtoMsg): _482.CommitSig;
-            toProto(message: _482.CommitSig): Uint8Array;
-            toProtoMsg(message: _482.CommitSig): _482.CommitSigProtoMsg;
+            encode(message: _543.CommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.CommitSig;
+            fromPartial(object: import("../helpers").DeepPartial<_543.CommitSig>): _543.CommitSig;
+            fromAmino(object: _543.CommitSigAmino): _543.CommitSig;
+            toAmino(message: _543.CommitSig): _543.CommitSigAmino;
+            fromAminoMsg(object: _543.CommitSigAminoMsg): _543.CommitSig;
+            fromProtoMsg(message: _543.CommitSigProtoMsg): _543.CommitSig;
+            toProto(message: _543.CommitSig): Uint8Array;
+            toProtoMsg(message: _543.CommitSig): _543.CommitSigProtoMsg;
         };
         ExtendedCommit: {
             typeUrl: string;
-            encode(message: _482.ExtendedCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.ExtendedCommit;
-            fromPartial(object: import("../helpers").DeepPartial<_482.ExtendedCommit>): _482.ExtendedCommit;
-            fromAmino(object: _482.ExtendedCommitAmino): _482.ExtendedCommit;
-            toAmino(message: _482.ExtendedCommit): _482.ExtendedCommitAmino;
-            fromAminoMsg(object: _482.ExtendedCommitAminoMsg): _482.ExtendedCommit;
-            fromProtoMsg(message: _482.ExtendedCommitProtoMsg): _482.ExtendedCommit;
-            toProto(message: _482.ExtendedCommit): Uint8Array;
-            toProtoMsg(message: _482.ExtendedCommit): _482.ExtendedCommitProtoMsg;
+            encode(message: _543.ExtendedCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.ExtendedCommit;
+            fromPartial(object: import("../helpers").DeepPartial<_543.ExtendedCommit>): _543.ExtendedCommit;
+            fromAmino(object: _543.ExtendedCommitAmino): _543.ExtendedCommit;
+            toAmino(message: _543.ExtendedCommit): _543.ExtendedCommitAmino;
+            fromAminoMsg(object: _543.ExtendedCommitAminoMsg): _543.ExtendedCommit;
+            fromProtoMsg(message: _543.ExtendedCommitProtoMsg): _543.ExtendedCommit;
+            toProto(message: _543.ExtendedCommit): Uint8Array;
+            toProtoMsg(message: _543.ExtendedCommit): _543.ExtendedCommitProtoMsg;
         };
         ExtendedCommitSig: {
             typeUrl: string;
-            encode(message: _482.ExtendedCommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.ExtendedCommitSig;
-            fromPartial(object: import("../helpers").DeepPartial<_482.ExtendedCommitSig>): _482.ExtendedCommitSig;
-            fromAmino(object: _482.ExtendedCommitSigAmino): _482.ExtendedCommitSig;
-            toAmino(message: _482.ExtendedCommitSig): _482.ExtendedCommitSigAmino;
-            fromAminoMsg(object: _482.ExtendedCommitSigAminoMsg): _482.ExtendedCommitSig;
-            fromProtoMsg(message: _482.ExtendedCommitSigProtoMsg): _482.ExtendedCommitSig;
-            toProto(message: _482.ExtendedCommitSig): Uint8Array;
-            toProtoMsg(message: _482.ExtendedCommitSig): _482.ExtendedCommitSigProtoMsg;
+            encode(message: _543.ExtendedCommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.ExtendedCommitSig;
+            fromPartial(object: import("../helpers").DeepPartial<_543.ExtendedCommitSig>): _543.ExtendedCommitSig;
+            fromAmino(object: _543.ExtendedCommitSigAmino): _543.ExtendedCommitSig;
+            toAmino(message: _543.ExtendedCommitSig): _543.ExtendedCommitSigAmino;
+            fromAminoMsg(object: _543.ExtendedCommitSigAminoMsg): _543.ExtendedCommitSig;
+            fromProtoMsg(message: _543.ExtendedCommitSigProtoMsg): _543.ExtendedCommitSig;
+            toProto(message: _543.ExtendedCommitSig): Uint8Array;
+            toProtoMsg(message: _543.ExtendedCommitSig): _543.ExtendedCommitSigProtoMsg;
         };
         Proposal: {
             typeUrl: string;
-            encode(message: _482.Proposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.Proposal;
-            fromPartial(object: import("../helpers").DeepPartial<_482.Proposal>): _482.Proposal;
-            fromAmino(object: _482.ProposalAmino): _482.Proposal;
-            toAmino(message: _482.Proposal): _482.ProposalAmino;
-            fromAminoMsg(object: _482.ProposalAminoMsg): _482.Proposal;
-            fromProtoMsg(message: _482.ProposalProtoMsg): _482.Proposal;
-            toProto(message: _482.Proposal): Uint8Array;
-            toProtoMsg(message: _482.Proposal): _482.ProposalProtoMsg;
+            encode(message: _543.Proposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.Proposal;
+            fromPartial(object: import("../helpers").DeepPartial<_543.Proposal>): _543.Proposal;
+            fromAmino(object: _543.ProposalAmino): _543.Proposal;
+            toAmino(message: _543.Proposal): _543.ProposalAmino;
+            fromAminoMsg(object: _543.ProposalAminoMsg): _543.Proposal;
+            fromProtoMsg(message: _543.ProposalProtoMsg): _543.Proposal;
+            toProto(message: _543.Proposal): Uint8Array;
+            toProtoMsg(message: _543.Proposal): _543.ProposalProtoMsg;
         };
         SignedHeader: {
             typeUrl: string;
-            encode(message: _482.SignedHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.SignedHeader;
-            fromPartial(object: import("../helpers").DeepPartial<_482.SignedHeader>): _482.SignedHeader;
-            fromAmino(object: _482.SignedHeaderAmino): _482.SignedHeader;
-            toAmino(message: _482.SignedHeader): _482.SignedHeaderAmino;
-            fromAminoMsg(object: _482.SignedHeaderAminoMsg): _482.SignedHeader;
-            fromProtoMsg(message: _482.SignedHeaderProtoMsg): _482.SignedHeader;
-            toProto(message: _482.SignedHeader): Uint8Array;
-            toProtoMsg(message: _482.SignedHeader): _482.SignedHeaderProtoMsg;
+            encode(message: _543.SignedHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.SignedHeader;
+            fromPartial(object: import("../helpers").DeepPartial<_543.SignedHeader>): _543.SignedHeader;
+            fromAmino(object: _543.SignedHeaderAmino): _543.SignedHeader;
+            toAmino(message: _543.SignedHeader): _543.SignedHeaderAmino;
+            fromAminoMsg(object: _543.SignedHeaderAminoMsg): _543.SignedHeader;
+            fromProtoMsg(message: _543.SignedHeaderProtoMsg): _543.SignedHeader;
+            toProto(message: _543.SignedHeader): Uint8Array;
+            toProtoMsg(message: _543.SignedHeader): _543.SignedHeaderProtoMsg;
         };
         LightBlock: {
             typeUrl: string;
-            encode(message: _482.LightBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.LightBlock;
-            fromPartial(object: import("../helpers").DeepPartial<_482.LightBlock>): _482.LightBlock;
-            fromAmino(object: _482.LightBlockAmino): _482.LightBlock;
-            toAmino(message: _482.LightBlock): _482.LightBlockAmino;
-            fromAminoMsg(object: _482.LightBlockAminoMsg): _482.LightBlock;
-            fromProtoMsg(message: _482.LightBlockProtoMsg): _482.LightBlock;
-            toProto(message: _482.LightBlock): Uint8Array;
-            toProtoMsg(message: _482.LightBlock): _482.LightBlockProtoMsg;
+            encode(message: _543.LightBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.LightBlock;
+            fromPartial(object: import("../helpers").DeepPartial<_543.LightBlock>): _543.LightBlock;
+            fromAmino(object: _543.LightBlockAmino): _543.LightBlock;
+            toAmino(message: _543.LightBlock): _543.LightBlockAmino;
+            fromAminoMsg(object: _543.LightBlockAminoMsg): _543.LightBlock;
+            fromProtoMsg(message: _543.LightBlockProtoMsg): _543.LightBlock;
+            toProto(message: _543.LightBlock): Uint8Array;
+            toProtoMsg(message: _543.LightBlock): _543.LightBlockProtoMsg;
         };
         BlockMeta: {
             typeUrl: string;
-            encode(message: _482.BlockMeta, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.BlockMeta;
-            fromPartial(object: import("../helpers").DeepPartial<_482.BlockMeta>): _482.BlockMeta;
-            fromAmino(object: _482.BlockMetaAmino): _482.BlockMeta;
-            toAmino(message: _482.BlockMeta): _482.BlockMetaAmino;
-            fromAminoMsg(object: _482.BlockMetaAminoMsg): _482.BlockMeta;
-            fromProtoMsg(message: _482.BlockMetaProtoMsg): _482.BlockMeta;
-            toProto(message: _482.BlockMeta): Uint8Array;
-            toProtoMsg(message: _482.BlockMeta): _482.BlockMetaProtoMsg;
+            encode(message: _543.BlockMeta, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.BlockMeta;
+            fromPartial(object: import("../helpers").DeepPartial<_543.BlockMeta>): _543.BlockMeta;
+            fromAmino(object: _543.BlockMetaAmino): _543.BlockMeta;
+            toAmino(message: _543.BlockMeta): _543.BlockMetaAmino;
+            fromAminoMsg(object: _543.BlockMetaAminoMsg): _543.BlockMeta;
+            fromProtoMsg(message: _543.BlockMetaProtoMsg): _543.BlockMeta;
+            toProto(message: _543.BlockMeta): Uint8Array;
+            toProtoMsg(message: _543.BlockMeta): _543.BlockMetaProtoMsg;
         };
         TxProof: {
             typeUrl: string;
-            encode(message: _482.TxProof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _482.TxProof;
-            fromPartial(object: import("../helpers").DeepPartial<_482.TxProof>): _482.TxProof;
-            fromAmino(object: _482.TxProofAmino): _482.TxProof;
-            toAmino(message: _482.TxProof): _482.TxProofAmino;
-            fromAminoMsg(object: _482.TxProofAminoMsg): _482.TxProof;
-            fromProtoMsg(message: _482.TxProofProtoMsg): _482.TxProof;
-            toProto(message: _482.TxProof): Uint8Array;
-            toProtoMsg(message: _482.TxProof): _482.TxProofProtoMsg;
+            encode(message: _543.TxProof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _543.TxProof;
+            fromPartial(object: import("../helpers").DeepPartial<_543.TxProof>): _543.TxProof;
+            fromAmino(object: _543.TxProofAmino): _543.TxProof;
+            toAmino(message: _543.TxProof): _543.TxProofAmino;
+            fromAminoMsg(object: _543.TxProofAminoMsg): _543.TxProof;
+            fromProtoMsg(message: _543.TxProofProtoMsg): _543.TxProof;
+            toProto(message: _543.TxProof): Uint8Array;
+            toProtoMsg(message: _543.TxProof): _543.TxProofProtoMsg;
         };
         ConsensusParams: {
             typeUrl: string;
-            encode(message: _481.ConsensusParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _481.ConsensusParams;
-            fromPartial(object: import("../helpers").DeepPartial<_481.ConsensusParams>): _481.ConsensusParams;
-            fromAmino(object: _481.ConsensusParamsAmino): _481.ConsensusParams;
-            toAmino(message: _481.ConsensusParams): _481.ConsensusParamsAmino;
-            fromAminoMsg(object: _481.ConsensusParamsAminoMsg): _481.ConsensusParams;
-            fromProtoMsg(message: _481.ConsensusParamsProtoMsg): _481.ConsensusParams;
-            toProto(message: _481.ConsensusParams): Uint8Array;
-            toProtoMsg(message: _481.ConsensusParams): _481.ConsensusParamsProtoMsg;
+            encode(message: _542.ConsensusParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.ConsensusParams;
+            fromPartial(object: import("../helpers").DeepPartial<_542.ConsensusParams>): _542.ConsensusParams;
+            fromAmino(object: _542.ConsensusParamsAmino): _542.ConsensusParams;
+            toAmino(message: _542.ConsensusParams): _542.ConsensusParamsAmino;
+            fromAminoMsg(object: _542.ConsensusParamsAminoMsg): _542.ConsensusParams;
+            fromProtoMsg(message: _542.ConsensusParamsProtoMsg): _542.ConsensusParams;
+            toProto(message: _542.ConsensusParams): Uint8Array;
+            toProtoMsg(message: _542.ConsensusParams): _542.ConsensusParamsProtoMsg;
         };
         BlockParams: {
             typeUrl: string;
-            encode(message: _481.BlockParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _481.BlockParams;
-            fromPartial(object: import("../helpers").DeepPartial<_481.BlockParams>): _481.BlockParams;
-            fromAmino(object: _481.BlockParamsAmino): _481.BlockParams;
-            toAmino(message: _481.BlockParams): _481.BlockParamsAmino;
-            fromAminoMsg(object: _481.BlockParamsAminoMsg): _481.BlockParams;
-            fromProtoMsg(message: _481.BlockParamsProtoMsg): _481.BlockParams;
-            toProto(message: _481.BlockParams): Uint8Array;
-            toProtoMsg(message: _481.BlockParams): _481.BlockParamsProtoMsg;
+            encode(message: _542.BlockParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.BlockParams;
+            fromPartial(object: import("../helpers").DeepPartial<_542.BlockParams>): _542.BlockParams;
+            fromAmino(object: _542.BlockParamsAmino): _542.BlockParams;
+            toAmino(message: _542.BlockParams): _542.BlockParamsAmino;
+            fromAminoMsg(object: _542.BlockParamsAminoMsg): _542.BlockParams;
+            fromProtoMsg(message: _542.BlockParamsProtoMsg): _542.BlockParams;
+            toProto(message: _542.BlockParams): Uint8Array;
+            toProtoMsg(message: _542.BlockParams): _542.BlockParamsProtoMsg;
         };
         EvidenceParams: {
             typeUrl: string;
-            encode(message: _481.EvidenceParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _481.EvidenceParams;
-            fromPartial(object: import("../helpers").DeepPartial<_481.EvidenceParams>): _481.EvidenceParams;
-            fromAmino(object: _481.EvidenceParamsAmino): _481.EvidenceParams;
-            toAmino(message: _481.EvidenceParams): _481.EvidenceParamsAmino;
-            fromAminoMsg(object: _481.EvidenceParamsAminoMsg): _481.EvidenceParams;
-            fromProtoMsg(message: _481.EvidenceParamsProtoMsg): _481.EvidenceParams;
-            toProto(message: _481.EvidenceParams): Uint8Array;
-            toProtoMsg(message: _481.EvidenceParams): _481.EvidenceParamsProtoMsg;
+            encode(message: _542.EvidenceParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.EvidenceParams;
+            fromPartial(object: import("../helpers").DeepPartial<_542.EvidenceParams>): _542.EvidenceParams;
+            fromAmino(object: _542.EvidenceParamsAmino): _542.EvidenceParams;
+            toAmino(message: _542.EvidenceParams): _542.EvidenceParamsAmino;
+            fromAminoMsg(object: _542.EvidenceParamsAminoMsg): _542.EvidenceParams;
+            fromProtoMsg(message: _542.EvidenceParamsProtoMsg): _542.EvidenceParams;
+            toProto(message: _542.EvidenceParams): Uint8Array;
+            toProtoMsg(message: _542.EvidenceParams): _542.EvidenceParamsProtoMsg;
         };
         ValidatorParams: {
             typeUrl: string;
-            encode(message: _481.ValidatorParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _481.ValidatorParams;
-            fromPartial(object: import("../helpers").DeepPartial<_481.ValidatorParams>): _481.ValidatorParams;
-            fromAmino(object: _481.ValidatorParamsAmino): _481.ValidatorParams;
-            toAmino(message: _481.ValidatorParams): _481.ValidatorParamsAmino;
-            fromAminoMsg(object: _481.ValidatorParamsAminoMsg): _481.ValidatorParams;
-            fromProtoMsg(message: _481.ValidatorParamsProtoMsg): _481.ValidatorParams;
-            toProto(message: _481.ValidatorParams): Uint8Array;
-            toProtoMsg(message: _481.ValidatorParams): _481.ValidatorParamsProtoMsg;
+            encode(message: _542.ValidatorParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.ValidatorParams;
+            fromPartial(object: import("../helpers").DeepPartial<_542.ValidatorParams>): _542.ValidatorParams;
+            fromAmino(object: _542.ValidatorParamsAmino): _542.ValidatorParams;
+            toAmino(message: _542.ValidatorParams): _542.ValidatorParamsAmino;
+            fromAminoMsg(object: _542.ValidatorParamsAminoMsg): _542.ValidatorParams;
+            fromProtoMsg(message: _542.ValidatorParamsProtoMsg): _542.ValidatorParams;
+            toProto(message: _542.ValidatorParams): Uint8Array;
+            toProtoMsg(message: _542.ValidatorParams): _542.ValidatorParamsProtoMsg;
         };
         VersionParams: {
             typeUrl: string;
-            encode(message: _481.VersionParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _481.VersionParams;
-            fromPartial(object: import("../helpers").DeepPartial<_481.VersionParams>): _481.VersionParams;
-            fromAmino(object: _481.VersionParamsAmino): _481.VersionParams;
-            toAmino(message: _481.VersionParams): _481.VersionParamsAmino;
-            fromAminoMsg(object: _481.VersionParamsAminoMsg): _481.VersionParams;
-            fromProtoMsg(message: _481.VersionParamsProtoMsg): _481.VersionParams;
-            toProto(message: _481.VersionParams): Uint8Array;
-            toProtoMsg(message: _481.VersionParams): _481.VersionParamsProtoMsg;
+            encode(message: _542.VersionParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.VersionParams;
+            fromPartial(object: import("../helpers").DeepPartial<_542.VersionParams>): _542.VersionParams;
+            fromAmino(object: _542.VersionParamsAmino): _542.VersionParams;
+            toAmino(message: _542.VersionParams): _542.VersionParamsAmino;
+            fromAminoMsg(object: _542.VersionParamsAminoMsg): _542.VersionParams;
+            fromProtoMsg(message: _542.VersionParamsProtoMsg): _542.VersionParams;
+            toProto(message: _542.VersionParams): Uint8Array;
+            toProtoMsg(message: _542.VersionParams): _542.VersionParamsProtoMsg;
         };
         HashedParams: {
             typeUrl: string;
-            encode(message: _481.HashedParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _481.HashedParams;
-            fromPartial(object: import("../helpers").DeepPartial<_481.HashedParams>): _481.HashedParams;
-            fromAmino(object: _481.HashedParamsAmino): _481.HashedParams;
-            toAmino(message: _481.HashedParams): _481.HashedParamsAmino;
-            fromAminoMsg(object: _481.HashedParamsAminoMsg): _481.HashedParams;
-            fromProtoMsg(message: _481.HashedParamsProtoMsg): _481.HashedParams;
-            toProto(message: _481.HashedParams): Uint8Array;
-            toProtoMsg(message: _481.HashedParams): _481.HashedParamsProtoMsg;
+            encode(message: _542.HashedParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.HashedParams;
+            fromPartial(object: import("../helpers").DeepPartial<_542.HashedParams>): _542.HashedParams;
+            fromAmino(object: _542.HashedParamsAmino): _542.HashedParams;
+            toAmino(message: _542.HashedParams): _542.HashedParamsAmino;
+            fromAminoMsg(object: _542.HashedParamsAminoMsg): _542.HashedParams;
+            fromProtoMsg(message: _542.HashedParamsProtoMsg): _542.HashedParams;
+            toProto(message: _542.HashedParams): Uint8Array;
+            toProtoMsg(message: _542.HashedParams): _542.HashedParamsProtoMsg;
         };
         ABCIParams: {
             typeUrl: string;
-            encode(message: _481.ABCIParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _481.ABCIParams;
-            fromPartial(object: import("../helpers").DeepPartial<_481.ABCIParams>): _481.ABCIParams;
-            fromAmino(object: _481.ABCIParamsAmino): _481.ABCIParams;
-            toAmino(message: _481.ABCIParams): _481.ABCIParamsAmino;
-            fromAminoMsg(object: _481.ABCIParamsAminoMsg): _481.ABCIParams;
-            fromProtoMsg(message: _481.ABCIParamsProtoMsg): _481.ABCIParams;
-            toProto(message: _481.ABCIParams): Uint8Array;
-            toProtoMsg(message: _481.ABCIParams): _481.ABCIParamsProtoMsg;
+            encode(message: _542.ABCIParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _542.ABCIParams;
+            fromPartial(object: import("../helpers").DeepPartial<_542.ABCIParams>): _542.ABCIParams;
+            fromAmino(object: _542.ABCIParamsAmino): _542.ABCIParams;
+            toAmino(message: _542.ABCIParams): _542.ABCIParamsAmino;
+            fromAminoMsg(object: _542.ABCIParamsAminoMsg): _542.ABCIParams;
+            fromProtoMsg(message: _542.ABCIParamsProtoMsg): _542.ABCIParams;
+            toProto(message: _542.ABCIParams): Uint8Array;
+            toProtoMsg(message: _542.ABCIParams): _542.ABCIParamsProtoMsg;
         };
         Evidence: {
             typeUrl: string;
-            encode(message: _480.Evidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _480.Evidence;
-            fromPartial(object: import("../helpers").DeepPartial<_480.Evidence>): _480.Evidence;
-            fromAmino(object: _480.EvidenceAmino): _480.Evidence;
-            toAmino(message: _480.Evidence): _480.EvidenceAmino;
-            fromAminoMsg(object: _480.EvidenceAminoMsg): _480.Evidence;
-            fromProtoMsg(message: _480.EvidenceProtoMsg): _480.Evidence;
-            toProto(message: _480.Evidence): Uint8Array;
-            toProtoMsg(message: _480.Evidence): _480.EvidenceProtoMsg;
+            encode(message: _541.Evidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.Evidence;
+            fromPartial(object: import("../helpers").DeepPartial<_541.Evidence>): _541.Evidence;
+            fromAmino(object: _541.EvidenceAmino): _541.Evidence;
+            toAmino(message: _541.Evidence): _541.EvidenceAmino;
+            fromAminoMsg(object: _541.EvidenceAminoMsg): _541.Evidence;
+            fromProtoMsg(message: _541.EvidenceProtoMsg): _541.Evidence;
+            toProto(message: _541.Evidence): Uint8Array;
+            toProtoMsg(message: _541.Evidence): _541.EvidenceProtoMsg;
         };
         DuplicateVoteEvidence: {
             typeUrl: string;
-            encode(message: _480.DuplicateVoteEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _480.DuplicateVoteEvidence;
-            fromPartial(object: import("../helpers").DeepPartial<_480.DuplicateVoteEvidence>): _480.DuplicateVoteEvidence;
-            fromAmino(object: _480.DuplicateVoteEvidenceAmino): _480.DuplicateVoteEvidence;
-            toAmino(message: _480.DuplicateVoteEvidence): _480.DuplicateVoteEvidenceAmino;
-            fromAminoMsg(object: _480.DuplicateVoteEvidenceAminoMsg): _480.DuplicateVoteEvidence;
-            fromProtoMsg(message: _480.DuplicateVoteEvidenceProtoMsg): _480.DuplicateVoteEvidence;
-            toProto(message: _480.DuplicateVoteEvidence): Uint8Array;
-            toProtoMsg(message: _480.DuplicateVoteEvidence): _480.DuplicateVoteEvidenceProtoMsg;
+            encode(message: _541.DuplicateVoteEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.DuplicateVoteEvidence;
+            fromPartial(object: import("../helpers").DeepPartial<_541.DuplicateVoteEvidence>): _541.DuplicateVoteEvidence;
+            fromAmino(object: _541.DuplicateVoteEvidenceAmino): _541.DuplicateVoteEvidence;
+            toAmino(message: _541.DuplicateVoteEvidence): _541.DuplicateVoteEvidenceAmino;
+            fromAminoMsg(object: _541.DuplicateVoteEvidenceAminoMsg): _541.DuplicateVoteEvidence;
+            fromProtoMsg(message: _541.DuplicateVoteEvidenceProtoMsg): _541.DuplicateVoteEvidence;
+            toProto(message: _541.DuplicateVoteEvidence): Uint8Array;
+            toProtoMsg(message: _541.DuplicateVoteEvidence): _541.DuplicateVoteEvidenceProtoMsg;
         };
         LightClientAttackEvidence: {
             typeUrl: string;
-            encode(message: _480.LightClientAttackEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _480.LightClientAttackEvidence;
-            fromPartial(object: import("../helpers").DeepPartial<_480.LightClientAttackEvidence>): _480.LightClientAttackEvidence;
-            fromAmino(object: _480.LightClientAttackEvidenceAmino): _480.LightClientAttackEvidence;
-            toAmino(message: _480.LightClientAttackEvidence): _480.LightClientAttackEvidenceAmino;
-            fromAminoMsg(object: _480.LightClientAttackEvidenceAminoMsg): _480.LightClientAttackEvidence;
-            fromProtoMsg(message: _480.LightClientAttackEvidenceProtoMsg): _480.LightClientAttackEvidence;
-            toProto(message: _480.LightClientAttackEvidence): Uint8Array;
-            toProtoMsg(message: _480.LightClientAttackEvidence): _480.LightClientAttackEvidenceProtoMsg;
+            encode(message: _541.LightClientAttackEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.LightClientAttackEvidence;
+            fromPartial(object: import("../helpers").DeepPartial<_541.LightClientAttackEvidence>): _541.LightClientAttackEvidence;
+            fromAmino(object: _541.LightClientAttackEvidenceAmino): _541.LightClientAttackEvidence;
+            toAmino(message: _541.LightClientAttackEvidence): _541.LightClientAttackEvidenceAmino;
+            fromAminoMsg(object: _541.LightClientAttackEvidenceAminoMsg): _541.LightClientAttackEvidence;
+            fromProtoMsg(message: _541.LightClientAttackEvidenceProtoMsg): _541.LightClientAttackEvidence;
+            toProto(message: _541.LightClientAttackEvidence): Uint8Array;
+            toProtoMsg(message: _541.LightClientAttackEvidence): _541.LightClientAttackEvidenceProtoMsg;
         };
         EvidenceList: {
             typeUrl: string;
-            encode(message: _480.EvidenceList, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _480.EvidenceList;
-            fromPartial(object: import("../helpers").DeepPartial<_480.EvidenceList>): _480.EvidenceList;
-            fromAmino(object: _480.EvidenceListAmino): _480.EvidenceList;
-            toAmino(message: _480.EvidenceList): _480.EvidenceListAmino;
-            fromAminoMsg(object: _480.EvidenceListAminoMsg): _480.EvidenceList;
-            fromProtoMsg(message: _480.EvidenceListProtoMsg): _480.EvidenceList;
-            toProto(message: _480.EvidenceList): Uint8Array;
-            toProtoMsg(message: _480.EvidenceList): _480.EvidenceListProtoMsg;
+            encode(message: _541.EvidenceList, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _541.EvidenceList;
+            fromPartial(object: import("../helpers").DeepPartial<_541.EvidenceList>): _541.EvidenceList;
+            fromAmino(object: _541.EvidenceListAmino): _541.EvidenceList;
+            toAmino(message: _541.EvidenceList): _541.EvidenceListAmino;
+            fromAminoMsg(object: _541.EvidenceListAminoMsg): _541.EvidenceList;
+            fromProtoMsg(message: _541.EvidenceListProtoMsg): _541.EvidenceList;
+            toProto(message: _541.EvidenceList): Uint8Array;
+            toProtoMsg(message: _541.EvidenceList): _541.EvidenceListProtoMsg;
         };
         Block: {
             typeUrl: string;
-            encode(message: _479.Block, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _479.Block;
-            fromPartial(object: import("../helpers").DeepPartial<_479.Block>): _479.Block;
-            fromAmino(object: _479.BlockAmino): _479.Block;
-            toAmino(message: _479.Block): _479.BlockAmino;
-            fromAminoMsg(object: _479.BlockAminoMsg): _479.Block;
-            fromProtoMsg(message: _479.BlockProtoMsg): _479.Block;
-            toProto(message: _479.Block): Uint8Array;
-            toProtoMsg(message: _479.Block): _479.BlockProtoMsg;
+            encode(message: _540.Block, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _540.Block;
+            fromPartial(object: import("../helpers").DeepPartial<_540.Block>): _540.Block;
+            fromAmino(object: _540.BlockAmino): _540.Block;
+            toAmino(message: _540.Block): _540.BlockAmino;
+            fromAminoMsg(object: _540.BlockAminoMsg): _540.Block;
+            fromProtoMsg(message: _540.BlockProtoMsg): _540.Block;
+            toProto(message: _540.Block): Uint8Array;
+            toProtoMsg(message: _540.Block): _540.BlockProtoMsg;
         };
     };
     const version: {
         App: {
             typeUrl: string;
-            encode(message: _484.App, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _484.App;
-            fromPartial(object: import("../helpers").DeepPartial<_484.App>): _484.App;
-            fromAmino(object: _484.AppAmino): _484.App;
-            toAmino(message: _484.App): _484.AppAmino;
-            fromAminoMsg(object: _484.AppAminoMsg): _484.App;
-            fromProtoMsg(message: _484.AppProtoMsg): _484.App;
-            toProto(message: _484.App): Uint8Array;
-            toProtoMsg(message: _484.App): _484.AppProtoMsg;
+            encode(message: _545.App, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.App;
+            fromPartial(object: import("../helpers").DeepPartial<_545.App>): _545.App;
+            fromAmino(object: _545.AppAmino): _545.App;
+            toAmino(message: _545.App): _545.AppAmino;
+            fromAminoMsg(object: _545.AppAminoMsg): _545.App;
+            fromProtoMsg(message: _545.AppProtoMsg): _545.App;
+            toProto(message: _545.App): Uint8Array;
+            toProtoMsg(message: _545.App): _545.AppProtoMsg;
         };
         Consensus: {
             typeUrl: string;
-            encode(message: _484.Consensus, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _484.Consensus;
-            fromPartial(object: import("../helpers").DeepPartial<_484.Consensus>): _484.Consensus;
-            fromAmino(object: _484.ConsensusAmino): _484.Consensus;
-            toAmino(message: _484.Consensus): _484.ConsensusAmino;
-            fromAminoMsg(object: _484.ConsensusAminoMsg): _484.Consensus;
-            fromProtoMsg(message: _484.ConsensusProtoMsg): _484.Consensus;
-            toProto(message: _484.Consensus): Uint8Array;
-            toProtoMsg(message: _484.Consensus): _484.ConsensusProtoMsg;
+            encode(message: _545.Consensus, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _545.Consensus;
+            fromPartial(object: import("../helpers").DeepPartial<_545.Consensus>): _545.Consensus;
+            fromAmino(object: _545.ConsensusAmino): _545.Consensus;
+            toAmino(message: _545.Consensus): _545.ConsensusAmino;
+            fromAminoMsg(object: _545.ConsensusAminoMsg): _545.Consensus;
+            fromProtoMsg(message: _545.ConsensusProtoMsg): _545.Consensus;
+            toProto(message: _545.Consensus): Uint8Array;
+            toProtoMsg(message: _545.Consensus): _545.ConsensusProtoMsg;
         };
     };
 }