@manifest-network/manifestjs 2.1.0

package/dist/codegen/tendermint/bundle.d.ts

@@ -0,0 +1,1597 @@
+import * as _132 from "./abci/types";
+import * as _133 from "./crypto/keys";
+import * as _134 from "./crypto/proof";
+import * as _135 from "./libs/bits/types";
+import * as _136 from "./p2p/types";
+import * as _137 from "./types/block";
+import * as _138 from "./types/evidence";
+import * as _139 from "./types/params";
+import * as _140 from "./types/types";
+import * as _141 from "./types/validator";
+import * as _142 from "./version/types";
+export declare namespace tendermint {
+    const abci: {
+        checkTxTypeFromJSON(object: any): _132.CheckTxType;
+        checkTxTypeToJSON(object: _132.CheckTxType): string;
+        responseOfferSnapshot_ResultFromJSON(object: any): _132.ResponseOfferSnapshot_Result;
+        responseOfferSnapshot_ResultToJSON(object: _132.ResponseOfferSnapshot_Result): string;
+        responseApplySnapshotChunk_ResultFromJSON(object: any): _132.ResponseApplySnapshotChunk_Result;
+        responseApplySnapshotChunk_ResultToJSON(object: _132.ResponseApplySnapshotChunk_Result): string;
+        responseProcessProposal_ProposalStatusFromJSON(object: any): _132.ResponseProcessProposal_ProposalStatus;
+        responseProcessProposal_ProposalStatusToJSON(object: _132.ResponseProcessProposal_ProposalStatus): string;
+        responseVerifyVoteExtension_VerifyStatusFromJSON(object: any): _132.ResponseVerifyVoteExtension_VerifyStatus;
+        responseVerifyVoteExtension_VerifyStatusToJSON(object: _132.ResponseVerifyVoteExtension_VerifyStatus): string;
+        misbehaviorTypeFromJSON(object: any): _132.MisbehaviorType;
+        misbehaviorTypeToJSON(object: _132.MisbehaviorType): string;
+        CheckTxType: typeof _132.CheckTxType;
+        CheckTxTypeSDKType: typeof _132.CheckTxType;
+        CheckTxTypeAmino: typeof _132.CheckTxType;
+        ResponseOfferSnapshot_Result: typeof _132.ResponseOfferSnapshot_Result;
+        ResponseOfferSnapshot_ResultSDKType: typeof _132.ResponseOfferSnapshot_Result;
+        ResponseOfferSnapshot_ResultAmino: typeof _132.ResponseOfferSnapshot_Result;
+        ResponseApplySnapshotChunk_Result: typeof _132.ResponseApplySnapshotChunk_Result;
+        ResponseApplySnapshotChunk_ResultSDKType: typeof _132.ResponseApplySnapshotChunk_Result;
+        ResponseApplySnapshotChunk_ResultAmino: typeof _132.ResponseApplySnapshotChunk_Result;
+        ResponseProcessProposal_ProposalStatus: typeof _132.ResponseProcessProposal_ProposalStatus;
+        ResponseProcessProposal_ProposalStatusSDKType: typeof _132.ResponseProcessProposal_ProposalStatus;
+        ResponseProcessProposal_ProposalStatusAmino: typeof _132.ResponseProcessProposal_ProposalStatus;
+        ResponseVerifyVoteExtension_VerifyStatus: typeof _132.ResponseVerifyVoteExtension_VerifyStatus;
+        ResponseVerifyVoteExtension_VerifyStatusSDKType: typeof _132.ResponseVerifyVoteExtension_VerifyStatus;
+        ResponseVerifyVoteExtension_VerifyStatusAmino: typeof _132.ResponseVerifyVoteExtension_VerifyStatus;
+        MisbehaviorType: typeof _132.MisbehaviorType;
+        MisbehaviorTypeSDKType: typeof _132.MisbehaviorType;
+        MisbehaviorTypeAmino: typeof _132.MisbehaviorType;
+        Request: {
+            typeUrl: string;
+            is(o: any): o is _132.Request;
+            isSDK(o: any): o is _132.RequestSDKType;
+            isAmino(o: any): o is _132.RequestAmino;
+            encode(message: _132.Request, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Request;
+            fromJSON(object: any): _132.Request;
+            toJSON(message: _132.Request): import("..").JsonSafe<_132.Request>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.Request>, I>>(object: I): _132.Request;
+            fromAmino(object: _132.RequestAmino): _132.Request;
+            toAmino(message: _132.Request): _132.RequestAmino;
+            fromAminoMsg(object: _132.RequestAminoMsg): _132.Request;
+            fromProtoMsg(message: _132.RequestProtoMsg): _132.Request;
+            toProto(message: _132.Request): Uint8Array;
+            toProtoMsg(message: _132.Request): _132.RequestProtoMsg;
+        };
+        RequestEcho: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestEcho;
+            isSDK(o: any): o is _132.RequestEchoSDKType;
+            isAmino(o: any): o is _132.RequestEchoAmino;
+            encode(message: _132.RequestEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestEcho;
+            fromJSON(object: any): _132.RequestEcho;
+            toJSON(message: _132.RequestEcho): import("..").JsonSafe<_132.RequestEcho>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestEcho>, I>>(object: I): _132.RequestEcho;
+            fromAmino(object: _132.RequestEchoAmino): _132.RequestEcho;
+            toAmino(message: _132.RequestEcho): _132.RequestEchoAmino;
+            fromAminoMsg(object: _132.RequestEchoAminoMsg): _132.RequestEcho;
+            fromProtoMsg(message: _132.RequestEchoProtoMsg): _132.RequestEcho;
+            toProto(message: _132.RequestEcho): Uint8Array;
+            toProtoMsg(message: _132.RequestEcho): _132.RequestEchoProtoMsg;
+        };
+        RequestFlush: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestFlush;
+            isSDK(o: any): o is _132.RequestFlushSDKType;
+            isAmino(o: any): o is _132.RequestFlushAmino;
+            encode(_: _132.RequestFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestFlush;
+            fromJSON(_: any): _132.RequestFlush;
+            toJSON(_: _132.RequestFlush): import("..").JsonSafe<_132.RequestFlush>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestFlush>, I>>(_: I): _132.RequestFlush;
+            fromAmino(_: _132.RequestFlushAmino): _132.RequestFlush;
+            toAmino(_: _132.RequestFlush): _132.RequestFlushAmino;
+            fromAminoMsg(object: _132.RequestFlushAminoMsg): _132.RequestFlush;
+            fromProtoMsg(message: _132.RequestFlushProtoMsg): _132.RequestFlush;
+            toProto(message: _132.RequestFlush): Uint8Array;
+            toProtoMsg(message: _132.RequestFlush): _132.RequestFlushProtoMsg;
+        };
+        RequestInfo: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestInfo;
+            isSDK(o: any): o is _132.RequestInfoSDKType;
+            isAmino(o: any): o is _132.RequestInfoAmino;
+            encode(message: _132.RequestInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestInfo;
+            fromJSON(object: any): _132.RequestInfo;
+            toJSON(message: _132.RequestInfo): import("..").JsonSafe<_132.RequestInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestInfo>, I>>(object: I): _132.RequestInfo;
+            fromAmino(object: _132.RequestInfoAmino): _132.RequestInfo;
+            toAmino(message: _132.RequestInfo): _132.RequestInfoAmino;
+            fromAminoMsg(object: _132.RequestInfoAminoMsg): _132.RequestInfo;
+            fromProtoMsg(message: _132.RequestInfoProtoMsg): _132.RequestInfo;
+            toProto(message: _132.RequestInfo): Uint8Array;
+            toProtoMsg(message: _132.RequestInfo): _132.RequestInfoProtoMsg;
+        };
+        RequestInitChain: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestInitChain;
+            isSDK(o: any): o is _132.RequestInitChainSDKType;
+            isAmino(o: any): o is _132.RequestInitChainAmino;
+            encode(message: _132.RequestInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestInitChain;
+            fromJSON(object: any): _132.RequestInitChain;
+            toJSON(message: _132.RequestInitChain): import("..").JsonSafe<_132.RequestInitChain>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestInitChain>, I>>(object: I): _132.RequestInitChain;
+            fromAmino(object: _132.RequestInitChainAmino): _132.RequestInitChain;
+            toAmino(message: _132.RequestInitChain): _132.RequestInitChainAmino;
+            fromAminoMsg(object: _132.RequestInitChainAminoMsg): _132.RequestInitChain;
+            fromProtoMsg(message: _132.RequestInitChainProtoMsg): _132.RequestInitChain;
+            toProto(message: _132.RequestInitChain): Uint8Array;
+            toProtoMsg(message: _132.RequestInitChain): _132.RequestInitChainProtoMsg;
+        };
+        RequestQuery: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestQuery;
+            isSDK(o: any): o is _132.RequestQuerySDKType;
+            isAmino(o: any): o is _132.RequestQueryAmino;
+            encode(message: _132.RequestQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestQuery;
+            fromJSON(object: any): _132.RequestQuery;
+            toJSON(message: _132.RequestQuery): import("..").JsonSafe<_132.RequestQuery>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestQuery>, I>>(object: I): _132.RequestQuery;
+            fromAmino(object: _132.RequestQueryAmino): _132.RequestQuery;
+            toAmino(message: _132.RequestQuery): _132.RequestQueryAmino;
+            fromAminoMsg(object: _132.RequestQueryAminoMsg): _132.RequestQuery;
+            fromProtoMsg(message: _132.RequestQueryProtoMsg): _132.RequestQuery;
+            toProto(message: _132.RequestQuery): Uint8Array;
+            toProtoMsg(message: _132.RequestQuery): _132.RequestQueryProtoMsg;
+        };
+        RequestCheckTx: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestCheckTx;
+            isSDK(o: any): o is _132.RequestCheckTxSDKType;
+            isAmino(o: any): o is _132.RequestCheckTxAmino;
+            encode(message: _132.RequestCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestCheckTx;
+            fromJSON(object: any): _132.RequestCheckTx;
+            toJSON(message: _132.RequestCheckTx): import("..").JsonSafe<_132.RequestCheckTx>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestCheckTx>, I>>(object: I): _132.RequestCheckTx;
+            fromAmino(object: _132.RequestCheckTxAmino): _132.RequestCheckTx;
+            toAmino(message: _132.RequestCheckTx): _132.RequestCheckTxAmino;
+            fromAminoMsg(object: _132.RequestCheckTxAminoMsg): _132.RequestCheckTx;
+            fromProtoMsg(message: _132.RequestCheckTxProtoMsg): _132.RequestCheckTx;
+            toProto(message: _132.RequestCheckTx): Uint8Array;
+            toProtoMsg(message: _132.RequestCheckTx): _132.RequestCheckTxProtoMsg;
+        };
+        RequestCommit: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestCommit;
+            isSDK(o: any): o is _132.RequestCommitSDKType;
+            isAmino(o: any): o is _132.RequestCommitAmino;
+            encode(_: _132.RequestCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestCommit;
+            fromJSON(_: any): _132.RequestCommit;
+            toJSON(_: _132.RequestCommit): import("..").JsonSafe<_132.RequestCommit>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestCommit>, I>>(_: I): _132.RequestCommit;
+            fromAmino(_: _132.RequestCommitAmino): _132.RequestCommit;
+            toAmino(_: _132.RequestCommit): _132.RequestCommitAmino;
+            fromAminoMsg(object: _132.RequestCommitAminoMsg): _132.RequestCommit;
+            fromProtoMsg(message: _132.RequestCommitProtoMsg): _132.RequestCommit;
+            toProto(message: _132.RequestCommit): Uint8Array;
+            toProtoMsg(message: _132.RequestCommit): _132.RequestCommitProtoMsg;
+        };
+        RequestListSnapshots: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestListSnapshots;
+            isSDK(o: any): o is _132.RequestListSnapshotsSDKType;
+            isAmino(o: any): o is _132.RequestListSnapshotsAmino;
+            encode(_: _132.RequestListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestListSnapshots;
+            fromJSON(_: any): _132.RequestListSnapshots;
+            toJSON(_: _132.RequestListSnapshots): import("..").JsonSafe<_132.RequestListSnapshots>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestListSnapshots>, I>>(_: I): _132.RequestListSnapshots;
+            fromAmino(_: _132.RequestListSnapshotsAmino): _132.RequestListSnapshots;
+            toAmino(_: _132.RequestListSnapshots): _132.RequestListSnapshotsAmino;
+            fromAminoMsg(object: _132.RequestListSnapshotsAminoMsg): _132.RequestListSnapshots;
+            fromProtoMsg(message: _132.RequestListSnapshotsProtoMsg): _132.RequestListSnapshots;
+            toProto(message: _132.RequestListSnapshots): Uint8Array;
+            toProtoMsg(message: _132.RequestListSnapshots): _132.RequestListSnapshotsProtoMsg;
+        };
+        RequestOfferSnapshot: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestOfferSnapshot;
+            isSDK(o: any): o is _132.RequestOfferSnapshotSDKType;
+            isAmino(o: any): o is _132.RequestOfferSnapshotAmino;
+            encode(message: _132.RequestOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestOfferSnapshot;
+            fromJSON(object: any): _132.RequestOfferSnapshot;
+            toJSON(message: _132.RequestOfferSnapshot): import("..").JsonSafe<_132.RequestOfferSnapshot>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestOfferSnapshot>, I>>(object: I): _132.RequestOfferSnapshot;
+            fromAmino(object: _132.RequestOfferSnapshotAmino): _132.RequestOfferSnapshot;
+            toAmino(message: _132.RequestOfferSnapshot): _132.RequestOfferSnapshotAmino;
+            fromAminoMsg(object: _132.RequestOfferSnapshotAminoMsg): _132.RequestOfferSnapshot;
+            fromProtoMsg(message: _132.RequestOfferSnapshotProtoMsg): _132.RequestOfferSnapshot;
+            toProto(message: _132.RequestOfferSnapshot): Uint8Array;
+            toProtoMsg(message: _132.RequestOfferSnapshot): _132.RequestOfferSnapshotProtoMsg;
+        };
+        RequestLoadSnapshotChunk: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestLoadSnapshotChunk;
+            isSDK(o: any): o is _132.RequestLoadSnapshotChunkSDKType;
+            isAmino(o: any): o is _132.RequestLoadSnapshotChunkAmino;
+            encode(message: _132.RequestLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestLoadSnapshotChunk;
+            fromJSON(object: any): _132.RequestLoadSnapshotChunk;
+            toJSON(message: _132.RequestLoadSnapshotChunk): import("..").JsonSafe<_132.RequestLoadSnapshotChunk>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestLoadSnapshotChunk>, I>>(object: I): _132.RequestLoadSnapshotChunk;
+            fromAmino(object: _132.RequestLoadSnapshotChunkAmino): _132.RequestLoadSnapshotChunk;
+            toAmino(message: _132.RequestLoadSnapshotChunk): _132.RequestLoadSnapshotChunkAmino;
+            fromAminoMsg(object: _132.RequestLoadSnapshotChunkAminoMsg): _132.RequestLoadSnapshotChunk;
+            fromProtoMsg(message: _132.RequestLoadSnapshotChunkProtoMsg): _132.RequestLoadSnapshotChunk;
+            toProto(message: _132.RequestLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: _132.RequestLoadSnapshotChunk): _132.RequestLoadSnapshotChunkProtoMsg;
+        };
+        RequestApplySnapshotChunk: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestApplySnapshotChunk;
+            isSDK(o: any): o is _132.RequestApplySnapshotChunkSDKType;
+            isAmino(o: any): o is _132.RequestApplySnapshotChunkAmino;
+            encode(message: _132.RequestApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestApplySnapshotChunk;
+            fromJSON(object: any): _132.RequestApplySnapshotChunk;
+            toJSON(message: _132.RequestApplySnapshotChunk): import("..").JsonSafe<_132.RequestApplySnapshotChunk>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestApplySnapshotChunk>, I>>(object: I): _132.RequestApplySnapshotChunk;
+            fromAmino(object: _132.RequestApplySnapshotChunkAmino): _132.RequestApplySnapshotChunk;
+            toAmino(message: _132.RequestApplySnapshotChunk): _132.RequestApplySnapshotChunkAmino;
+            fromAminoMsg(object: _132.RequestApplySnapshotChunkAminoMsg): _132.RequestApplySnapshotChunk;
+            fromProtoMsg(message: _132.RequestApplySnapshotChunkProtoMsg): _132.RequestApplySnapshotChunk;
+            toProto(message: _132.RequestApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: _132.RequestApplySnapshotChunk): _132.RequestApplySnapshotChunkProtoMsg;
+        };
+        RequestPrepareProposal: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestPrepareProposal;
+            isSDK(o: any): o is _132.RequestPrepareProposalSDKType;
+            isAmino(o: any): o is _132.RequestPrepareProposalAmino;
+            encode(message: _132.RequestPrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestPrepareProposal;
+            fromJSON(object: any): _132.RequestPrepareProposal;
+            toJSON(message: _132.RequestPrepareProposal): import("..").JsonSafe<_132.RequestPrepareProposal>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestPrepareProposal>, I>>(object: I): _132.RequestPrepareProposal;
+            fromAmino(object: _132.RequestPrepareProposalAmino): _132.RequestPrepareProposal;
+            toAmino(message: _132.RequestPrepareProposal): _132.RequestPrepareProposalAmino;
+            fromAminoMsg(object: _132.RequestPrepareProposalAminoMsg): _132.RequestPrepareProposal;
+            fromProtoMsg(message: _132.RequestPrepareProposalProtoMsg): _132.RequestPrepareProposal;
+            toProto(message: _132.RequestPrepareProposal): Uint8Array;
+            toProtoMsg(message: _132.RequestPrepareProposal): _132.RequestPrepareProposalProtoMsg;
+        };
+        RequestProcessProposal: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestProcessProposal;
+            isSDK(o: any): o is _132.RequestProcessProposalSDKType;
+            isAmino(o: any): o is _132.RequestProcessProposalAmino;
+            encode(message: _132.RequestProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestProcessProposal;
+            fromJSON(object: any): _132.RequestProcessProposal;
+            toJSON(message: _132.RequestProcessProposal): import("..").JsonSafe<_132.RequestProcessProposal>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestProcessProposal>, I>>(object: I): _132.RequestProcessProposal;
+            fromAmino(object: _132.RequestProcessProposalAmino): _132.RequestProcessProposal;
+            toAmino(message: _132.RequestProcessProposal): _132.RequestProcessProposalAmino;
+            fromAminoMsg(object: _132.RequestProcessProposalAminoMsg): _132.RequestProcessProposal;
+            fromProtoMsg(message: _132.RequestProcessProposalProtoMsg): _132.RequestProcessProposal;
+            toProto(message: _132.RequestProcessProposal): Uint8Array;
+            toProtoMsg(message: _132.RequestProcessProposal): _132.RequestProcessProposalProtoMsg;
+        };
+        RequestExtendVote: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestExtendVote;
+            isSDK(o: any): o is _132.RequestExtendVoteSDKType;
+            isAmino(o: any): o is _132.RequestExtendVoteAmino;
+            encode(message: _132.RequestExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestExtendVote;
+            fromJSON(object: any): _132.RequestExtendVote;
+            toJSON(message: _132.RequestExtendVote): import("..").JsonSafe<_132.RequestExtendVote>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestExtendVote>, I>>(object: I): _132.RequestExtendVote;
+            fromAmino(object: _132.RequestExtendVoteAmino): _132.RequestExtendVote;
+            toAmino(message: _132.RequestExtendVote): _132.RequestExtendVoteAmino;
+            fromAminoMsg(object: _132.RequestExtendVoteAminoMsg): _132.RequestExtendVote;
+            fromProtoMsg(message: _132.RequestExtendVoteProtoMsg): _132.RequestExtendVote;
+            toProto(message: _132.RequestExtendVote): Uint8Array;
+            toProtoMsg(message: _132.RequestExtendVote): _132.RequestExtendVoteProtoMsg;
+        };
+        RequestVerifyVoteExtension: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestVerifyVoteExtension;
+            isSDK(o: any): o is _132.RequestVerifyVoteExtensionSDKType;
+            isAmino(o: any): o is _132.RequestVerifyVoteExtensionAmino;
+            encode(message: _132.RequestVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestVerifyVoteExtension;
+            fromJSON(object: any): _132.RequestVerifyVoteExtension;
+            toJSON(message: _132.RequestVerifyVoteExtension): import("..").JsonSafe<_132.RequestVerifyVoteExtension>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestVerifyVoteExtension>, I>>(object: I): _132.RequestVerifyVoteExtension;
+            fromAmino(object: _132.RequestVerifyVoteExtensionAmino): _132.RequestVerifyVoteExtension;
+            toAmino(message: _132.RequestVerifyVoteExtension): _132.RequestVerifyVoteExtensionAmino;
+            fromAminoMsg(object: _132.RequestVerifyVoteExtensionAminoMsg): _132.RequestVerifyVoteExtension;
+            fromProtoMsg(message: _132.RequestVerifyVoteExtensionProtoMsg): _132.RequestVerifyVoteExtension;
+            toProto(message: _132.RequestVerifyVoteExtension): Uint8Array;
+            toProtoMsg(message: _132.RequestVerifyVoteExtension): _132.RequestVerifyVoteExtensionProtoMsg;
+        };
+        RequestFinalizeBlock: {
+            typeUrl: string;
+            is(o: any): o is _132.RequestFinalizeBlock;
+            isSDK(o: any): o is _132.RequestFinalizeBlockSDKType;
+            isAmino(o: any): o is _132.RequestFinalizeBlockAmino;
+            encode(message: _132.RequestFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestFinalizeBlock;
+            fromJSON(object: any): _132.RequestFinalizeBlock;
+            toJSON(message: _132.RequestFinalizeBlock): import("..").JsonSafe<_132.RequestFinalizeBlock>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.RequestFinalizeBlock>, I>>(object: I): _132.RequestFinalizeBlock;
+            fromAmino(object: _132.RequestFinalizeBlockAmino): _132.RequestFinalizeBlock;
+            toAmino(message: _132.RequestFinalizeBlock): _132.RequestFinalizeBlockAmino;
+            fromAminoMsg(object: _132.RequestFinalizeBlockAminoMsg): _132.RequestFinalizeBlock;
+            fromProtoMsg(message: _132.RequestFinalizeBlockProtoMsg): _132.RequestFinalizeBlock;
+            toProto(message: _132.RequestFinalizeBlock): Uint8Array;
+            toProtoMsg(message: _132.RequestFinalizeBlock): _132.RequestFinalizeBlockProtoMsg;
+        };
+        Response: {
+            typeUrl: string;
+            is(o: any): o is _132.Response;
+            isSDK(o: any): o is _132.ResponseSDKType;
+            isAmino(o: any): o is _132.ResponseAmino;
+            encode(message: _132.Response, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Response;
+            fromJSON(object: any): _132.Response;
+            toJSON(message: _132.Response): import("..").JsonSafe<_132.Response>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.Response>, I>>(object: I): _132.Response;
+            fromAmino(object: _132.ResponseAmino): _132.Response;
+            toAmino(message: _132.Response): _132.ResponseAmino;
+            fromAminoMsg(object: _132.ResponseAminoMsg): _132.Response;
+            fromProtoMsg(message: _132.ResponseProtoMsg): _132.Response;
+            toProto(message: _132.Response): Uint8Array;
+            toProtoMsg(message: _132.Response): _132.ResponseProtoMsg;
+        };
+        ResponseException: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseException;
+            isSDK(o: any): o is _132.ResponseExceptionSDKType;
+            isAmino(o: any): o is _132.ResponseExceptionAmino;
+            encode(message: _132.ResponseException, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseException;
+            fromJSON(object: any): _132.ResponseException;
+            toJSON(message: _132.ResponseException): import("..").JsonSafe<_132.ResponseException>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseException>, I>>(object: I): _132.ResponseException;
+            fromAmino(object: _132.ResponseExceptionAmino): _132.ResponseException;
+            toAmino(message: _132.ResponseException): _132.ResponseExceptionAmino;
+            fromAminoMsg(object: _132.ResponseExceptionAminoMsg): _132.ResponseException;
+            fromProtoMsg(message: _132.ResponseExceptionProtoMsg): _132.ResponseException;
+            toProto(message: _132.ResponseException): Uint8Array;
+            toProtoMsg(message: _132.ResponseException): _132.ResponseExceptionProtoMsg;
+        };
+        ResponseEcho: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseEcho;
+            isSDK(o: any): o is _132.ResponseEchoSDKType;
+            isAmino(o: any): o is _132.ResponseEchoAmino;
+            encode(message: _132.ResponseEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseEcho;
+            fromJSON(object: any): _132.ResponseEcho;
+            toJSON(message: _132.ResponseEcho): import("..").JsonSafe<_132.ResponseEcho>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseEcho>, I>>(object: I): _132.ResponseEcho;
+            fromAmino(object: _132.ResponseEchoAmino): _132.ResponseEcho;
+            toAmino(message: _132.ResponseEcho): _132.ResponseEchoAmino;
+            fromAminoMsg(object: _132.ResponseEchoAminoMsg): _132.ResponseEcho;
+            fromProtoMsg(message: _132.ResponseEchoProtoMsg): _132.ResponseEcho;
+            toProto(message: _132.ResponseEcho): Uint8Array;
+            toProtoMsg(message: _132.ResponseEcho): _132.ResponseEchoProtoMsg;
+        };
+        ResponseFlush: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseFlush;
+            isSDK(o: any): o is _132.ResponseFlushSDKType;
+            isAmino(o: any): o is _132.ResponseFlushAmino;
+            encode(_: _132.ResponseFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseFlush;
+            fromJSON(_: any): _132.ResponseFlush;
+            toJSON(_: _132.ResponseFlush): import("..").JsonSafe<_132.ResponseFlush>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseFlush>, I>>(_: I): _132.ResponseFlush;
+            fromAmino(_: _132.ResponseFlushAmino): _132.ResponseFlush;
+            toAmino(_: _132.ResponseFlush): _132.ResponseFlushAmino;
+            fromAminoMsg(object: _132.ResponseFlushAminoMsg): _132.ResponseFlush;
+            fromProtoMsg(message: _132.ResponseFlushProtoMsg): _132.ResponseFlush;
+            toProto(message: _132.ResponseFlush): Uint8Array;
+            toProtoMsg(message: _132.ResponseFlush): _132.ResponseFlushProtoMsg;
+        };
+        ResponseInfo: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseInfo;
+            isSDK(o: any): o is _132.ResponseInfoSDKType;
+            isAmino(o: any): o is _132.ResponseInfoAmino;
+            encode(message: _132.ResponseInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseInfo;
+            fromJSON(object: any): _132.ResponseInfo;
+            toJSON(message: _132.ResponseInfo): import("..").JsonSafe<_132.ResponseInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseInfo>, I>>(object: I): _132.ResponseInfo;
+            fromAmino(object: _132.ResponseInfoAmino): _132.ResponseInfo;
+            toAmino(message: _132.ResponseInfo): _132.ResponseInfoAmino;
+            fromAminoMsg(object: _132.ResponseInfoAminoMsg): _132.ResponseInfo;
+            fromProtoMsg(message: _132.ResponseInfoProtoMsg): _132.ResponseInfo;
+            toProto(message: _132.ResponseInfo): Uint8Array;
+            toProtoMsg(message: _132.ResponseInfo): _132.ResponseInfoProtoMsg;
+        };
+        ResponseInitChain: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseInitChain;
+            isSDK(o: any): o is _132.ResponseInitChainSDKType;
+            isAmino(o: any): o is _132.ResponseInitChainAmino;
+            encode(message: _132.ResponseInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseInitChain;
+            fromJSON(object: any): _132.ResponseInitChain;
+            toJSON(message: _132.ResponseInitChain): import("..").JsonSafe<_132.ResponseInitChain>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseInitChain>, I>>(object: I): _132.ResponseInitChain;
+            fromAmino(object: _132.ResponseInitChainAmino): _132.ResponseInitChain;
+            toAmino(message: _132.ResponseInitChain): _132.ResponseInitChainAmino;
+            fromAminoMsg(object: _132.ResponseInitChainAminoMsg): _132.ResponseInitChain;
+            fromProtoMsg(message: _132.ResponseInitChainProtoMsg): _132.ResponseInitChain;
+            toProto(message: _132.ResponseInitChain): Uint8Array;
+            toProtoMsg(message: _132.ResponseInitChain): _132.ResponseInitChainProtoMsg;
+        };
+        ResponseQuery: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseQuery;
+            isSDK(o: any): o is _132.ResponseQuerySDKType;
+            isAmino(o: any): o is _132.ResponseQueryAmino;
+            encode(message: _132.ResponseQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseQuery;
+            fromJSON(object: any): _132.ResponseQuery;
+            toJSON(message: _132.ResponseQuery): import("..").JsonSafe<_132.ResponseQuery>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseQuery>, I>>(object: I): _132.ResponseQuery;
+            fromAmino(object: _132.ResponseQueryAmino): _132.ResponseQuery;
+            toAmino(message: _132.ResponseQuery): _132.ResponseQueryAmino;
+            fromAminoMsg(object: _132.ResponseQueryAminoMsg): _132.ResponseQuery;
+            fromProtoMsg(message: _132.ResponseQueryProtoMsg): _132.ResponseQuery;
+            toProto(message: _132.ResponseQuery): Uint8Array;
+            toProtoMsg(message: _132.ResponseQuery): _132.ResponseQueryProtoMsg;
+        };
+        ResponseCheckTx: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseCheckTx;
+            isSDK(o: any): o is _132.ResponseCheckTxSDKType;
+            isAmino(o: any): o is _132.ResponseCheckTxAmino;
+            encode(message: _132.ResponseCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseCheckTx;
+            fromJSON(object: any): _132.ResponseCheckTx;
+            toJSON(message: _132.ResponseCheckTx): import("..").JsonSafe<_132.ResponseCheckTx>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseCheckTx>, I>>(object: I): _132.ResponseCheckTx;
+            fromAmino(object: _132.ResponseCheckTxAmino): _132.ResponseCheckTx;
+            toAmino(message: _132.ResponseCheckTx): _132.ResponseCheckTxAmino;
+            fromAminoMsg(object: _132.ResponseCheckTxAminoMsg): _132.ResponseCheckTx;
+            fromProtoMsg(message: _132.ResponseCheckTxProtoMsg): _132.ResponseCheckTx;
+            toProto(message: _132.ResponseCheckTx): Uint8Array;
+            toProtoMsg(message: _132.ResponseCheckTx): _132.ResponseCheckTxProtoMsg;
+        };
+        ResponseCommit: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseCommit;
+            isSDK(o: any): o is _132.ResponseCommitSDKType;
+            isAmino(o: any): o is _132.ResponseCommitAmino;
+            encode(message: _132.ResponseCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseCommit;
+            fromJSON(object: any): _132.ResponseCommit;
+            toJSON(message: _132.ResponseCommit): import("..").JsonSafe<_132.ResponseCommit>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseCommit>, I>>(object: I): _132.ResponseCommit;
+            fromAmino(object: _132.ResponseCommitAmino): _132.ResponseCommit;
+            toAmino(message: _132.ResponseCommit): _132.ResponseCommitAmino;
+            fromAminoMsg(object: _132.ResponseCommitAminoMsg): _132.ResponseCommit;
+            fromProtoMsg(message: _132.ResponseCommitProtoMsg): _132.ResponseCommit;
+            toProto(message: _132.ResponseCommit): Uint8Array;
+            toProtoMsg(message: _132.ResponseCommit): _132.ResponseCommitProtoMsg;
+        };
+        ResponseListSnapshots: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseListSnapshots;
+            isSDK(o: any): o is _132.ResponseListSnapshotsSDKType;
+            isAmino(o: any): o is _132.ResponseListSnapshotsAmino;
+            encode(message: _132.ResponseListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseListSnapshots;
+            fromJSON(object: any): _132.ResponseListSnapshots;
+            toJSON(message: _132.ResponseListSnapshots): import("..").JsonSafe<_132.ResponseListSnapshots>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseListSnapshots>, I>>(object: I): _132.ResponseListSnapshots;
+            fromAmino(object: _132.ResponseListSnapshotsAmino): _132.ResponseListSnapshots;
+            toAmino(message: _132.ResponseListSnapshots): _132.ResponseListSnapshotsAmino;
+            fromAminoMsg(object: _132.ResponseListSnapshotsAminoMsg): _132.ResponseListSnapshots;
+            fromProtoMsg(message: _132.ResponseListSnapshotsProtoMsg): _132.ResponseListSnapshots;
+            toProto(message: _132.ResponseListSnapshots): Uint8Array;
+            toProtoMsg(message: _132.ResponseListSnapshots): _132.ResponseListSnapshotsProtoMsg;
+        };
+        ResponseOfferSnapshot: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseOfferSnapshot;
+            isSDK(o: any): o is _132.ResponseOfferSnapshotSDKType;
+            isAmino(o: any): o is _132.ResponseOfferSnapshotAmino;
+            encode(message: _132.ResponseOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseOfferSnapshot;
+            fromJSON(object: any): _132.ResponseOfferSnapshot;
+            toJSON(message: _132.ResponseOfferSnapshot): import("..").JsonSafe<_132.ResponseOfferSnapshot>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseOfferSnapshot>, I>>(object: I): _132.ResponseOfferSnapshot;
+            fromAmino(object: _132.ResponseOfferSnapshotAmino): _132.ResponseOfferSnapshot;
+            toAmino(message: _132.ResponseOfferSnapshot): _132.ResponseOfferSnapshotAmino;
+            fromAminoMsg(object: _132.ResponseOfferSnapshotAminoMsg): _132.ResponseOfferSnapshot;
+            fromProtoMsg(message: _132.ResponseOfferSnapshotProtoMsg): _132.ResponseOfferSnapshot;
+            toProto(message: _132.ResponseOfferSnapshot): Uint8Array;
+            toProtoMsg(message: _132.ResponseOfferSnapshot): _132.ResponseOfferSnapshotProtoMsg;
+        };
+        ResponseLoadSnapshotChunk: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseLoadSnapshotChunk;
+            isSDK(o: any): o is _132.ResponseLoadSnapshotChunkSDKType;
+            isAmino(o: any): o is _132.ResponseLoadSnapshotChunkAmino;
+            encode(message: _132.ResponseLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseLoadSnapshotChunk;
+            fromJSON(object: any): _132.ResponseLoadSnapshotChunk;
+            toJSON(message: _132.ResponseLoadSnapshotChunk): import("..").JsonSafe<_132.ResponseLoadSnapshotChunk>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseLoadSnapshotChunk>, I>>(object: I): _132.ResponseLoadSnapshotChunk;
+            fromAmino(object: _132.ResponseLoadSnapshotChunkAmino): _132.ResponseLoadSnapshotChunk;
+            toAmino(message: _132.ResponseLoadSnapshotChunk): _132.ResponseLoadSnapshotChunkAmino;
+            fromAminoMsg(object: _132.ResponseLoadSnapshotChunkAminoMsg): _132.ResponseLoadSnapshotChunk;
+            fromProtoMsg(message: _132.ResponseLoadSnapshotChunkProtoMsg): _132.ResponseLoadSnapshotChunk;
+            toProto(message: _132.ResponseLoadSnapshotChunk): Uint8Array;
+            toProtoMsg(message: _132.ResponseLoadSnapshotChunk): _132.ResponseLoadSnapshotChunkProtoMsg;
+        };
+        ResponseApplySnapshotChunk: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseApplySnapshotChunk;
+            isSDK(o: any): o is _132.ResponseApplySnapshotChunkSDKType;
+            isAmino(o: any): o is _132.ResponseApplySnapshotChunkAmino;
+            encode(message: _132.ResponseApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseApplySnapshotChunk;
+            fromJSON(object: any): _132.ResponseApplySnapshotChunk;
+            toJSON(message: _132.ResponseApplySnapshotChunk): import("..").JsonSafe<_132.ResponseApplySnapshotChunk>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseApplySnapshotChunk>, I>>(object: I): _132.ResponseApplySnapshotChunk;
+            fromAmino(object: _132.ResponseApplySnapshotChunkAmino): _132.ResponseApplySnapshotChunk;
+            toAmino(message: _132.ResponseApplySnapshotChunk): _132.ResponseApplySnapshotChunkAmino;
+            fromAminoMsg(object: _132.ResponseApplySnapshotChunkAminoMsg): _132.ResponseApplySnapshotChunk;
+            fromProtoMsg(message: _132.ResponseApplySnapshotChunkProtoMsg): _132.ResponseApplySnapshotChunk;
+            toProto(message: _132.ResponseApplySnapshotChunk): Uint8Array;
+            toProtoMsg(message: _132.ResponseApplySnapshotChunk): _132.ResponseApplySnapshotChunkProtoMsg;
+        };
+        ResponsePrepareProposal: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponsePrepareProposal;
+            isSDK(o: any): o is _132.ResponsePrepareProposalSDKType;
+            isAmino(o: any): o is _132.ResponsePrepareProposalAmino;
+            encode(message: _132.ResponsePrepareProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponsePrepareProposal;
+            fromJSON(object: any): _132.ResponsePrepareProposal;
+            toJSON(message: _132.ResponsePrepareProposal): import("..").JsonSafe<_132.ResponsePrepareProposal>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponsePrepareProposal>, I>>(object: I): _132.ResponsePrepareProposal;
+            fromAmino(object: _132.ResponsePrepareProposalAmino): _132.ResponsePrepareProposal;
+            toAmino(message: _132.ResponsePrepareProposal): _132.ResponsePrepareProposalAmino;
+            fromAminoMsg(object: _132.ResponsePrepareProposalAminoMsg): _132.ResponsePrepareProposal;
+            fromProtoMsg(message: _132.ResponsePrepareProposalProtoMsg): _132.ResponsePrepareProposal;
+            toProto(message: _132.ResponsePrepareProposal): Uint8Array;
+            toProtoMsg(message: _132.ResponsePrepareProposal): _132.ResponsePrepareProposalProtoMsg;
+        };
+        ResponseProcessProposal: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseProcessProposal;
+            isSDK(o: any): o is _132.ResponseProcessProposalSDKType;
+            isAmino(o: any): o is _132.ResponseProcessProposalAmino;
+            encode(message: _132.ResponseProcessProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseProcessProposal;
+            fromJSON(object: any): _132.ResponseProcessProposal;
+            toJSON(message: _132.ResponseProcessProposal): import("..").JsonSafe<_132.ResponseProcessProposal>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseProcessProposal>, I>>(object: I): _132.ResponseProcessProposal;
+            fromAmino(object: _132.ResponseProcessProposalAmino): _132.ResponseProcessProposal;
+            toAmino(message: _132.ResponseProcessProposal): _132.ResponseProcessProposalAmino;
+            fromAminoMsg(object: _132.ResponseProcessProposalAminoMsg): _132.ResponseProcessProposal;
+            fromProtoMsg(message: _132.ResponseProcessProposalProtoMsg): _132.ResponseProcessProposal;
+            toProto(message: _132.ResponseProcessProposal): Uint8Array;
+            toProtoMsg(message: _132.ResponseProcessProposal): _132.ResponseProcessProposalProtoMsg;
+        };
+        ResponseExtendVote: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseExtendVote;
+            isSDK(o: any): o is _132.ResponseExtendVoteSDKType;
+            isAmino(o: any): o is _132.ResponseExtendVoteAmino;
+            encode(message: _132.ResponseExtendVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseExtendVote;
+            fromJSON(object: any): _132.ResponseExtendVote;
+            toJSON(message: _132.ResponseExtendVote): import("..").JsonSafe<_132.ResponseExtendVote>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseExtendVote>, I>>(object: I): _132.ResponseExtendVote;
+            fromAmino(object: _132.ResponseExtendVoteAmino): _132.ResponseExtendVote;
+            toAmino(message: _132.ResponseExtendVote): _132.ResponseExtendVoteAmino;
+            fromAminoMsg(object: _132.ResponseExtendVoteAminoMsg): _132.ResponseExtendVote;
+            fromProtoMsg(message: _132.ResponseExtendVoteProtoMsg): _132.ResponseExtendVote;
+            toProto(message: _132.ResponseExtendVote): Uint8Array;
+            toProtoMsg(message: _132.ResponseExtendVote): _132.ResponseExtendVoteProtoMsg;
+        };
+        ResponseVerifyVoteExtension: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseVerifyVoteExtension;
+            isSDK(o: any): o is _132.ResponseVerifyVoteExtensionSDKType;
+            isAmino(o: any): o is _132.ResponseVerifyVoteExtensionAmino;
+            encode(message: _132.ResponseVerifyVoteExtension, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseVerifyVoteExtension;
+            fromJSON(object: any): _132.ResponseVerifyVoteExtension;
+            toJSON(message: _132.ResponseVerifyVoteExtension): import("..").JsonSafe<_132.ResponseVerifyVoteExtension>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseVerifyVoteExtension>, I>>(object: I): _132.ResponseVerifyVoteExtension;
+            fromAmino(object: _132.ResponseVerifyVoteExtensionAmino): _132.ResponseVerifyVoteExtension;
+            toAmino(message: _132.ResponseVerifyVoteExtension): _132.ResponseVerifyVoteExtensionAmino;
+            fromAminoMsg(object: _132.ResponseVerifyVoteExtensionAminoMsg): _132.ResponseVerifyVoteExtension;
+            fromProtoMsg(message: _132.ResponseVerifyVoteExtensionProtoMsg): _132.ResponseVerifyVoteExtension;
+            toProto(message: _132.ResponseVerifyVoteExtension): Uint8Array;
+            toProtoMsg(message: _132.ResponseVerifyVoteExtension): _132.ResponseVerifyVoteExtensionProtoMsg;
+        };
+        ResponseFinalizeBlock: {
+            typeUrl: string;
+            is(o: any): o is _132.ResponseFinalizeBlock;
+            isSDK(o: any): o is _132.ResponseFinalizeBlockSDKType;
+            isAmino(o: any): o is _132.ResponseFinalizeBlockAmino;
+            encode(message: _132.ResponseFinalizeBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseFinalizeBlock;
+            fromJSON(object: any): _132.ResponseFinalizeBlock;
+            toJSON(message: _132.ResponseFinalizeBlock): import("..").JsonSafe<_132.ResponseFinalizeBlock>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ResponseFinalizeBlock>, I>>(object: I): _132.ResponseFinalizeBlock;
+            fromAmino(object: _132.ResponseFinalizeBlockAmino): _132.ResponseFinalizeBlock;
+            toAmino(message: _132.ResponseFinalizeBlock): _132.ResponseFinalizeBlockAmino;
+            fromAminoMsg(object: _132.ResponseFinalizeBlockAminoMsg): _132.ResponseFinalizeBlock;
+            fromProtoMsg(message: _132.ResponseFinalizeBlockProtoMsg): _132.ResponseFinalizeBlock;
+            toProto(message: _132.ResponseFinalizeBlock): Uint8Array;
+            toProtoMsg(message: _132.ResponseFinalizeBlock): _132.ResponseFinalizeBlockProtoMsg;
+        };
+        CommitInfo: {
+            typeUrl: string;
+            is(o: any): o is _132.CommitInfo;
+            isSDK(o: any): o is _132.CommitInfoSDKType;
+            isAmino(o: any): o is _132.CommitInfoAmino;
+            encode(message: _132.CommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.CommitInfo;
+            fromJSON(object: any): _132.CommitInfo;
+            toJSON(message: _132.CommitInfo): import("..").JsonSafe<_132.CommitInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.CommitInfo>, I>>(object: I): _132.CommitInfo;
+            fromAmino(object: _132.CommitInfoAmino): _132.CommitInfo;
+            toAmino(message: _132.CommitInfo): _132.CommitInfoAmino;
+            fromAminoMsg(object: _132.CommitInfoAminoMsg): _132.CommitInfo;
+            fromProtoMsg(message: _132.CommitInfoProtoMsg): _132.CommitInfo;
+            toProto(message: _132.CommitInfo): Uint8Array;
+            toProtoMsg(message: _132.CommitInfo): _132.CommitInfoProtoMsg;
+        };
+        ExtendedCommitInfo: {
+            typeUrl: string;
+            is(o: any): o is _132.ExtendedCommitInfo;
+            isSDK(o: any): o is _132.ExtendedCommitInfoSDKType;
+            isAmino(o: any): o is _132.ExtendedCommitInfoAmino;
+            encode(message: _132.ExtendedCommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ExtendedCommitInfo;
+            fromJSON(object: any): _132.ExtendedCommitInfo;
+            toJSON(message: _132.ExtendedCommitInfo): import("..").JsonSafe<_132.ExtendedCommitInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ExtendedCommitInfo>, I>>(object: I): _132.ExtendedCommitInfo;
+            fromAmino(object: _132.ExtendedCommitInfoAmino): _132.ExtendedCommitInfo;
+            toAmino(message: _132.ExtendedCommitInfo): _132.ExtendedCommitInfoAmino;
+            fromAminoMsg(object: _132.ExtendedCommitInfoAminoMsg): _132.ExtendedCommitInfo;
+            fromProtoMsg(message: _132.ExtendedCommitInfoProtoMsg): _132.ExtendedCommitInfo;
+            toProto(message: _132.ExtendedCommitInfo): Uint8Array;
+            toProtoMsg(message: _132.ExtendedCommitInfo): _132.ExtendedCommitInfoProtoMsg;
+        };
+        Event: {
+            typeUrl: string;
+            is(o: any): o is _132.Event;
+            isSDK(o: any): o is _132.EventSDKType;
+            isAmino(o: any): o is _132.EventAmino;
+            encode(message: _132.Event, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Event;
+            fromJSON(object: any): _132.Event;
+            toJSON(message: _132.Event): import("..").JsonSafe<_132.Event>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.Event>, I>>(object: I): _132.Event;
+            fromAmino(object: _132.EventAmino): _132.Event;
+            toAmino(message: _132.Event): _132.EventAmino;
+            fromAminoMsg(object: _132.EventAminoMsg): _132.Event;
+            fromProtoMsg(message: _132.EventProtoMsg): _132.Event;
+            toProto(message: _132.Event): Uint8Array;
+            toProtoMsg(message: _132.Event): _132.EventProtoMsg;
+        };
+        EventAttribute: {
+            typeUrl: string;
+            is(o: any): o is _132.EventAttribute;
+            isSDK(o: any): o is _132.EventAttributeSDKType;
+            isAmino(o: any): o is _132.EventAttributeAmino;
+            encode(message: _132.EventAttribute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.EventAttribute;
+            fromJSON(object: any): _132.EventAttribute;
+            toJSON(message: _132.EventAttribute): import("..").JsonSafe<_132.EventAttribute>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.EventAttribute>, I>>(object: I): _132.EventAttribute;
+            fromAmino(object: _132.EventAttributeAmino): _132.EventAttribute;
+            toAmino(message: _132.EventAttribute): _132.EventAttributeAmino;
+            fromAminoMsg(object: _132.EventAttributeAminoMsg): _132.EventAttribute;
+            fromProtoMsg(message: _132.EventAttributeProtoMsg): _132.EventAttribute;
+            toProto(message: _132.EventAttribute): Uint8Array;
+            toProtoMsg(message: _132.EventAttribute): _132.EventAttributeProtoMsg;
+        };
+        ExecTxResult: {
+            typeUrl: string;
+            is(o: any): o is _132.ExecTxResult;
+            isSDK(o: any): o is _132.ExecTxResultSDKType;
+            isAmino(o: any): o is _132.ExecTxResultAmino;
+            encode(message: _132.ExecTxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ExecTxResult;
+            fromJSON(object: any): _132.ExecTxResult;
+            toJSON(message: _132.ExecTxResult): import("..").JsonSafe<_132.ExecTxResult>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ExecTxResult>, I>>(object: I): _132.ExecTxResult;
+            fromAmino(object: _132.ExecTxResultAmino): _132.ExecTxResult;
+            toAmino(message: _132.ExecTxResult): _132.ExecTxResultAmino;
+            fromAminoMsg(object: _132.ExecTxResultAminoMsg): _132.ExecTxResult;
+            fromProtoMsg(message: _132.ExecTxResultProtoMsg): _132.ExecTxResult;
+            toProto(message: _132.ExecTxResult): Uint8Array;
+            toProtoMsg(message: _132.ExecTxResult): _132.ExecTxResultProtoMsg;
+        };
+        TxResult: {
+            typeUrl: string;
+            is(o: any): o is _132.TxResult;
+            isSDK(o: any): o is _132.TxResultSDKType;
+            isAmino(o: any): o is _132.TxResultAmino;
+            encode(message: _132.TxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.TxResult;
+            fromJSON(object: any): _132.TxResult;
+            toJSON(message: _132.TxResult): import("..").JsonSafe<_132.TxResult>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.TxResult>, I>>(object: I): _132.TxResult;
+            fromAmino(object: _132.TxResultAmino): _132.TxResult;
+            toAmino(message: _132.TxResult): _132.TxResultAmino;
+            fromAminoMsg(object: _132.TxResultAminoMsg): _132.TxResult;
+            fromProtoMsg(message: _132.TxResultProtoMsg): _132.TxResult;
+            toProto(message: _132.TxResult): Uint8Array;
+            toProtoMsg(message: _132.TxResult): _132.TxResultProtoMsg;
+        };
+        Validator: {
+            typeUrl: string;
+            is(o: any): o is _132.Validator;
+            isSDK(o: any): o is _132.ValidatorSDKType;
+            isAmino(o: any): o is _132.ValidatorAmino;
+            encode(message: _132.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Validator;
+            fromJSON(object: any): _132.Validator;
+            toJSON(message: _132.Validator): import("..").JsonSafe<_132.Validator>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.Validator>, I>>(object: I): _132.Validator;
+            fromAmino(object: _132.ValidatorAmino): _132.Validator;
+            toAmino(message: _132.Validator): _132.ValidatorAmino;
+            fromAminoMsg(object: _132.ValidatorAminoMsg): _132.Validator;
+            fromProtoMsg(message: _132.ValidatorProtoMsg): _132.Validator;
+            toProto(message: _132.Validator): Uint8Array;
+            toProtoMsg(message: _132.Validator): _132.ValidatorProtoMsg;
+        };
+        ValidatorUpdate: {
+            typeUrl: string;
+            is(o: any): o is _132.ValidatorUpdate;
+            isSDK(o: any): o is _132.ValidatorUpdateSDKType;
+            isAmino(o: any): o is _132.ValidatorUpdateAmino;
+            encode(message: _132.ValidatorUpdate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ValidatorUpdate;
+            fromJSON(object: any): _132.ValidatorUpdate;
+            toJSON(message: _132.ValidatorUpdate): import("..").JsonSafe<_132.ValidatorUpdate>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ValidatorUpdate>, I>>(object: I): _132.ValidatorUpdate;
+            fromAmino(object: _132.ValidatorUpdateAmino): _132.ValidatorUpdate;
+            toAmino(message: _132.ValidatorUpdate): _132.ValidatorUpdateAmino;
+            fromAminoMsg(object: _132.ValidatorUpdateAminoMsg): _132.ValidatorUpdate;
+            fromProtoMsg(message: _132.ValidatorUpdateProtoMsg): _132.ValidatorUpdate;
+            toProto(message: _132.ValidatorUpdate): Uint8Array;
+            toProtoMsg(message: _132.ValidatorUpdate): _132.ValidatorUpdateProtoMsg;
+        };
+        VoteInfo: {
+            typeUrl: string;
+            is(o: any): o is _132.VoteInfo;
+            isSDK(o: any): o is _132.VoteInfoSDKType;
+            isAmino(o: any): o is _132.VoteInfoAmino;
+            encode(message: _132.VoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.VoteInfo;
+            fromJSON(object: any): _132.VoteInfo;
+            toJSON(message: _132.VoteInfo): import("..").JsonSafe<_132.VoteInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.VoteInfo>, I>>(object: I): _132.VoteInfo;
+            fromAmino(object: _132.VoteInfoAmino): _132.VoteInfo;
+            toAmino(message: _132.VoteInfo): _132.VoteInfoAmino;
+            fromAminoMsg(object: _132.VoteInfoAminoMsg): _132.VoteInfo;
+            fromProtoMsg(message: _132.VoteInfoProtoMsg): _132.VoteInfo;
+            toProto(message: _132.VoteInfo): Uint8Array;
+            toProtoMsg(message: _132.VoteInfo): _132.VoteInfoProtoMsg;
+        };
+        ExtendedVoteInfo: {
+            typeUrl: string;
+            is(o: any): o is _132.ExtendedVoteInfo;
+            isSDK(o: any): o is _132.ExtendedVoteInfoSDKType;
+            isAmino(o: any): o is _132.ExtendedVoteInfoAmino;
+            encode(message: _132.ExtendedVoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ExtendedVoteInfo;
+            fromJSON(object: any): _132.ExtendedVoteInfo;
+            toJSON(message: _132.ExtendedVoteInfo): import("..").JsonSafe<_132.ExtendedVoteInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.ExtendedVoteInfo>, I>>(object: I): _132.ExtendedVoteInfo;
+            fromAmino(object: _132.ExtendedVoteInfoAmino): _132.ExtendedVoteInfo;
+            toAmino(message: _132.ExtendedVoteInfo): _132.ExtendedVoteInfoAmino;
+            fromAminoMsg(object: _132.ExtendedVoteInfoAminoMsg): _132.ExtendedVoteInfo;
+            fromProtoMsg(message: _132.ExtendedVoteInfoProtoMsg): _132.ExtendedVoteInfo;
+            toProto(message: _132.ExtendedVoteInfo): Uint8Array;
+            toProtoMsg(message: _132.ExtendedVoteInfo): _132.ExtendedVoteInfoProtoMsg;
+        };
+        Misbehavior: {
+            typeUrl: string;
+            is(o: any): o is _132.Misbehavior;
+            isSDK(o: any): o is _132.MisbehaviorSDKType;
+            isAmino(o: any): o is _132.MisbehaviorAmino;
+            encode(message: _132.Misbehavior, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Misbehavior;
+            fromJSON(object: any): _132.Misbehavior;
+            toJSON(message: _132.Misbehavior): import("..").JsonSafe<_132.Misbehavior>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.Misbehavior>, I>>(object: I): _132.Misbehavior;
+            fromAmino(object: _132.MisbehaviorAmino): _132.Misbehavior;
+            toAmino(message: _132.Misbehavior): _132.MisbehaviorAmino;
+            fromAminoMsg(object: _132.MisbehaviorAminoMsg): _132.Misbehavior;
+            fromProtoMsg(message: _132.MisbehaviorProtoMsg): _132.Misbehavior;
+            toProto(message: _132.Misbehavior): Uint8Array;
+            toProtoMsg(message: _132.Misbehavior): _132.MisbehaviorProtoMsg;
+        };
+        Snapshot: {
+            typeUrl: string;
+            is(o: any): o is _132.Snapshot;
+            isSDK(o: any): o is _132.SnapshotSDKType;
+            isAmino(o: any): o is _132.SnapshotAmino;
+            encode(message: _132.Snapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Snapshot;
+            fromJSON(object: any): _132.Snapshot;
+            toJSON(message: _132.Snapshot): import("..").JsonSafe<_132.Snapshot>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_132.Snapshot>, I>>(object: I): _132.Snapshot;
+            fromAmino(object: _132.SnapshotAmino): _132.Snapshot;
+            toAmino(message: _132.Snapshot): _132.SnapshotAmino;
+            fromAminoMsg(object: _132.SnapshotAminoMsg): _132.Snapshot;
+            fromProtoMsg(message: _132.SnapshotProtoMsg): _132.Snapshot;
+            toProto(message: _132.Snapshot): Uint8Array;
+            toProtoMsg(message: _132.Snapshot): _132.SnapshotProtoMsg;
+        };
+    };
+    const crypto: {
+        Proof: {
+            typeUrl: string;
+            is(o: any): o is _134.Proof;
+            isSDK(o: any): o is _134.ProofSDKType;
+            isAmino(o: any): o is _134.ProofAmino;
+            encode(message: _134.Proof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.Proof;
+            fromJSON(object: any): _134.Proof;
+            toJSON(message: _134.Proof): import("..").JsonSafe<_134.Proof>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_134.Proof>, I>>(object: I): _134.Proof;
+            fromAmino(object: _134.ProofAmino): _134.Proof;
+            toAmino(message: _134.Proof): _134.ProofAmino;
+            fromAminoMsg(object: _134.ProofAminoMsg): _134.Proof;
+            fromProtoMsg(message: _134.ProofProtoMsg): _134.Proof;
+            toProto(message: _134.Proof): Uint8Array;
+            toProtoMsg(message: _134.Proof): _134.ProofProtoMsg;
+        };
+        ValueOp: {
+            typeUrl: string;
+            is(o: any): o is _134.ValueOp;
+            isSDK(o: any): o is _134.ValueOpSDKType;
+            isAmino(o: any): o is _134.ValueOpAmino;
+            encode(message: _134.ValueOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.ValueOp;
+            fromJSON(object: any): _134.ValueOp;
+            toJSON(message: _134.ValueOp): import("..").JsonSafe<_134.ValueOp>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_134.ValueOp>, I>>(object: I): _134.ValueOp;
+            fromAmino(object: _134.ValueOpAmino): _134.ValueOp;
+            toAmino(message: _134.ValueOp): _134.ValueOpAmino;
+            fromAminoMsg(object: _134.ValueOpAminoMsg): _134.ValueOp;
+            fromProtoMsg(message: _134.ValueOpProtoMsg): _134.ValueOp;
+            toProto(message: _134.ValueOp): Uint8Array;
+            toProtoMsg(message: _134.ValueOp): _134.ValueOpProtoMsg;
+        };
+        DominoOp: {
+            typeUrl: string;
+            is(o: any): o is _134.DominoOp;
+            isSDK(o: any): o is _134.DominoOpSDKType;
+            isAmino(o: any): o is _134.DominoOpAmino;
+            encode(message: _134.DominoOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.DominoOp;
+            fromJSON(object: any): _134.DominoOp;
+            toJSON(message: _134.DominoOp): import("..").JsonSafe<_134.DominoOp>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_134.DominoOp>, I>>(object: I): _134.DominoOp;
+            fromAmino(object: _134.DominoOpAmino): _134.DominoOp;
+            toAmino(message: _134.DominoOp): _134.DominoOpAmino;
+            fromAminoMsg(object: _134.DominoOpAminoMsg): _134.DominoOp;
+            fromProtoMsg(message: _134.DominoOpProtoMsg): _134.DominoOp;
+            toProto(message: _134.DominoOp): Uint8Array;
+            toProtoMsg(message: _134.DominoOp): _134.DominoOpProtoMsg;
+        };
+        ProofOp: {
+            typeUrl: string;
+            is(o: any): o is _134.ProofOp;
+            isSDK(o: any): o is _134.ProofOpSDKType;
+            isAmino(o: any): o is _134.ProofOpAmino;
+            encode(message: _134.ProofOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.ProofOp;
+            fromJSON(object: any): _134.ProofOp;
+            toJSON(message: _134.ProofOp): import("..").JsonSafe<_134.ProofOp>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_134.ProofOp>, I>>(object: I): _134.ProofOp;
+            fromAmino(object: _134.ProofOpAmino): _134.ProofOp;
+            toAmino(message: _134.ProofOp): _134.ProofOpAmino;
+            fromAminoMsg(object: _134.ProofOpAminoMsg): _134.ProofOp;
+            fromProtoMsg(message: _134.ProofOpProtoMsg): _134.ProofOp;
+            toProto(message: _134.ProofOp): Uint8Array;
+            toProtoMsg(message: _134.ProofOp): _134.ProofOpProtoMsg;
+        };
+        ProofOps: {
+            typeUrl: string;
+            is(o: any): o is _134.ProofOps;
+            isSDK(o: any): o is _134.ProofOpsSDKType;
+            isAmino(o: any): o is _134.ProofOpsAmino;
+            encode(message: _134.ProofOps, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.ProofOps;
+            fromJSON(object: any): _134.ProofOps;
+            toJSON(message: _134.ProofOps): import("..").JsonSafe<_134.ProofOps>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_134.ProofOps>, I>>(object: I): _134.ProofOps;
+            fromAmino(object: _134.ProofOpsAmino): _134.ProofOps;
+            toAmino(message: _134.ProofOps): _134.ProofOpsAmino;
+            fromAminoMsg(object: _134.ProofOpsAminoMsg): _134.ProofOps;
+            fromProtoMsg(message: _134.ProofOpsProtoMsg): _134.ProofOps;
+            toProto(message: _134.ProofOps): Uint8Array;
+            toProtoMsg(message: _134.ProofOps): _134.ProofOpsProtoMsg;
+        };
+        PublicKey: {
+            typeUrl: string;
+            is(o: any): o is _133.PublicKey;
+            isSDK(o: any): o is _133.PublicKeySDKType;
+            isAmino(o: any): o is _133.PublicKeyAmino;
+            encode(message: _133.PublicKey, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _133.PublicKey;
+            fromJSON(object: any): _133.PublicKey;
+            toJSON(message: _133.PublicKey): import("..").JsonSafe<_133.PublicKey>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_133.PublicKey>, I>>(object: I): _133.PublicKey;
+            fromAmino(object: _133.PublicKeyAmino): _133.PublicKey;
+            toAmino(message: _133.PublicKey): _133.PublicKeyAmino;
+            fromAminoMsg(object: _133.PublicKeyAminoMsg): _133.PublicKey;
+            fromProtoMsg(message: _133.PublicKeyProtoMsg): _133.PublicKey;
+            toProto(message: _133.PublicKey): Uint8Array;
+            toProtoMsg(message: _133.PublicKey): _133.PublicKeyProtoMsg;
+        };
+    };
+    namespace libs {
+        const bits: {
+            BitArray: {
+                typeUrl: string;
+                is(o: any): o is _135.BitArray;
+                isSDK(o: any): o is _135.BitArraySDKType;
+                isAmino(o: any): o is _135.BitArrayAmino;
+                encode(message: _135.BitArray, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _135.BitArray;
+                fromJSON(object: any): _135.BitArray;
+                toJSON(message: _135.BitArray): import("..").JsonSafe<_135.BitArray>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_135.BitArray>, I>>(object: I): _135.BitArray;
+                fromAmino(object: _135.BitArrayAmino): _135.BitArray;
+                toAmino(message: _135.BitArray): _135.BitArrayAmino;
+                fromAminoMsg(object: _135.BitArrayAminoMsg): _135.BitArray;
+                fromProtoMsg(message: _135.BitArrayProtoMsg): _135.BitArray;
+                toProto(message: _135.BitArray): Uint8Array;
+                toProtoMsg(message: _135.BitArray): _135.BitArrayProtoMsg;
+            };
+        };
+    }
+    const p2p: {
+        NetAddress: {
+            typeUrl: string;
+            is(o: any): o is _136.NetAddress;
+            isSDK(o: any): o is _136.NetAddressSDKType;
+            isAmino(o: any): o is _136.NetAddressAmino;
+            encode(message: _136.NetAddress, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.NetAddress;
+            fromJSON(object: any): _136.NetAddress;
+            toJSON(message: _136.NetAddress): import("..").JsonSafe<_136.NetAddress>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_136.NetAddress>, I>>(object: I): _136.NetAddress;
+            fromAmino(object: _136.NetAddressAmino): _136.NetAddress;
+            toAmino(message: _136.NetAddress): _136.NetAddressAmino;
+            fromAminoMsg(object: _136.NetAddressAminoMsg): _136.NetAddress;
+            fromProtoMsg(message: _136.NetAddressProtoMsg): _136.NetAddress;
+            toProto(message: _136.NetAddress): Uint8Array;
+            toProtoMsg(message: _136.NetAddress): _136.NetAddressProtoMsg;
+        };
+        ProtocolVersion: {
+            typeUrl: string;
+            is(o: any): o is _136.ProtocolVersion;
+            isSDK(o: any): o is _136.ProtocolVersionSDKType;
+            isAmino(o: any): o is _136.ProtocolVersionAmino;
+            encode(message: _136.ProtocolVersion, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.ProtocolVersion;
+            fromJSON(object: any): _136.ProtocolVersion;
+            toJSON(message: _136.ProtocolVersion): import("..").JsonSafe<_136.ProtocolVersion>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_136.ProtocolVersion>, I>>(object: I): _136.ProtocolVersion;
+            fromAmino(object: _136.ProtocolVersionAmino): _136.ProtocolVersion;
+            toAmino(message: _136.ProtocolVersion): _136.ProtocolVersionAmino;
+            fromAminoMsg(object: _136.ProtocolVersionAminoMsg): _136.ProtocolVersion;
+            fromProtoMsg(message: _136.ProtocolVersionProtoMsg): _136.ProtocolVersion;
+            toProto(message: _136.ProtocolVersion): Uint8Array;
+            toProtoMsg(message: _136.ProtocolVersion): _136.ProtocolVersionProtoMsg;
+        };
+        DefaultNodeInfo: {
+            typeUrl: string;
+            is(o: any): o is _136.DefaultNodeInfo;
+            isSDK(o: any): o is _136.DefaultNodeInfoSDKType;
+            isAmino(o: any): o is _136.DefaultNodeInfoAmino;
+            encode(message: _136.DefaultNodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.DefaultNodeInfo;
+            fromJSON(object: any): _136.DefaultNodeInfo;
+            toJSON(message: _136.DefaultNodeInfo): import("..").JsonSafe<_136.DefaultNodeInfo>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_136.DefaultNodeInfo>, I>>(object: I): _136.DefaultNodeInfo;
+            fromAmino(object: _136.DefaultNodeInfoAmino): _136.DefaultNodeInfo;
+            toAmino(message: _136.DefaultNodeInfo): _136.DefaultNodeInfoAmino;
+            fromAminoMsg(object: _136.DefaultNodeInfoAminoMsg): _136.DefaultNodeInfo;
+            fromProtoMsg(message: _136.DefaultNodeInfoProtoMsg): _136.DefaultNodeInfo;
+            toProto(message: _136.DefaultNodeInfo): Uint8Array;
+            toProtoMsg(message: _136.DefaultNodeInfo): _136.DefaultNodeInfoProtoMsg;
+        };
+        DefaultNodeInfoOther: {
+            typeUrl: string;
+            is(o: any): o is _136.DefaultNodeInfoOther;
+            isSDK(o: any): o is _136.DefaultNodeInfoOtherSDKType;
+            isAmino(o: any): o is _136.DefaultNodeInfoOtherAmino;
+            encode(message: _136.DefaultNodeInfoOther, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.DefaultNodeInfoOther;
+            fromJSON(object: any): _136.DefaultNodeInfoOther;
+            toJSON(message: _136.DefaultNodeInfoOther): import("..").JsonSafe<_136.DefaultNodeInfoOther>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_136.DefaultNodeInfoOther>, I>>(object: I): _136.DefaultNodeInfoOther;
+            fromAmino(object: _136.DefaultNodeInfoOtherAmino): _136.DefaultNodeInfoOther;
+            toAmino(message: _136.DefaultNodeInfoOther): _136.DefaultNodeInfoOtherAmino;
+            fromAminoMsg(object: _136.DefaultNodeInfoOtherAminoMsg): _136.DefaultNodeInfoOther;
+            fromProtoMsg(message: _136.DefaultNodeInfoOtherProtoMsg): _136.DefaultNodeInfoOther;
+            toProto(message: _136.DefaultNodeInfoOther): Uint8Array;
+            toProtoMsg(message: _136.DefaultNodeInfoOther): _136.DefaultNodeInfoOtherProtoMsg;
+        };
+    };
+    const types: {
+        blockIDFlagFromJSON(object: any): _141.BlockIDFlag;
+        blockIDFlagToJSON(object: _141.BlockIDFlag): string;
+        BlockIDFlag: typeof _141.BlockIDFlag;
+        BlockIDFlagSDKType: typeof _141.BlockIDFlag;
+        BlockIDFlagAmino: typeof _141.BlockIDFlag;
+        ValidatorSet: {
+            typeUrl: string;
+            is(o: any): o is _141.ValidatorSet;
+            isSDK(o: any): o is _141.ValidatorSetSDKType;
+            isAmino(o: any): o is _141.ValidatorSetAmino;
+            encode(message: _141.ValidatorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _141.ValidatorSet;
+            fromJSON(object: any): _141.ValidatorSet;
+            toJSON(message: _141.ValidatorSet): import("..").JsonSafe<_141.ValidatorSet>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_141.ValidatorSet>, I>>(object: I): _141.ValidatorSet;
+            fromAmino(object: _141.ValidatorSetAmino): _141.ValidatorSet;
+            toAmino(message: _141.ValidatorSet): _141.ValidatorSetAmino;
+            fromAminoMsg(object: _141.ValidatorSetAminoMsg): _141.ValidatorSet;
+            fromProtoMsg(message: _141.ValidatorSetProtoMsg): _141.ValidatorSet;
+            toProto(message: _141.ValidatorSet): Uint8Array;
+            toProtoMsg(message: _141.ValidatorSet): _141.ValidatorSetProtoMsg;
+        };
+        Validator: {
+            typeUrl: string;
+            is(o: any): o is _141.Validator;
+            isSDK(o: any): o is _141.ValidatorSDKType;
+            isAmino(o: any): o is _141.ValidatorAmino;
+            encode(message: _141.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _141.Validator;
+            fromJSON(object: any): _141.Validator;
+            toJSON(message: _141.Validator): import("..").JsonSafe<_141.Validator>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_141.Validator>, I>>(object: I): _141.Validator;
+            fromAmino(object: _141.ValidatorAmino): _141.Validator;
+            toAmino(message: _141.Validator): _141.ValidatorAmino;
+            fromAminoMsg(object: _141.ValidatorAminoMsg): _141.Validator;
+            fromProtoMsg(message: _141.ValidatorProtoMsg): _141.Validator;
+            toProto(message: _141.Validator): Uint8Array;
+            toProtoMsg(message: _141.Validator): _141.ValidatorProtoMsg;
+        };
+        SimpleValidator: {
+            typeUrl: string;
+            is(o: any): o is _141.SimpleValidator;
+            isSDK(o: any): o is _141.SimpleValidatorSDKType;
+            isAmino(o: any): o is _141.SimpleValidatorAmino;
+            encode(message: _141.SimpleValidator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _141.SimpleValidator;
+            fromJSON(object: any): _141.SimpleValidator;
+            toJSON(message: _141.SimpleValidator): import("..").JsonSafe<_141.SimpleValidator>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_141.SimpleValidator>, I>>(object: I): _141.SimpleValidator;
+            fromAmino(object: _141.SimpleValidatorAmino): _141.SimpleValidator;
+            toAmino(message: _141.SimpleValidator): _141.SimpleValidatorAmino;
+            fromAminoMsg(object: _141.SimpleValidatorAminoMsg): _141.SimpleValidator;
+            fromProtoMsg(message: _141.SimpleValidatorProtoMsg): _141.SimpleValidator;
+            toProto(message: _141.SimpleValidator): Uint8Array;
+            toProtoMsg(message: _141.SimpleValidator): _141.SimpleValidatorProtoMsg;
+        };
+        signedMsgTypeFromJSON(object: any): _140.SignedMsgType;
+        signedMsgTypeToJSON(object: _140.SignedMsgType): string;
+        SignedMsgType: typeof _140.SignedMsgType;
+        SignedMsgTypeSDKType: typeof _140.SignedMsgType;
+        SignedMsgTypeAmino: typeof _140.SignedMsgType;
+        PartSetHeader: {
+            typeUrl: string;
+            is(o: any): o is _140.PartSetHeader;
+            isSDK(o: any): o is _140.PartSetHeaderSDKType;
+            isAmino(o: any): o is _140.PartSetHeaderAmino;
+            encode(message: _140.PartSetHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.PartSetHeader;
+            fromJSON(object: any): _140.PartSetHeader;
+            toJSON(message: _140.PartSetHeader): import("..").JsonSafe<_140.PartSetHeader>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.PartSetHeader>, I>>(object: I): _140.PartSetHeader;
+            fromAmino(object: _140.PartSetHeaderAmino): _140.PartSetHeader;
+            toAmino(message: _140.PartSetHeader): _140.PartSetHeaderAmino;
+            fromAminoMsg(object: _140.PartSetHeaderAminoMsg): _140.PartSetHeader;
+            fromProtoMsg(message: _140.PartSetHeaderProtoMsg): _140.PartSetHeader;
+            toProto(message: _140.PartSetHeader): Uint8Array;
+            toProtoMsg(message: _140.PartSetHeader): _140.PartSetHeaderProtoMsg;
+        };
+        Part: {
+            typeUrl: string;
+            is(o: any): o is _140.Part;
+            isSDK(o: any): o is _140.PartSDKType;
+            isAmino(o: any): o is _140.PartAmino;
+            encode(message: _140.Part, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Part;
+            fromJSON(object: any): _140.Part;
+            toJSON(message: _140.Part): import("..").JsonSafe<_140.Part>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.Part>, I>>(object: I): _140.Part;
+            fromAmino(object: _140.PartAmino): _140.Part;
+            toAmino(message: _140.Part): _140.PartAmino;
+            fromAminoMsg(object: _140.PartAminoMsg): _140.Part;
+            fromProtoMsg(message: _140.PartProtoMsg): _140.Part;
+            toProto(message: _140.Part): Uint8Array;
+            toProtoMsg(message: _140.Part): _140.PartProtoMsg;
+        };
+        BlockID: {
+            typeUrl: string;
+            is(o: any): o is _140.BlockID;
+            isSDK(o: any): o is _140.BlockIDSDKType;
+            isAmino(o: any): o is _140.BlockIDAmino;
+            encode(message: _140.BlockID, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.BlockID;
+            fromJSON(object: any): _140.BlockID;
+            toJSON(message: _140.BlockID): import("..").JsonSafe<_140.BlockID>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.BlockID>, I>>(object: I): _140.BlockID;
+            fromAmino(object: _140.BlockIDAmino): _140.BlockID;
+            toAmino(message: _140.BlockID): _140.BlockIDAmino;
+            fromAminoMsg(object: _140.BlockIDAminoMsg): _140.BlockID;
+            fromProtoMsg(message: _140.BlockIDProtoMsg): _140.BlockID;
+            toProto(message: _140.BlockID): Uint8Array;
+            toProtoMsg(message: _140.BlockID): _140.BlockIDProtoMsg;
+        };
+        Header: {
+            typeUrl: string;
+            is(o: any): o is _140.Header;
+            isSDK(o: any): o is _140.HeaderSDKType;
+            isAmino(o: any): o is _140.HeaderAmino;
+            encode(message: _140.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Header;
+            fromJSON(object: any): _140.Header;
+            toJSON(message: _140.Header): import("..").JsonSafe<_140.Header>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.Header>, I>>(object: I): _140.Header;
+            fromAmino(object: _140.HeaderAmino): _140.Header;
+            toAmino(message: _140.Header): _140.HeaderAmino;
+            fromAminoMsg(object: _140.HeaderAminoMsg): _140.Header;
+            fromProtoMsg(message: _140.HeaderProtoMsg): _140.Header;
+            toProto(message: _140.Header): Uint8Array;
+            toProtoMsg(message: _140.Header): _140.HeaderProtoMsg;
+        };
+        Data: {
+            typeUrl: string;
+            is(o: any): o is _140.Data;
+            isSDK(o: any): o is _140.DataSDKType;
+            isAmino(o: any): o is _140.DataAmino;
+            encode(message: _140.Data, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Data;
+            fromJSON(object: any): _140.Data;
+            toJSON(message: _140.Data): import("..").JsonSafe<_140.Data>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.Data>, I>>(object: I): _140.Data;
+            fromAmino(object: _140.DataAmino): _140.Data;
+            toAmino(message: _140.Data): _140.DataAmino;
+            fromAminoMsg(object: _140.DataAminoMsg): _140.Data;
+            fromProtoMsg(message: _140.DataProtoMsg): _140.Data;
+            toProto(message: _140.Data): Uint8Array;
+            toProtoMsg(message: _140.Data): _140.DataProtoMsg;
+        };
+        Vote: {
+            typeUrl: string;
+            is(o: any): o is _140.Vote;
+            isSDK(o: any): o is _140.VoteSDKType;
+            isAmino(o: any): o is _140.VoteAmino;
+            encode(message: _140.Vote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Vote;
+            fromJSON(object: any): _140.Vote;
+            toJSON(message: _140.Vote): import("..").JsonSafe<_140.Vote>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.Vote>, I>>(object: I): _140.Vote;
+            fromAmino(object: _140.VoteAmino): _140.Vote;
+            toAmino(message: _140.Vote): _140.VoteAmino;
+            fromAminoMsg(object: _140.VoteAminoMsg): _140.Vote;
+            fromProtoMsg(message: _140.VoteProtoMsg): _140.Vote;
+            toProto(message: _140.Vote): Uint8Array;
+            toProtoMsg(message: _140.Vote): _140.VoteProtoMsg;
+        };
+        Commit: {
+            typeUrl: string;
+            is(o: any): o is _140.Commit;
+            isSDK(o: any): o is _140.CommitSDKType;
+            isAmino(o: any): o is _140.CommitAmino;
+            encode(message: _140.Commit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Commit;
+            fromJSON(object: any): _140.Commit;
+            toJSON(message: _140.Commit): import("..").JsonSafe<_140.Commit>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.Commit>, I>>(object: I): _140.Commit;
+            fromAmino(object: _140.CommitAmino): _140.Commit;
+            toAmino(message: _140.Commit): _140.CommitAmino;
+            fromAminoMsg(object: _140.CommitAminoMsg): _140.Commit;
+            fromProtoMsg(message: _140.CommitProtoMsg): _140.Commit;
+            toProto(message: _140.Commit): Uint8Array;
+            toProtoMsg(message: _140.Commit): _140.CommitProtoMsg;
+        };
+        CommitSig: {
+            typeUrl: string;
+            is(o: any): o is _140.CommitSig;
+            isSDK(o: any): o is _140.CommitSigSDKType;
+            isAmino(o: any): o is _140.CommitSigAmino;
+            encode(message: _140.CommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.CommitSig;
+            fromJSON(object: any): _140.CommitSig;
+            toJSON(message: _140.CommitSig): import("..").JsonSafe<_140.CommitSig>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.CommitSig>, I>>(object: I): _140.CommitSig;
+            fromAmino(object: _140.CommitSigAmino): _140.CommitSig;
+            toAmino(message: _140.CommitSig): _140.CommitSigAmino;
+            fromAminoMsg(object: _140.CommitSigAminoMsg): _140.CommitSig;
+            fromProtoMsg(message: _140.CommitSigProtoMsg): _140.CommitSig;
+            toProto(message: _140.CommitSig): Uint8Array;
+            toProtoMsg(message: _140.CommitSig): _140.CommitSigProtoMsg;
+        };
+        ExtendedCommit: {
+            typeUrl: string;
+            is(o: any): o is _140.ExtendedCommit;
+            isSDK(o: any): o is _140.ExtendedCommitSDKType;
+            isAmino(o: any): o is _140.ExtendedCommitAmino;
+            encode(message: _140.ExtendedCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.ExtendedCommit;
+            fromJSON(object: any): _140.ExtendedCommit;
+            toJSON(message: _140.ExtendedCommit): import("..").JsonSafe<_140.ExtendedCommit>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.ExtendedCommit>, I>>(object: I): _140.ExtendedCommit;
+            fromAmino(object: _140.ExtendedCommitAmino): _140.ExtendedCommit;
+            toAmino(message: _140.ExtendedCommit): _140.ExtendedCommitAmino;
+            fromAminoMsg(object: _140.ExtendedCommitAminoMsg): _140.ExtendedCommit;
+            fromProtoMsg(message: _140.ExtendedCommitProtoMsg): _140.ExtendedCommit;
+            toProto(message: _140.ExtendedCommit): Uint8Array;
+            toProtoMsg(message: _140.ExtendedCommit): _140.ExtendedCommitProtoMsg;
+        };
+        ExtendedCommitSig: {
+            typeUrl: string;
+            is(o: any): o is _140.ExtendedCommitSig;
+            isSDK(o: any): o is _140.ExtendedCommitSigSDKType;
+            isAmino(o: any): o is _140.ExtendedCommitSigAmino;
+            encode(message: _140.ExtendedCommitSig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.ExtendedCommitSig;
+            fromJSON(object: any): _140.ExtendedCommitSig;
+            toJSON(message: _140.ExtendedCommitSig): import("..").JsonSafe<_140.ExtendedCommitSig>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.ExtendedCommitSig>, I>>(object: I): _140.ExtendedCommitSig;
+            fromAmino(object: _140.ExtendedCommitSigAmino): _140.ExtendedCommitSig;
+            toAmino(message: _140.ExtendedCommitSig): _140.ExtendedCommitSigAmino;
+            fromAminoMsg(object: _140.ExtendedCommitSigAminoMsg): _140.ExtendedCommitSig;
+            fromProtoMsg(message: _140.ExtendedCommitSigProtoMsg): _140.ExtendedCommitSig;
+            toProto(message: _140.ExtendedCommitSig): Uint8Array;
+            toProtoMsg(message: _140.ExtendedCommitSig): _140.ExtendedCommitSigProtoMsg;
+        };
+        Proposal: {
+            typeUrl: string;
+            is(o: any): o is _140.Proposal;
+            isSDK(o: any): o is _140.ProposalSDKType;
+            isAmino(o: any): o is _140.ProposalAmino;
+            encode(message: _140.Proposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Proposal;
+            fromJSON(object: any): _140.Proposal;
+            toJSON(message: _140.Proposal): import("..").JsonSafe<_140.Proposal>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.Proposal>, I>>(object: I): _140.Proposal;
+            fromAmino(object: _140.ProposalAmino): _140.Proposal;
+            toAmino(message: _140.Proposal): _140.ProposalAmino;
+            fromAminoMsg(object: _140.ProposalAminoMsg): _140.Proposal;
+            fromProtoMsg(message: _140.ProposalProtoMsg): _140.Proposal;
+            toProto(message: _140.Proposal): Uint8Array;
+            toProtoMsg(message: _140.Proposal): _140.ProposalProtoMsg;
+        };
+        SignedHeader: {
+            typeUrl: string;
+            is(o: any): o is _140.SignedHeader;
+            isSDK(o: any): o is _140.SignedHeaderSDKType;
+            isAmino(o: any): o is _140.SignedHeaderAmino;
+            encode(message: _140.SignedHeader, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.SignedHeader;
+            fromJSON(object: any): _140.SignedHeader;
+            toJSON(message: _140.SignedHeader): import("..").JsonSafe<_140.SignedHeader>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.SignedHeader>, I>>(object: I): _140.SignedHeader;
+            fromAmino(object: _140.SignedHeaderAmino): _140.SignedHeader;
+            toAmino(message: _140.SignedHeader): _140.SignedHeaderAmino;
+            fromAminoMsg(object: _140.SignedHeaderAminoMsg): _140.SignedHeader;
+            fromProtoMsg(message: _140.SignedHeaderProtoMsg): _140.SignedHeader;
+            toProto(message: _140.SignedHeader): Uint8Array;
+            toProtoMsg(message: _140.SignedHeader): _140.SignedHeaderProtoMsg;
+        };
+        LightBlock: {
+            typeUrl: string;
+            is(o: any): o is _140.LightBlock;
+            isSDK(o: any): o is _140.LightBlockSDKType;
+            isAmino(o: any): o is _140.LightBlockAmino;
+            encode(message: _140.LightBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.LightBlock;
+            fromJSON(object: any): _140.LightBlock;
+            toJSON(message: _140.LightBlock): import("..").JsonSafe<_140.LightBlock>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.LightBlock>, I>>(object: I): _140.LightBlock;
+            fromAmino(object: _140.LightBlockAmino): _140.LightBlock;
+            toAmino(message: _140.LightBlock): _140.LightBlockAmino;
+            fromAminoMsg(object: _140.LightBlockAminoMsg): _140.LightBlock;
+            fromProtoMsg(message: _140.LightBlockProtoMsg): _140.LightBlock;
+            toProto(message: _140.LightBlock): Uint8Array;
+            toProtoMsg(message: _140.LightBlock): _140.LightBlockProtoMsg;
+        };
+        BlockMeta: {
+            typeUrl: string;
+            is(o: any): o is _140.BlockMeta;
+            isSDK(o: any): o is _140.BlockMetaSDKType;
+            isAmino(o: any): o is _140.BlockMetaAmino;
+            encode(message: _140.BlockMeta, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.BlockMeta;
+            fromJSON(object: any): _140.BlockMeta;
+            toJSON(message: _140.BlockMeta): import("..").JsonSafe<_140.BlockMeta>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.BlockMeta>, I>>(object: I): _140.BlockMeta;
+            fromAmino(object: _140.BlockMetaAmino): _140.BlockMeta;
+            toAmino(message: _140.BlockMeta): _140.BlockMetaAmino;
+            fromAminoMsg(object: _140.BlockMetaAminoMsg): _140.BlockMeta;
+            fromProtoMsg(message: _140.BlockMetaProtoMsg): _140.BlockMeta;
+            toProto(message: _140.BlockMeta): Uint8Array;
+            toProtoMsg(message: _140.BlockMeta): _140.BlockMetaProtoMsg;
+        };
+        TxProof: {
+            typeUrl: string;
+            is(o: any): o is _140.TxProof;
+            isSDK(o: any): o is _140.TxProofSDKType;
+            isAmino(o: any): o is _140.TxProofAmino;
+            encode(message: _140.TxProof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.TxProof;
+            fromJSON(object: any): _140.TxProof;
+            toJSON(message: _140.TxProof): import("..").JsonSafe<_140.TxProof>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_140.TxProof>, I>>(object: I): _140.TxProof;
+            fromAmino(object: _140.TxProofAmino): _140.TxProof;
+            toAmino(message: _140.TxProof): _140.TxProofAmino;
+            fromAminoMsg(object: _140.TxProofAminoMsg): _140.TxProof;
+            fromProtoMsg(message: _140.TxProofProtoMsg): _140.TxProof;
+            toProto(message: _140.TxProof): Uint8Array;
+            toProtoMsg(message: _140.TxProof): _140.TxProofProtoMsg;
+        };
+        ConsensusParams: {
+            typeUrl: string;
+            is(o: any): o is _139.ConsensusParams;
+            isSDK(o: any): o is _139.ConsensusParamsSDKType;
+            isAmino(o: any): o is _139.ConsensusParamsAmino;
+            encode(message: _139.ConsensusParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.ConsensusParams;
+            fromJSON(object: any): _139.ConsensusParams;
+            toJSON(message: _139.ConsensusParams): import("..").JsonSafe<_139.ConsensusParams>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_139.ConsensusParams>, I>>(object: I): _139.ConsensusParams;
+            fromAmino(object: _139.ConsensusParamsAmino): _139.ConsensusParams;
+            toAmino(message: _139.ConsensusParams): _139.ConsensusParamsAmino;
+            fromAminoMsg(object: _139.ConsensusParamsAminoMsg): _139.ConsensusParams;
+            fromProtoMsg(message: _139.ConsensusParamsProtoMsg): _139.ConsensusParams;
+            toProto(message: _139.ConsensusParams): Uint8Array;
+            toProtoMsg(message: _139.ConsensusParams): _139.ConsensusParamsProtoMsg;
+        };
+        BlockParams: {
+            typeUrl: string;
+            is(o: any): o is _139.BlockParams;
+            isSDK(o: any): o is _139.BlockParamsSDKType;
+            isAmino(o: any): o is _139.BlockParamsAmino;
+            encode(message: _139.BlockParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.BlockParams;
+            fromJSON(object: any): _139.BlockParams;
+            toJSON(message: _139.BlockParams): import("..").JsonSafe<_139.BlockParams>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_139.BlockParams>, I>>(object: I): _139.BlockParams;
+            fromAmino(object: _139.BlockParamsAmino): _139.BlockParams;
+            toAmino(message: _139.BlockParams): _139.BlockParamsAmino;
+            fromAminoMsg(object: _139.BlockParamsAminoMsg): _139.BlockParams;
+            fromProtoMsg(message: _139.BlockParamsProtoMsg): _139.BlockParams;
+            toProto(message: _139.BlockParams): Uint8Array;
+            toProtoMsg(message: _139.BlockParams): _139.BlockParamsProtoMsg;
+        };
+        EvidenceParams: {
+            typeUrl: string;
+            is(o: any): o is _139.EvidenceParams;
+            isSDK(o: any): o is _139.EvidenceParamsSDKType;
+            isAmino(o: any): o is _139.EvidenceParamsAmino;
+            encode(message: _139.EvidenceParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.EvidenceParams;
+            fromJSON(object: any): _139.EvidenceParams;
+            toJSON(message: _139.EvidenceParams): import("..").JsonSafe<_139.EvidenceParams>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_139.EvidenceParams>, I>>(object: I): _139.EvidenceParams;
+            fromAmino(object: _139.EvidenceParamsAmino): _139.EvidenceParams;
+            toAmino(message: _139.EvidenceParams): _139.EvidenceParamsAmino;
+            fromAminoMsg(object: _139.EvidenceParamsAminoMsg): _139.EvidenceParams;
+            fromProtoMsg(message: _139.EvidenceParamsProtoMsg): _139.EvidenceParams;
+            toProto(message: _139.EvidenceParams): Uint8Array;
+            toProtoMsg(message: _139.EvidenceParams): _139.EvidenceParamsProtoMsg;
+        };
+        ValidatorParams: {
+            typeUrl: string;
+            is(o: any): o is _139.ValidatorParams;
+            isSDK(o: any): o is _139.ValidatorParamsSDKType;
+            isAmino(o: any): o is _139.ValidatorParamsAmino;
+            encode(message: _139.ValidatorParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.ValidatorParams;
+            fromJSON(object: any): _139.ValidatorParams;
+            toJSON(message: _139.ValidatorParams): import("..").JsonSafe<_139.ValidatorParams>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_139.ValidatorParams>, I>>(object: I): _139.ValidatorParams;
+            fromAmino(object: _139.ValidatorParamsAmino): _139.ValidatorParams;
+            toAmino(message: _139.ValidatorParams): _139.ValidatorParamsAmino;
+            fromAminoMsg(object: _139.ValidatorParamsAminoMsg): _139.ValidatorParams;
+            fromProtoMsg(message: _139.ValidatorParamsProtoMsg): _139.ValidatorParams;
+            toProto(message: _139.ValidatorParams): Uint8Array;
+            toProtoMsg(message: _139.ValidatorParams): _139.ValidatorParamsProtoMsg;
+        };
+        VersionParams: {
+            typeUrl: string;
+            is(o: any): o is _139.VersionParams;
+            isSDK(o: any): o is _139.VersionParamsSDKType;
+            isAmino(o: any): o is _139.VersionParamsAmino;
+            encode(message: _139.VersionParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.VersionParams;
+            fromJSON(object: any): _139.VersionParams;
+            toJSON(message: _139.VersionParams): import("..").JsonSafe<_139.VersionParams>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_139.VersionParams>, I>>(object: I): _139.VersionParams;
+            fromAmino(object: _139.VersionParamsAmino): _139.VersionParams;
+            toAmino(message: _139.VersionParams): _139.VersionParamsAmino;
+            fromAminoMsg(object: _139.VersionParamsAminoMsg): _139.VersionParams;
+            fromProtoMsg(message: _139.VersionParamsProtoMsg): _139.VersionParams;
+            toProto(message: _139.VersionParams): Uint8Array;
+            toProtoMsg(message: _139.VersionParams): _139.VersionParamsProtoMsg;
+        };
+        HashedParams: {
+            typeUrl: string;
+            is(o: any): o is _139.HashedParams;
+            isSDK(o: any): o is _139.HashedParamsSDKType;
+            isAmino(o: any): o is _139.HashedParamsAmino;
+            encode(message: _139.HashedParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.HashedParams;
+            fromJSON(object: any): _139.HashedParams;
+            toJSON(message: _139.HashedParams): import("..").JsonSafe<_139.HashedParams>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_139.HashedParams>, I>>(object: I): _139.HashedParams;
+            fromAmino(object: _139.HashedParamsAmino): _139.HashedParams;
+            toAmino(message: _139.HashedParams): _139.HashedParamsAmino;
+            fromAminoMsg(object: _139.HashedParamsAminoMsg): _139.HashedParams;
+            fromProtoMsg(message: _139.HashedParamsProtoMsg): _139.HashedParams;
+            toProto(message: _139.HashedParams): Uint8Array;
+            toProtoMsg(message: _139.HashedParams): _139.HashedParamsProtoMsg;
+        };
+        ABCIParams: {
+            typeUrl: string;
+            is(o: any): o is _139.ABCIParams;
+            isSDK(o: any): o is _139.ABCIParamsSDKType;
+            isAmino(o: any): o is _139.ABCIParamsAmino;
+            encode(message: _139.ABCIParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.ABCIParams;
+            fromJSON(object: any): _139.ABCIParams;
+            toJSON(message: _139.ABCIParams): import("..").JsonSafe<_139.ABCIParams>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_139.ABCIParams>, I>>(object: I): _139.ABCIParams;
+            fromAmino(object: _139.ABCIParamsAmino): _139.ABCIParams;
+            toAmino(message: _139.ABCIParams): _139.ABCIParamsAmino;
+            fromAminoMsg(object: _139.ABCIParamsAminoMsg): _139.ABCIParams;
+            fromProtoMsg(message: _139.ABCIParamsProtoMsg): _139.ABCIParams;
+            toProto(message: _139.ABCIParams): Uint8Array;
+            toProtoMsg(message: _139.ABCIParams): _139.ABCIParamsProtoMsg;
+        };
+        Evidence: {
+            typeUrl: string;
+            is(o: any): o is _138.Evidence;
+            isSDK(o: any): o is _138.EvidenceSDKType;
+            isAmino(o: any): o is _138.EvidenceAmino;
+            encode(message: _138.Evidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _138.Evidence;
+            fromJSON(object: any): _138.Evidence;
+            toJSON(message: _138.Evidence): import("..").JsonSafe<_138.Evidence>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_138.Evidence>, I>>(object: I): _138.Evidence;
+            fromAmino(object: _138.EvidenceAmino): _138.Evidence;
+            toAmino(message: _138.Evidence): _138.EvidenceAmino;
+            fromAminoMsg(object: _138.EvidenceAminoMsg): _138.Evidence;
+            fromProtoMsg(message: _138.EvidenceProtoMsg): _138.Evidence;
+            toProto(message: _138.Evidence): Uint8Array;
+            toProtoMsg(message: _138.Evidence): _138.EvidenceProtoMsg;
+        };
+        DuplicateVoteEvidence: {
+            typeUrl: string;
+            is(o: any): o is _138.DuplicateVoteEvidence;
+            isSDK(o: any): o is _138.DuplicateVoteEvidenceSDKType;
+            isAmino(o: any): o is _138.DuplicateVoteEvidenceAmino;
+            encode(message: _138.DuplicateVoteEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _138.DuplicateVoteEvidence;
+            fromJSON(object: any): _138.DuplicateVoteEvidence;
+            toJSON(message: _138.DuplicateVoteEvidence): import("..").JsonSafe<_138.DuplicateVoteEvidence>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_138.DuplicateVoteEvidence>, I>>(object: I): _138.DuplicateVoteEvidence;
+            fromAmino(object: _138.DuplicateVoteEvidenceAmino): _138.DuplicateVoteEvidence;
+            toAmino(message: _138.DuplicateVoteEvidence): _138.DuplicateVoteEvidenceAmino;
+            fromAminoMsg(object: _138.DuplicateVoteEvidenceAminoMsg): _138.DuplicateVoteEvidence;
+            fromProtoMsg(message: _138.DuplicateVoteEvidenceProtoMsg): _138.DuplicateVoteEvidence;
+            toProto(message: _138.DuplicateVoteEvidence): Uint8Array;
+            toProtoMsg(message: _138.DuplicateVoteEvidence): _138.DuplicateVoteEvidenceProtoMsg;
+        };
+        LightClientAttackEvidence: {
+            typeUrl: string;
+            is(o: any): o is _138.LightClientAttackEvidence;
+            isSDK(o: any): o is _138.LightClientAttackEvidenceSDKType;
+            isAmino(o: any): o is _138.LightClientAttackEvidenceAmino;
+            encode(message: _138.LightClientAttackEvidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _138.LightClientAttackEvidence;
+            fromJSON(object: any): _138.LightClientAttackEvidence;
+            toJSON(message: _138.LightClientAttackEvidence): import("..").JsonSafe<_138.LightClientAttackEvidence>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_138.LightClientAttackEvidence>, I>>(object: I): _138.LightClientAttackEvidence;
+            fromAmino(object: _138.LightClientAttackEvidenceAmino): _138.LightClientAttackEvidence;
+            toAmino(message: _138.LightClientAttackEvidence): _138.LightClientAttackEvidenceAmino;
+            fromAminoMsg(object: _138.LightClientAttackEvidenceAminoMsg): _138.LightClientAttackEvidence;
+            fromProtoMsg(message: _138.LightClientAttackEvidenceProtoMsg): _138.LightClientAttackEvidence;
+            toProto(message: _138.LightClientAttackEvidence): Uint8Array;
+            toProtoMsg(message: _138.LightClientAttackEvidence): _138.LightClientAttackEvidenceProtoMsg;
+        };
+        EvidenceList: {
+            typeUrl: string;
+            is(o: any): o is _138.EvidenceList;
+            isSDK(o: any): o is _138.EvidenceListSDKType;
+            isAmino(o: any): o is _138.EvidenceListAmino;
+            encode(message: _138.EvidenceList, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _138.EvidenceList;
+            fromJSON(object: any): _138.EvidenceList;
+            toJSON(message: _138.EvidenceList): import("..").JsonSafe<_138.EvidenceList>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_138.EvidenceList>, I>>(object: I): _138.EvidenceList;
+            fromAmino(object: _138.EvidenceListAmino): _138.EvidenceList;
+            toAmino(message: _138.EvidenceList): _138.EvidenceListAmino;
+            fromAminoMsg(object: _138.EvidenceListAminoMsg): _138.EvidenceList;
+            fromProtoMsg(message: _138.EvidenceListProtoMsg): _138.EvidenceList;
+            toProto(message: _138.EvidenceList): Uint8Array;
+            toProtoMsg(message: _138.EvidenceList): _138.EvidenceListProtoMsg;
+        };
+        Block: {
+            typeUrl: string;
+            is(o: any): o is _137.Block;
+            isSDK(o: any): o is _137.BlockSDKType;
+            isAmino(o: any): o is _137.BlockAmino;
+            encode(message: _137.Block, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _137.Block;
+            fromJSON(object: any): _137.Block;
+            toJSON(message: _137.Block): import("..").JsonSafe<_137.Block>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_137.Block>, I>>(object: I): _137.Block;
+            fromAmino(object: _137.BlockAmino): _137.Block;
+            toAmino(message: _137.Block): _137.BlockAmino;
+            fromAminoMsg(object: _137.BlockAminoMsg): _137.Block;
+            fromProtoMsg(message: _137.BlockProtoMsg): _137.Block;
+            toProto(message: _137.Block): Uint8Array;
+            toProtoMsg(message: _137.Block): _137.BlockProtoMsg;
+        };
+    };
+    const version: {
+        App: {
+            typeUrl: string;
+            is(o: any): o is _142.App;
+            isSDK(o: any): o is _142.AppSDKType;
+            isAmino(o: any): o is _142.AppAmino;
+            encode(message: _142.App, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _142.App;
+            fromJSON(object: any): _142.App;
+            toJSON(message: _142.App): import("..").JsonSafe<_142.App>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_142.App>, I>>(object: I): _142.App;
+            fromAmino(object: _142.AppAmino): _142.App;
+            toAmino(message: _142.App): _142.AppAmino;
+            fromAminoMsg(object: _142.AppAminoMsg): _142.App;
+            fromProtoMsg(message: _142.AppProtoMsg): _142.App;
+            toProto(message: _142.App): Uint8Array;
+            toProtoMsg(message: _142.App): _142.AppProtoMsg;
+        };
+        Consensus: {
+            typeUrl: string;
+            is(o: any): o is _142.Consensus;
+            isSDK(o: any): o is _142.ConsensusSDKType;
+            isAmino(o: any): o is _142.ConsensusAmino;
+            encode(message: _142.Consensus, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _142.Consensus;
+            fromJSON(object: any): _142.Consensus;
+            toJSON(message: _142.Consensus): import("..").JsonSafe<_142.Consensus>;
+            fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_142.Consensus>, I>>(object: I): _142.Consensus;
+            fromAmino(object: _142.ConsensusAmino): _142.Consensus;
+            toAmino(message: _142.Consensus): _142.ConsensusAmino;
+            fromAminoMsg(object: _142.ConsensusAminoMsg): _142.Consensus;
+            fromProtoMsg(message: _142.ConsensusProtoMsg): _142.Consensus;
+            toProto(message: _142.Consensus): Uint8Array;
+            toProtoMsg(message: _142.Consensus): _142.ConsensusProtoMsg;
+        };
+    };
+}