@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/tendermint/bundle.d.ts

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