@sparkdreamnft/sparkdreamjs 0.0.5 → 0.0.7

package/tendermint/bundle.d.ts

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