@sparkdreamnft/sparkdreamjs 0.0.25 → 0.0.27

package/tendermint/bundle.d.ts

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