@inco/js 0.2.16 → 0.2.17

package/dist/esm/generated/ts/cometbft/abci/v1/types.d.ts

@@ -0,0 +1,597 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { PublicKey } from "../../crypto/v1/keys";
+import { ProofOps } from "../../crypto/v1/proof";
+import { ConsensusParams } from "../../types/v1/params";
+import { BlockIDFlag } from "../../types/v1/validator";
+export declare const protobufPackage = "cometbft.abci.v1";
+/**
+ * Type of the transaction check request.
+ *
+ * This enumeration is incompatible with the CheckTxType definition in
+ * cometbft.abci.v1beta1 and therefore shall not be used in encoding with the same
+ * field number.
+ */
+export declare enum CheckTxType {
+    /** CHECK_TX_TYPE_UNKNOWN - Unknown */
+    CHECK_TX_TYPE_UNKNOWN = 0,
+    /** CHECK_TX_TYPE_RECHECK - Recheck (2nd, 3rd, etc.) */
+    CHECK_TX_TYPE_RECHECK = 1,
+    /** CHECK_TX_TYPE_CHECK - Check (1st time) */
+    CHECK_TX_TYPE_CHECK = 2,
+    UNRECOGNIZED = -1
+}
+export declare function checkTxTypeFromJSON(object: any): CheckTxType;
+export declare function checkTxTypeToJSON(object: CheckTxType): string;
+/** The result of offering a snapshot. */
+export declare enum OfferSnapshotResult {
+    /** OFFER_SNAPSHOT_RESULT_UNKNOWN - Unknown result, abort all snapshot restoration */
+    OFFER_SNAPSHOT_RESULT_UNKNOWN = 0,
+    /** OFFER_SNAPSHOT_RESULT_ACCEPT - Snapshot accepted, apply chunks */
+    OFFER_SNAPSHOT_RESULT_ACCEPT = 1,
+    /** OFFER_SNAPSHOT_RESULT_ABORT - Abort all snapshot restoration */
+    OFFER_SNAPSHOT_RESULT_ABORT = 2,
+    /** OFFER_SNAPSHOT_RESULT_REJECT - Reject this specific snapshot, try others */
+    OFFER_SNAPSHOT_RESULT_REJECT = 3,
+    /** OFFER_SNAPSHOT_RESULT_REJECT_FORMAT - Reject all snapshots of this format, try others */
+    OFFER_SNAPSHOT_RESULT_REJECT_FORMAT = 4,
+    /** OFFER_SNAPSHOT_RESULT_REJECT_SENDER - Reject all snapshots from the sender(s), try others */
+    OFFER_SNAPSHOT_RESULT_REJECT_SENDER = 5,
+    UNRECOGNIZED = -1
+}
+export declare function offerSnapshotResultFromJSON(object: any): OfferSnapshotResult;
+export declare function offerSnapshotResultToJSON(object: OfferSnapshotResult): string;
+/** The result of applying a snapshot chunk. */
+export declare enum ApplySnapshotChunkResult {
+    /** APPLY_SNAPSHOT_CHUNK_RESULT_UNKNOWN - Unknown result, abort all snapshot restoration */
+    APPLY_SNAPSHOT_CHUNK_RESULT_UNKNOWN = 0,
+    /** APPLY_SNAPSHOT_CHUNK_RESULT_ACCEPT - Chunk successfully accepted */
+    APPLY_SNAPSHOT_CHUNK_RESULT_ACCEPT = 1,
+    /** APPLY_SNAPSHOT_CHUNK_RESULT_ABORT - Abort all snapshot restoration */
+    APPLY_SNAPSHOT_CHUNK_RESULT_ABORT = 2,
+    /** APPLY_SNAPSHOT_CHUNK_RESULT_RETRY - Retry chunk (combine with refetch and reject) */
+    APPLY_SNAPSHOT_CHUNK_RESULT_RETRY = 3,
+    /** APPLY_SNAPSHOT_CHUNK_RESULT_RETRY_SNAPSHOT - Retry snapshot (combine with refetch and reject) */
+    APPLY_SNAPSHOT_CHUNK_RESULT_RETRY_SNAPSHOT = 4,
+    /** APPLY_SNAPSHOT_CHUNK_RESULT_REJECT_SNAPSHOT - Reject this snapshot, try others */
+    APPLY_SNAPSHOT_CHUNK_RESULT_REJECT_SNAPSHOT = 5,
+    UNRECOGNIZED = -1
+}
+export declare function applySnapshotChunkResultFromJSON(object: any): ApplySnapshotChunkResult;
+export declare function applySnapshotChunkResultToJSON(object: ApplySnapshotChunkResult): string;
+/** ProcessProposalStatus is the status of the proposal processing. */
+export declare enum ProcessProposalStatus {
+    /** PROCESS_PROPOSAL_STATUS_UNKNOWN - Unknown */
+    PROCESS_PROPOSAL_STATUS_UNKNOWN = 0,
+    /** PROCESS_PROPOSAL_STATUS_ACCEPT - Accepted */
+    PROCESS_PROPOSAL_STATUS_ACCEPT = 1,
+    /** PROCESS_PROPOSAL_STATUS_REJECT - Rejected */
+    PROCESS_PROPOSAL_STATUS_REJECT = 2,
+    UNRECOGNIZED = -1
+}
+export declare function processProposalStatusFromJSON(object: any): ProcessProposalStatus;
+export declare function processProposalStatusToJSON(object: ProcessProposalStatus): string;
+/** VerifyVoteExtensionStatus is the status of the vote extension verification. */
+export declare enum VerifyVoteExtensionStatus {
+    /** VERIFY_VOTE_EXTENSION_STATUS_UNKNOWN - Unknown */
+    VERIFY_VOTE_EXTENSION_STATUS_UNKNOWN = 0,
+    /** VERIFY_VOTE_EXTENSION_STATUS_ACCEPT - Accepted */
+    VERIFY_VOTE_EXTENSION_STATUS_ACCEPT = 1,
+    /**
+     * VERIFY_VOTE_EXTENSION_STATUS_REJECT - Rejecting the vote extension will reject the entire precommit by the sender.
+     * Incorrectly implementing this thus has liveness implications as it may affect
+     * CometBFT's ability to receive 2/3+ valid votes to finalize the block.
+     * Honest nodes should never be rejected.
+     */
+    VERIFY_VOTE_EXTENSION_STATUS_REJECT = 2,
+    UNRECOGNIZED = -1
+}
+export declare function verifyVoteExtensionStatusFromJSON(object: any): VerifyVoteExtensionStatus;
+export declare function verifyVoteExtensionStatusToJSON(object: VerifyVoteExtensionStatus): string;
+/** The type of misbehavior committed by a validator. */
+export declare enum MisbehaviorType {
+    /** MISBEHAVIOR_TYPE_UNKNOWN - Unknown */
+    MISBEHAVIOR_TYPE_UNKNOWN = 0,
+    /** MISBEHAVIOR_TYPE_DUPLICATE_VOTE - Duplicate vote */
+    MISBEHAVIOR_TYPE_DUPLICATE_VOTE = 1,
+    /** MISBEHAVIOR_TYPE_LIGHT_CLIENT_ATTACK - Light client attack */
+    MISBEHAVIOR_TYPE_LIGHT_CLIENT_ATTACK = 2,
+    UNRECOGNIZED = -1
+}
+export declare function misbehaviorTypeFromJSON(object: any): MisbehaviorType;
+export declare function misbehaviorTypeToJSON(object: MisbehaviorType): string;
+/** Request represents a request to the ABCI application. */
+export interface Request {
+    echo?: EchoRequest | undefined;
+    flush?: FlushRequest | undefined;
+    info?: InfoRequest | undefined;
+    initChain?: InitChainRequest | undefined;
+    query?: QueryRequest | undefined;
+    checkTx?: CheckTxRequest | undefined;
+    commit?: CommitRequest | undefined;
+    listSnapshots?: ListSnapshotsRequest | undefined;
+    offerSnapshot?: OfferSnapshotRequest | undefined;
+    loadSnapshotChunk?: LoadSnapshotChunkRequest | undefined;
+    applySnapshotChunk?: ApplySnapshotChunkRequest | undefined;
+    prepareProposal?: PrepareProposalRequest | undefined;
+    processProposal?: ProcessProposalRequest | undefined;
+    extendVote?: ExtendVoteRequest | undefined;
+    verifyVoteExtension?: VerifyVoteExtensionRequest | undefined;
+    finalizeBlock?: FinalizeBlockRequest | undefined;
+}
+/** EchoRequest is a request to "echo" the given string. */
+export interface EchoRequest {
+    message: string;
+}
+/** FlushRequest is a request to flush the write buffer. */
+export interface FlushRequest {
+}
+/** InfoRequest is a request for the ABCI application version. */
+export interface InfoRequest {
+    version: string;
+    blockVersion: number;
+    p2pVersion: number;
+    abciVersion: string;
+}
+/** InitChainRequest is a request to initialize the blockchain. */
+export interface InitChainRequest {
+    time: Date | undefined;
+    chainId: string;
+    consensusParams: ConsensusParams | undefined;
+    validators: ValidatorUpdate[];
+    appStateBytes: Uint8Array;
+    initialHeight: number;
+}
+/** QueryRequest is a request to query the application state. */
+export interface QueryRequest {
+    data: Uint8Array;
+    path: string;
+    height: number;
+    prove: boolean;
+}
+/** CheckTxRequest is a request to check that the transaction is valid. */
+export interface CheckTxRequest {
+    tx: Uint8Array;
+    type: CheckTxType;
+}
+/** CommitRequest is a request to commit the pending application state. */
+export interface CommitRequest {
+}
+/** Request to list available snapshots. */
+export interface ListSnapshotsRequest {
+}
+/** Request offering a snapshot to the application. */
+export interface OfferSnapshotRequest {
+    /** snapshot offered by peers */
+    snapshot: Snapshot | undefined;
+    /** light client-verified app hash for snapshot height */
+    appHash: Uint8Array;
+}
+/** Request to load a snapshot chunk. */
+export interface LoadSnapshotChunkRequest {
+    height: number;
+    format: number;
+    chunk: number;
+}
+/** Request to apply a snapshot chunk. */
+export interface ApplySnapshotChunkRequest {
+    index: number;
+    chunk: Uint8Array;
+    sender: string;
+}
+/**
+ * PrepareProposalRequest is a request for the ABCI application to prepare a new
+ * block proposal.
+ */
+export interface PrepareProposalRequest {
+    /** the modified transactions cannot exceed this size. */
+    maxTxBytes: number;
+    /**
+     * txs is an array of transactions that will be included in a block,
+     * sent to the app for possible modifications.
+     */
+    txs: Uint8Array[];
+    localLastCommit: ExtendedCommitInfo | undefined;
+    misbehavior: Misbehavior[];
+    height: number;
+    time: Date | undefined;
+    nextValidatorsHash: Uint8Array;
+    /** address of the public key of the validator proposing the block. */
+    proposerAddress: Uint8Array;
+}
+/**
+ * ProcessProposalRequest is a request for the ABCI application to process a proposal
+ * received from another validator.
+ */
+export interface ProcessProposalRequest {
+    txs: Uint8Array[];
+    proposedLastCommit: CommitInfo | undefined;
+    misbehavior: Misbehavior[];
+    /** Merkle root hash of the fields of the proposed block. */
+    hash: Uint8Array;
+    height: number;
+    time: Date | undefined;
+    nextValidatorsHash: Uint8Array;
+    /** address of the public key of the original proposer of the block. */
+    proposerAddress: Uint8Array;
+}
+/** ExtendVoteRequest extends a precommit vote with application-injected data. */
+export interface ExtendVoteRequest {
+    /** the hash of the block that this vote may be referring to */
+    hash: Uint8Array;
+    /** the height of the extended vote */
+    height: number;
+    /** info of the block that this vote may be referring to */
+    time: Date | undefined;
+    txs: Uint8Array[];
+    proposedLastCommit: CommitInfo | undefined;
+    misbehavior: Misbehavior[];
+    nextValidatorsHash: Uint8Array;
+    /** address of the public key of the original proposer of the block. */
+    proposerAddress: Uint8Array;
+}
+/**
+ * VerifyVoteExtensionRequest is a request for the application to verify a vote extension
+ * produced by a different validator.
+ */
+export interface VerifyVoteExtensionRequest {
+    /** the hash of the block that this received vote corresponds to */
+    hash: Uint8Array;
+    /** the validator that signed the vote extension */
+    validatorAddress: Uint8Array;
+    height: number;
+    voteExtension: Uint8Array;
+}
+/** FinalizeBlockRequest is a request to finalize the block. */
+export interface FinalizeBlockRequest {
+    txs: Uint8Array[];
+    decidedLastCommit: CommitInfo | undefined;
+    misbehavior: Misbehavior[];
+    /** Merkle root hash of the fields of the decided block. */
+    hash: Uint8Array;
+    height: number;
+    time: Date | undefined;
+    nextValidatorsHash: Uint8Array;
+    /** address of the public key of the original proposer of the block. */
+    proposerAddress: Uint8Array;
+}
+/** Response represents a response from the ABCI application. */
+export interface Response {
+    exception?: ExceptionResponse | undefined;
+    echo?: EchoResponse | undefined;
+    flush?: FlushResponse | undefined;
+    info?: InfoResponse | undefined;
+    initChain?: InitChainResponse | undefined;
+    query?: QueryResponse | undefined;
+    checkTx?: CheckTxResponse | undefined;
+    commit?: CommitResponse | undefined;
+    listSnapshots?: ListSnapshotsResponse | undefined;
+    offerSnapshot?: OfferSnapshotResponse | undefined;
+    loadSnapshotChunk?: LoadSnapshotChunkResponse | undefined;
+    applySnapshotChunk?: ApplySnapshotChunkResponse | undefined;
+    prepareProposal?: PrepareProposalResponse | undefined;
+    processProposal?: ProcessProposalResponse | undefined;
+    extendVote?: ExtendVoteResponse | undefined;
+    verifyVoteExtension?: VerifyVoteExtensionResponse | undefined;
+    finalizeBlock?: FinalizeBlockResponse | undefined;
+}
+/** nondeterministic */
+export interface ExceptionResponse {
+    error: string;
+}
+/** EchoResponse indicates that the connection is still alive. */
+export interface EchoResponse {
+    message: string;
+}
+/** FlushResponse indicates that the write buffer was flushed. */
+export interface FlushResponse {
+}
+/** InfoResponse contains the ABCI application version information. */
+export interface InfoResponse {
+    data: string;
+    version: string;
+    appVersion: number;
+    lastBlockHeight: number;
+    lastBlockAppHash: Uint8Array;
+}
+/**
+ * InitChainResponse contains the ABCI application's hash and updates to the
+ * validator set and/or the consensus params, if any.
+ */
+export interface InitChainResponse {
+    consensusParams: ConsensusParams | undefined;
+    validators: ValidatorUpdate[];
+    appHash: Uint8Array;
+}
+/** QueryResponse contains the ABCI application data along with a proof. */
+export interface QueryResponse {
+    code: number;
+    /** bytes data = 2; // use "value" instead. */
+    log: string;
+    /** nondeterministic */
+    info: string;
+    index: number;
+    key: Uint8Array;
+    value: Uint8Array;
+    proofOps: ProofOps | undefined;
+    height: number;
+    codespace: string;
+}
+/**
+ * CheckTxResponse shows if the transaction was deemed valid by the ABCI
+ * application.
+ */
+export interface CheckTxResponse {
+    code: number;
+    data: Uint8Array;
+    /** nondeterministic */
+    log: string;
+    /** nondeterministic */
+    info: string;
+    gasWanted: number;
+    gasUsed: number;
+    /** nondeterministic */
+    events: Event[];
+    codespace: string;
+}
+/** CommitResponse indicates how much blocks should CometBFT retain. */
+export interface CommitResponse {
+    retainHeight: number;
+}
+/** ListSnapshotsResponse contains the list of snapshots. */
+export interface ListSnapshotsResponse {
+    snapshots: Snapshot[];
+}
+/**
+ * OfferSnapshotResponse indicates the ABCI application decision whenever to
+ * provide a snapshot to the requester or not.
+ */
+export interface OfferSnapshotResponse {
+    result: OfferSnapshotResult;
+}
+/** LoadSnapshotChunkResponse returns a snapshot's chunk. */
+export interface LoadSnapshotChunkResponse {
+    chunk: Uint8Array;
+}
+/** ApplySnapshotChunkResponse returns a result of applying the specified chunk. */
+export interface ApplySnapshotChunkResponse {
+    result: ApplySnapshotChunkResult;
+    /** Chunks to refetch and reapply */
+    refetchChunks: number[];
+    /** Chunk senders to reject and ban */
+    rejectSenders: string[];
+}
+/** PrepareProposalResponse contains a list of transactions, which will form a block. */
+export interface PrepareProposalResponse {
+    txs: Uint8Array[];
+}
+/**
+ * ProcessProposalResponse indicates the ABCI application's decision whenever
+ * the given proposal should be accepted or not.
+ */
+export interface ProcessProposalResponse {
+    status: ProcessProposalStatus;
+}
+/**
+ * ExtendVoteResponse contains the vote extension that the application would like to
+ * attach to its next precommit vote.
+ */
+export interface ExtendVoteResponse {
+    voteExtension: Uint8Array;
+}
+/**
+ * VerifyVoteExtensionResponse indicates the ABCI application's decision
+ * whenever the vote extension should be accepted or not.
+ */
+export interface VerifyVoteExtensionResponse {
+    status: VerifyVoteExtensionStatus;
+}
+/** FinalizeBlockResponse contains the result of executing the block. */
+export interface FinalizeBlockResponse {
+    /** set of block events emitted as part of executing the block */
+    events: Event[];
+    /**
+     * the result of executing each transaction including the events
+     * the particular transaction emitted. This should match the order
+     * of the transactions delivered in the block itself
+     */
+    txResults: ExecTxResult[];
+    /** a list of updates to the validator set. These will reflect the validator set at current height + 2. */
+    validatorUpdates: ValidatorUpdate[];
+    /** updates to the consensus params, if any. */
+    consensusParamUpdates: ConsensusParams | undefined;
+    /**
+     * app_hash is the hash of the applications' state which is used to confirm
+     * that execution of the transactions was deterministic.
+     * It is up to the application to decide which algorithm to use.
+     */
+    appHash: Uint8Array;
+}
+/** CommitInfo contains votes for the particular round. */
+export interface CommitInfo {
+    round: number;
+    votes: VoteInfo[];
+}
+/**
+ * ExtendedCommitInfo is similar to CommitInfo except that it is only used in
+ * the PrepareProposal request such that Tendermint can provide vote extensions
+ * to the application.
+ */
+export interface ExtendedCommitInfo {
+    /** The round at which the block proposer decided in the previous height. */
+    round: number;
+    /**
+     * List of validators' addresses in the last validator set with their voting
+     * information, including vote extensions.
+     */
+    votes: ExtendedVoteInfo[];
+}
+/**
+ * Event allows application developers to attach additional information to
+ * ResponseFinalizeBlock and ResponseCheckTx.
+ * Up to 0.37, this could also be used in ResponseBeginBlock, ResponseEndBlock,
+ * and ResponseDeliverTx.
+ * Later, transactions may be queried using these events.
+ */
+export interface Event {
+    type: string;
+    attributes: EventAttribute[];
+}
+/** EventAttribute is a single key-value pair, associated with an event. */
+export interface EventAttribute {
+    key: string;
+    value: string;
+    /** nondeterministic */
+    index: boolean;
+}
+/**
+ * ExecTxResult contains results of executing one individual transaction.
+ *
+ * * Its structure is equivalent to #ResponseDeliverTx which will be deprecated/deleted
+ */
+export interface ExecTxResult {
+    code: number;
+    data: Uint8Array;
+    /** nondeterministic */
+    log: string;
+    /** nondeterministic */
+    info: string;
+    gasWanted: number;
+    gasUsed: number;
+    /** nondeterministic */
+    events: Event[];
+    codespace: string;
+}
+/**
+ * TxResult contains results of executing the transaction.
+ *
+ * One usage is indexing transaction results.
+ */
+export interface TxResult {
+    height: number;
+    index: number;
+    tx: Uint8Array;
+    result: ExecTxResult | undefined;
+}
+/** Validator in the validator set. */
+export interface Validator {
+    /** The first 20 bytes of SHA256(public key) */
+    address: Uint8Array;
+    /** PubKey pub_key = 2 [(gogoproto.nullable)=false]; */
+    power: number;
+}
+/** ValidatorUpdate is a singular update to a validator set. */
+export interface ValidatorUpdate {
+    pubKey: PublicKey | undefined;
+    power: number;
+}
+/** VoteInfo contains the information about the vote. */
+export interface VoteInfo {
+    validator: Validator | undefined;
+    blockIdFlag: BlockIDFlag;
+}
+/** ExtendedVoteInfo extends VoteInfo with the vote extensions (non-deterministic). */
+export interface ExtendedVoteInfo {
+    /** The validator that sent the vote. */
+    validator: Validator | undefined;
+    /** Non-deterministic extension provided by the sending validator's application. */
+    voteExtension: Uint8Array;
+    /** Vote extension signature created by CometBFT */
+    extensionSignature: Uint8Array;
+    /** block_id_flag indicates whether the validator voted for a block, nil, or did not vote at all */
+    blockIdFlag: BlockIDFlag;
+}
+/** Misbehavior is a type of misbehavior committed by a validator. */
+export interface Misbehavior {
+    type: MisbehaviorType;
+    /** The offending validator */
+    validator: Validator | undefined;
+    /** The height when the offense occurred */
+    height: number;
+    /** The corresponding time where the offense occurred */
+    time: Date | undefined;
+    /**
+     * Total voting power of the validator set in case the ABCI application does
+     * not store historical validators.
+     * https://github.com/tendermint/tendermint/issues/4581
+     */
+    totalVotingPower: number;
+}
+/** Snapshot of the ABCI application state. */
+export interface Snapshot {
+    /** The height at which the snapshot was taken */
+    height: number;
+    /** The application-specific snapshot format */
+    format: number;
+    /** Number of chunks in the snapshot */
+    chunks: number;
+    /** Arbitrary snapshot hash, equal only if identical */
+    hash: Uint8Array;
+    /** Arbitrary application metadata */
+    metadata: Uint8Array;
+}
+export declare const Request: MessageFns<Request>;
+export declare const EchoRequest: MessageFns<EchoRequest>;
+export declare const FlushRequest: MessageFns<FlushRequest>;
+export declare const InfoRequest: MessageFns<InfoRequest>;
+export declare const InitChainRequest: MessageFns<InitChainRequest>;
+export declare const QueryRequest: MessageFns<QueryRequest>;
+export declare const CheckTxRequest: MessageFns<CheckTxRequest>;
+export declare const CommitRequest: MessageFns<CommitRequest>;
+export declare const ListSnapshotsRequest: MessageFns<ListSnapshotsRequest>;
+export declare const OfferSnapshotRequest: MessageFns<OfferSnapshotRequest>;
+export declare const LoadSnapshotChunkRequest: MessageFns<LoadSnapshotChunkRequest>;
+export declare const ApplySnapshotChunkRequest: MessageFns<ApplySnapshotChunkRequest>;
+export declare const PrepareProposalRequest: MessageFns<PrepareProposalRequest>;
+export declare const ProcessProposalRequest: MessageFns<ProcessProposalRequest>;
+export declare const ExtendVoteRequest: MessageFns<ExtendVoteRequest>;
+export declare const VerifyVoteExtensionRequest: MessageFns<VerifyVoteExtensionRequest>;
+export declare const FinalizeBlockRequest: MessageFns<FinalizeBlockRequest>;
+export declare const Response: MessageFns<Response>;
+export declare const ExceptionResponse: MessageFns<ExceptionResponse>;
+export declare const EchoResponse: MessageFns<EchoResponse>;
+export declare const FlushResponse: MessageFns<FlushResponse>;
+export declare const InfoResponse: MessageFns<InfoResponse>;
+export declare const InitChainResponse: MessageFns<InitChainResponse>;
+export declare const QueryResponse: MessageFns<QueryResponse>;
+export declare const CheckTxResponse: MessageFns<CheckTxResponse>;
+export declare const CommitResponse: MessageFns<CommitResponse>;
+export declare const ListSnapshotsResponse: MessageFns<ListSnapshotsResponse>;
+export declare const OfferSnapshotResponse: MessageFns<OfferSnapshotResponse>;
+export declare const LoadSnapshotChunkResponse: MessageFns<LoadSnapshotChunkResponse>;
+export declare const ApplySnapshotChunkResponse: MessageFns<ApplySnapshotChunkResponse>;
+export declare const PrepareProposalResponse: MessageFns<PrepareProposalResponse>;
+export declare const ProcessProposalResponse: MessageFns<ProcessProposalResponse>;
+export declare const ExtendVoteResponse: MessageFns<ExtendVoteResponse>;
+export declare const VerifyVoteExtensionResponse: MessageFns<VerifyVoteExtensionResponse>;
+export declare const FinalizeBlockResponse: MessageFns<FinalizeBlockResponse>;
+export declare const CommitInfo: MessageFns<CommitInfo>;
+export declare const ExtendedCommitInfo: MessageFns<ExtendedCommitInfo>;
+export declare const Event: MessageFns<Event>;
+export declare const EventAttribute: MessageFns<EventAttribute>;
+export declare const ExecTxResult: MessageFns<ExecTxResult>;
+export declare const TxResult: MessageFns<TxResult>;
+export declare const Validator: MessageFns<Validator>;
+export declare const ValidatorUpdate: MessageFns<ValidatorUpdate>;
+export declare const VoteInfo: MessageFns<VoteInfo>;
+export declare const ExtendedVoteInfo: MessageFns<ExtendedVoteInfo>;
+export declare const Misbehavior: MessageFns<Misbehavior>;
+export declare const Snapshot: MessageFns<Snapshot>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};