@sparkdreamnft/sparkdreamjs 0.0.4 → 0.0.6

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