@sparkdreamnft/sparkdreamjs 0.0.30 → 0.0.32

package/tendermint/bundle.d.ts

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