@sparkdreamnft/sparkdreamjs 0.0.6 → 0.0.8

package/tendermint/bundle.d.ts

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