@sparkdreamnft/sparkdreamjs 0.0.45 → 0.0.47

package/tendermint/bundle.d.ts

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