import { Beef, TelemetrySpan } from '@bsv/sdk';
import type { StorageProvider } from '../StorageProvider';
import type { TablePreparedBeef } from '../schema/tables/TablePreparedBeef.interfaces';
export declare const PREPARED_BEEF_FORMAT_VERSION = 1;
export interface PreparedBeefOptions {
    /** Read prepared artifacts on the createAction proof path. Default false. */
    readEnabled?: boolean;
    /** Prepare and persist artifacts after foreground work completes. Default false. */
    writeEnabled?: boolean;
    /** Gradually prepare existing eligible managed-change roots. Default false. */
    backfillEnabled?: boolean;
    /** Maximum queued roots. New background work is dropped when full. */
    maxQueueSize?: number;
    /** Maximum queued or running roots for one user. */
    maxQueueSizePerUser?: number;
    /** Reject a prepared artifact larger than this many bytes. */
    maxArtifactBytes?: number;
    /** Bypass prepared lookup when all matching artifacts exceed this total. */
    maxLookupBytes?: number;
    /** Reject source or prepared BEEF graphs with more transactions. */
    maxArtifactTransactions?: number;
    /** Maximum roots selected by each low-priority backfill pass. */
    backfillBatchSize?: number;
    /** Delay between backfill passes. */
    backfillIntervalMs?: number;
}
export interface PreparedBeefPolicy {
    readEnabled: boolean;
    writeEnabled: boolean;
    backfillEnabled: boolean;
    maxQueueSize: number;
    maxQueueSizePerUser: number;
    maxArtifactBytes: number;
    maxLookupBytes: number;
    maxArtifactTransactions: number;
    backfillBatchSize: number;
    backfillIntervalMs: number;
}
export interface PreparedBeefRoot {
    userId: number;
    rootTxid: string;
}
export interface PreparedBeefLookupResult {
    beef: Beef;
    hitTxids: string[];
    missingTxids: string[];
    corruptCount: number;
    byteLength: number;
}
export interface PreparedBeefPreparation {
    userId: number;
    rootTxids: string[];
}
/** Knex-owned extension used without adding server cache code to portable providers. */
export interface PreparedBeefStorage extends Pick<StorageProvider, 'telemetry' | 'getBeefForTransaction' | 'getServices'> {
    readonly preparedBeefPolicy: PreparedBeefPolicy;
    preparedBeefReadsEnabled?: () => boolean;
    findPreparedBeefs: (userId: number, rootTxids: string[]) => Promise<TablePreparedBeef[]>;
    readPreparedBeefLookupByteLength: (userId: number, rootTxids: string[]) => Promise<number>;
    readPreparedBeefProofEpoch: () => Promise<number>;
    readPreparedBeefSourceByteLength: (rootTxid: string) => Promise<number | undefined>;
    upsertPreparedBeef: (artifact: TablePreparedBeef, expectedProofEpoch: number) => Promise<boolean>;
    findPreparedBeefBackfillRoots: (limit: number, formatVersion: number) => Promise<PreparedBeefRoot[]>;
}
export declare function defaultPreparedBeefPolicy(): PreparedBeefPolicy;
export declare function validatePreparedBeefPolicy(options?: PreparedBeefOptions): PreparedBeefPolicy;
/**
 * Read and validate prepared artifacts without performing chain or service
 * work. A malformed, stale, oversized, or unsupported row is a cache miss.
 */
export declare function lookupPreparedBeefs(storage: PreparedBeefStorage, userId: number, rootTxids: string[], parent?: TelemetrySpan): Promise<PreparedBeefLookupResult>;
/**
 * Bounded, best-effort COOK worker. No foreground caller awaits this queue.
 * Dropped or failed work is safe because canonical storage remains the source
 * of truth and the normal BEEF builder remains the read-path fallback.
 */
export declare class PreparedBeefCoordinator {
    private readonly storage;
    private readonly queue;
    private readonly pendingRoots;
    private readonly pendingRootsByUser;
    private admittedRoots;
    private scheduled;
    private timer?;
    private running;
    private stopped;
    private backfillStarted;
    private idleWaiters;
    constructor(storage: PreparedBeefStorage);
    enqueue(preparation: PreparedBeefPreparation): boolean;
    startBackfill(): void;
    waitForIdle(): Promise<void>;
    stop(): Promise<void>;
    private schedule;
    private run;
    private enqueueBackfillBatch;
    private prepare;
    private prepareRoot;
    private buildAndPersistReadyArtifact;
    private persistFailureMarker;
    private resolveIdle;
    private releaseAdmission;
}
//# sourceMappingURL=preparedBeef.d.ts.map