@bandprotocol/bandchain.js
Version:
TypeScript library for Cosmos SDK and BandChain
737 lines (736 loc) • 71.7 kB
TypeScript
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;
evidenceTypeFromJSON(object: any): _132.EvidenceType;
evidenceTypeToJSON(object: _132.EvidenceType): 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;
EvidenceType: typeof _132.EvidenceType;
EvidenceTypeSDKType: typeof _132.EvidenceType;
EvidenceTypeAmino: typeof _132.EvidenceType;
Request: {
typeUrl: string;
encode(message: _132.Request, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Request;
fromPartial(object: Partial<_132.Request>): _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;
encode(message: _132.RequestEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestEcho;
fromPartial(object: Partial<_132.RequestEcho>): _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;
encode(_: _132.RequestFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestFlush;
fromPartial(_: Partial<_132.RequestFlush>): _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;
encode(message: _132.RequestInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestInfo;
fromPartial(object: Partial<_132.RequestInfo>): _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;
};
RequestSetOption: {
typeUrl: string;
encode(message: _132.RequestSetOption, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestSetOption;
fromPartial(object: Partial<_132.RequestSetOption>): _132.RequestSetOption;
fromAmino(object: _132.RequestSetOptionAmino): _132.RequestSetOption;
toAmino(message: _132.RequestSetOption): _132.RequestSetOptionAmino;
fromAminoMsg(object: _132.RequestSetOptionAminoMsg): _132.RequestSetOption;
fromProtoMsg(message: _132.RequestSetOptionProtoMsg): _132.RequestSetOption;
toProto(message: _132.RequestSetOption): Uint8Array;
toProtoMsg(message: _132.RequestSetOption): _132.RequestSetOptionProtoMsg;
};
RequestInitChain: {
typeUrl: string;
encode(message: _132.RequestInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestInitChain;
fromPartial(object: Partial<_132.RequestInitChain>): _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;
encode(message: _132.RequestQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestQuery;
fromPartial(object: Partial<_132.RequestQuery>): _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;
};
RequestBeginBlock: {
typeUrl: string;
encode(message: _132.RequestBeginBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestBeginBlock;
fromPartial(object: Partial<_132.RequestBeginBlock>): _132.RequestBeginBlock;
fromAmino(object: _132.RequestBeginBlockAmino): _132.RequestBeginBlock;
toAmino(message: _132.RequestBeginBlock): _132.RequestBeginBlockAmino;
fromAminoMsg(object: _132.RequestBeginBlockAminoMsg): _132.RequestBeginBlock;
fromProtoMsg(message: _132.RequestBeginBlockProtoMsg): _132.RequestBeginBlock;
toProto(message: _132.RequestBeginBlock): Uint8Array;
toProtoMsg(message: _132.RequestBeginBlock): _132.RequestBeginBlockProtoMsg;
};
RequestCheckTx: {
typeUrl: string;
encode(message: _132.RequestCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestCheckTx;
fromPartial(object: Partial<_132.RequestCheckTx>): _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;
};
RequestDeliverTx: {
typeUrl: string;
encode(message: _132.RequestDeliverTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestDeliverTx;
fromPartial(object: Partial<_132.RequestDeliverTx>): _132.RequestDeliverTx;
fromAmino(object: _132.RequestDeliverTxAmino): _132.RequestDeliverTx;
toAmino(message: _132.RequestDeliverTx): _132.RequestDeliverTxAmino;
fromAminoMsg(object: _132.RequestDeliverTxAminoMsg): _132.RequestDeliverTx;
fromProtoMsg(message: _132.RequestDeliverTxProtoMsg): _132.RequestDeliverTx;
toProto(message: _132.RequestDeliverTx): Uint8Array;
toProtoMsg(message: _132.RequestDeliverTx): _132.RequestDeliverTxProtoMsg;
};
RequestEndBlock: {
typeUrl: string;
encode(message: _132.RequestEndBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestEndBlock;
fromPartial(object: Partial<_132.RequestEndBlock>): _132.RequestEndBlock;
fromAmino(object: _132.RequestEndBlockAmino): _132.RequestEndBlock;
toAmino(message: _132.RequestEndBlock): _132.RequestEndBlockAmino;
fromAminoMsg(object: _132.RequestEndBlockAminoMsg): _132.RequestEndBlock;
fromProtoMsg(message: _132.RequestEndBlockProtoMsg): _132.RequestEndBlock;
toProto(message: _132.RequestEndBlock): Uint8Array;
toProtoMsg(message: _132.RequestEndBlock): _132.RequestEndBlockProtoMsg;
};
RequestCommit: {
typeUrl: string;
encode(_: _132.RequestCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestCommit;
fromPartial(_: Partial<_132.RequestCommit>): _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;
encode(_: _132.RequestListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestListSnapshots;
fromPartial(_: Partial<_132.RequestListSnapshots>): _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;
encode(message: _132.RequestOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestOfferSnapshot;
fromPartial(object: Partial<_132.RequestOfferSnapshot>): _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;
encode(message: _132.RequestLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestLoadSnapshotChunk;
fromPartial(object: Partial<_132.RequestLoadSnapshotChunk>): _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;
encode(message: _132.RequestApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.RequestApplySnapshotChunk;
fromPartial(object: Partial<_132.RequestApplySnapshotChunk>): _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;
};
Response: {
typeUrl: string;
encode(message: _132.Response, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Response;
fromPartial(object: Partial<_132.Response>): _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;
encode(message: _132.ResponseException, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseException;
fromPartial(object: Partial<_132.ResponseException>): _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;
encode(message: _132.ResponseEcho, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseEcho;
fromPartial(object: Partial<_132.ResponseEcho>): _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;
encode(_: _132.ResponseFlush, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseFlush;
fromPartial(_: Partial<_132.ResponseFlush>): _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;
encode(message: _132.ResponseInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseInfo;
fromPartial(object: Partial<_132.ResponseInfo>): _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;
};
ResponseSetOption: {
typeUrl: string;
encode(message: _132.ResponseSetOption, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseSetOption;
fromPartial(object: Partial<_132.ResponseSetOption>): _132.ResponseSetOption;
fromAmino(object: _132.ResponseSetOptionAmino): _132.ResponseSetOption;
toAmino(message: _132.ResponseSetOption): _132.ResponseSetOptionAmino;
fromAminoMsg(object: _132.ResponseSetOptionAminoMsg): _132.ResponseSetOption;
fromProtoMsg(message: _132.ResponseSetOptionProtoMsg): _132.ResponseSetOption;
toProto(message: _132.ResponseSetOption): Uint8Array;
toProtoMsg(message: _132.ResponseSetOption): _132.ResponseSetOptionProtoMsg;
};
ResponseInitChain: {
typeUrl: string;
encode(message: _132.ResponseInitChain, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseInitChain;
fromPartial(object: Partial<_132.ResponseInitChain>): _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;
encode(message: _132.ResponseQuery, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseQuery;
fromPartial(object: Partial<_132.ResponseQuery>): _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;
};
ResponseBeginBlock: {
typeUrl: string;
encode(message: _132.ResponseBeginBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseBeginBlock;
fromPartial(object: Partial<_132.ResponseBeginBlock>): _132.ResponseBeginBlock;
fromAmino(object: _132.ResponseBeginBlockAmino): _132.ResponseBeginBlock;
toAmino(message: _132.ResponseBeginBlock): _132.ResponseBeginBlockAmino;
fromAminoMsg(object: _132.ResponseBeginBlockAminoMsg): _132.ResponseBeginBlock;
fromProtoMsg(message: _132.ResponseBeginBlockProtoMsg): _132.ResponseBeginBlock;
toProto(message: _132.ResponseBeginBlock): Uint8Array;
toProtoMsg(message: _132.ResponseBeginBlock): _132.ResponseBeginBlockProtoMsg;
};
ResponseCheckTx: {
typeUrl: string;
encode(message: _132.ResponseCheckTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseCheckTx;
fromPartial(object: Partial<_132.ResponseCheckTx>): _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;
};
ResponseDeliverTx: {
typeUrl: string;
encode(message: _132.ResponseDeliverTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseDeliverTx;
fromPartial(object: Partial<_132.ResponseDeliverTx>): _132.ResponseDeliverTx;
fromAmino(object: _132.ResponseDeliverTxAmino): _132.ResponseDeliverTx;
toAmino(message: _132.ResponseDeliverTx): _132.ResponseDeliverTxAmino;
fromAminoMsg(object: _132.ResponseDeliverTxAminoMsg): _132.ResponseDeliverTx;
fromProtoMsg(message: _132.ResponseDeliverTxProtoMsg): _132.ResponseDeliverTx;
toProto(message: _132.ResponseDeliverTx): Uint8Array;
toProtoMsg(message: _132.ResponseDeliverTx): _132.ResponseDeliverTxProtoMsg;
};
ResponseEndBlock: {
typeUrl: string;
encode(message: _132.ResponseEndBlock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseEndBlock;
fromPartial(object: Partial<_132.ResponseEndBlock>): _132.ResponseEndBlock;
fromAmino(object: _132.ResponseEndBlockAmino): _132.ResponseEndBlock;
toAmino(message: _132.ResponseEndBlock): _132.ResponseEndBlockAmino;
fromAminoMsg(object: _132.ResponseEndBlockAminoMsg): _132.ResponseEndBlock;
fromProtoMsg(message: _132.ResponseEndBlockProtoMsg): _132.ResponseEndBlock;
toProto(message: _132.ResponseEndBlock): Uint8Array;
toProtoMsg(message: _132.ResponseEndBlock): _132.ResponseEndBlockProtoMsg;
};
ResponseCommit: {
typeUrl: string;
encode(message: _132.ResponseCommit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseCommit;
fromPartial(object: Partial<_132.ResponseCommit>): _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;
encode(message: _132.ResponseListSnapshots, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseListSnapshots;
fromPartial(object: Partial<_132.ResponseListSnapshots>): _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;
encode(message: _132.ResponseOfferSnapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseOfferSnapshot;
fromPartial(object: Partial<_132.ResponseOfferSnapshot>): _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;
encode(message: _132.ResponseLoadSnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseLoadSnapshotChunk;
fromPartial(object: Partial<_132.ResponseLoadSnapshotChunk>): _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;
encode(message: _132.ResponseApplySnapshotChunk, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ResponseApplySnapshotChunk;
fromPartial(object: Partial<_132.ResponseApplySnapshotChunk>): _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;
};
ConsensusParams: {
typeUrl: string;
encode(message: _132.ConsensusParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ConsensusParams;
fromPartial(object: Partial<_132.ConsensusParams>): _132.ConsensusParams;
fromAmino(object: _132.ConsensusParamsAmino): _132.ConsensusParams;
toAmino(message: _132.ConsensusParams): _132.ConsensusParamsAmino;
fromAminoMsg(object: _132.ConsensusParamsAminoMsg): _132.ConsensusParams;
fromProtoMsg(message: _132.ConsensusParamsProtoMsg): _132.ConsensusParams;
toProto(message: _132.ConsensusParams): Uint8Array;
toProtoMsg(message: _132.ConsensusParams): _132.ConsensusParamsProtoMsg;
};
BlockParams: {
typeUrl: string;
encode(message: _132.BlockParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.BlockParams;
fromPartial(object: Partial<_132.BlockParams>): _132.BlockParams;
fromAmino(object: _132.BlockParamsAmino): _132.BlockParams;
toAmino(message: _132.BlockParams): _132.BlockParamsAmino;
fromAminoMsg(object: _132.BlockParamsAminoMsg): _132.BlockParams;
fromProtoMsg(message: _132.BlockParamsProtoMsg): _132.BlockParams;
toProto(message: _132.BlockParams): Uint8Array;
toProtoMsg(message: _132.BlockParams): _132.BlockParamsProtoMsg;
};
LastCommitInfo: {
typeUrl: string;
encode(message: _132.LastCommitInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.LastCommitInfo;
fromPartial(object: Partial<_132.LastCommitInfo>): _132.LastCommitInfo;
fromAmino(object: _132.LastCommitInfoAmino): _132.LastCommitInfo;
toAmino(message: _132.LastCommitInfo): _132.LastCommitInfoAmino;
fromAminoMsg(object: _132.LastCommitInfoAminoMsg): _132.LastCommitInfo;
fromProtoMsg(message: _132.LastCommitInfoProtoMsg): _132.LastCommitInfo;
toProto(message: _132.LastCommitInfo): Uint8Array;
toProtoMsg(message: _132.LastCommitInfo): _132.LastCommitInfoProtoMsg;
};
Event: {
typeUrl: string;
encode(message: _132.Event, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Event;
fromPartial(object: Partial<_132.Event>): _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;
encode(message: _132.EventAttribute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.EventAttribute;
fromPartial(object: Partial<_132.EventAttribute>): _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;
};
TxResult: {
typeUrl: string;
encode(message: _132.TxResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.TxResult;
fromPartial(object: Partial<_132.TxResult>): _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;
encode(message: _132.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Validator;
fromPartial(object: Partial<_132.Validator>): _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;
encode(message: _132.ValidatorUpdate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.ValidatorUpdate;
fromPartial(object: Partial<_132.ValidatorUpdate>): _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;
encode(message: _132.VoteInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.VoteInfo;
fromPartial(object: Partial<_132.VoteInfo>): _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;
};
Evidence: {
typeUrl: string;
encode(message: _132.Evidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Evidence;
fromPartial(object: Partial<_132.Evidence>): _132.Evidence;
fromAmino(object: _132.EvidenceAmino): _132.Evidence;
toAmino(message: _132.Evidence): _132.EvidenceAmino;
fromAminoMsg(object: _132.EvidenceAminoMsg): _132.Evidence;
fromProtoMsg(message: _132.EvidenceProtoMsg): _132.Evidence;
toProto(message: _132.Evidence): Uint8Array;
toProtoMsg(message: _132.Evidence): _132.EvidenceProtoMsg;
};
Snapshot: {
typeUrl: string;
encode(message: _132.Snapshot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Snapshot;
fromPartial(object: Partial<_132.Snapshot>): _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;
encode(message: _134.Proof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.Proof;
fromPartial(object: Partial<_134.Proof>): _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;
encode(message: _134.ValueOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.ValueOp;
fromPartial(object: Partial<_134.ValueOp>): _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;
encode(message: _134.DominoOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.DominoOp;
fromPartial(object: Partial<_134.DominoOp>): _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;
encode(message: _134.ProofOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.ProofOp;
fromPartial(object: Partial<_134.ProofOp>): _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;
encode(message: _134.ProofOps, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.ProofOps;
fromPartial(object: Partial<_134.ProofOps>): _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;
encode(message: _133.PublicKey, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _133.PublicKey;
fromPartial(object: Partial<_133.PublicKey>): _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;
encode(message: _135.BitArray, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _135.BitArray;
fromPartial(object: Partial<_135.BitArray>): _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: {
ProtocolVersion: {
typeUrl: string;
encode(message: _136.ProtocolVersion, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.ProtocolVersion;
fromPartial(object: Partial<_136.ProtocolVersion>): _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;
};
NodeInfo: {
typeUrl: string;
encode(message: _136.NodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.NodeInfo;
fromPartial(object: Partial<_136.NodeInfo>): _136.NodeInfo;
fromAmino(object: _136.NodeInfoAmino): _136.NodeInfo;
toAmino(message: _136.NodeInfo): _136.NodeInfoAmino;
fromAminoMsg(object: _136.NodeInfoAminoMsg): _136.NodeInfo;
fromProtoMsg(message: _136.NodeInfoProtoMsg): _136.NodeInfo;
toProto(message: _136.NodeInfo): Uint8Array;
toProtoMsg(message: _136.NodeInfo): _136.NodeInfoProtoMsg;
};
NodeInfoOther: {
typeUrl: string;
encode(message: _136.NodeInfoOther, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.NodeInfoOther;
fromPartial(object: Partial<_136.NodeInfoOther>): _136.NodeInfoOther;
fromAmino(object: _136.NodeInfoOtherAmino): _136.NodeInfoOther;
toAmino(message: _136.NodeInfoOther): _136.NodeInfoOtherAmino;
fromAminoMsg(object: _136.NodeInfoOtherAminoMsg): _136.NodeInfoOther;
fromProtoMsg(message: _136.NodeInfoOtherProtoMsg): _136.NodeInfoOther;
toProto(message: _136.NodeInfoOther): Uint8Array;
toProtoMsg(message: _136.NodeInfoOther): _136.NodeInfoOtherProtoMsg;
};
PeerInfo: {
typeUrl: string;
encode(message: _136.PeerInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.PeerInfo;
fromPartial(object: Partial<_136.PeerInfo>): _136.PeerInfo;
fromAmino(object: _136.PeerInfoAmino): _136.PeerInfo;
toAmino(message: _136.PeerInfo): _136.PeerInfoAmino;
fromAminoMsg(object: _136.PeerInfoAminoMsg): _136.PeerInfo;
fromProtoMsg(message: _136.PeerInfoProtoMsg): _136.PeerInfo;
toProto(message: _136.PeerInfo): Uint8Array;
toProtoMsg(message: _136.PeerInfo): _136.PeerInfoProtoMsg;
};
PeerAddressInfo: {
typeUrl: string;
encode(message: _136.PeerAddressInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.PeerAddressInfo;
fromPartial(object: Partial<_136.PeerAddressInfo>): _136.PeerAddressInfo;
fromAmino(object: _136.PeerAddressInfoAmino): _136.PeerAddressInfo;
toAmino(message: _136.PeerAddressInfo): _136.PeerAddressInfoAmino;
fromAminoMsg(object: _136.PeerAddressInfoAminoMsg): _136.PeerAddressInfo;
fromProtoMsg(message: _136.PeerAddressInfoProtoMsg): _136.PeerAddressInfo;
toProto(message: _136.PeerAddressInfo): Uint8Array;
toProtoMsg(message: _136.PeerAddressInfo): _136.PeerAddressInfoProtoMsg;
};
};
const types: {
ValidatorSet: {
typeUrl: string;
encode(message: _141.ValidatorSet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _141.ValidatorSet;
fromPartial(object: Partial<_141.ValidatorSet>): _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;
encode(message: _141.Validator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
decode(input: import("..").BinaryReader | Uint8Array, length?: number): _141.Validator;
fromPartial(object: Partial<_141.Validator>): _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;