@sparkdreamnft/sparkdreamjs 0.0.29 → 0.0.30

package/tendermint/bundle.d.ts

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