import { type DurableTtlSweepResult } from './ttl-coordinator.js';
import type { Task, TaskStatus, TaskEvent, TaskArchive, TaskArchiveImportOptions, TaskArchiveImportResult, BlockedRequest, TaskFilter, BroadcastProvider, ShortTermStore, LongTermStore, TaskcastHooks, EventQueryOptions, ReleasePreconditions, ReleaseResult, StorageWriterRegistration } from './types.js';
export declare class TaskConflictError extends Error {
    constructor(taskId: string);
}
export declare class InvalidTransitionError extends Error {
    readonly from: TaskStatus;
    readonly to: TaskStatus;
    constructor(from: TaskStatus, to: TaskStatus);
}
interface TaskEngineOptionsBase {
    broadcast: BroadcastProvider;
    hooks?: TaskcastHooks;
    storageLockTtlMs?: number;
    rehydrateReplayEvents?: number;
}
interface TaskEngineOptionsCanonical extends TaskEngineOptionsBase {
    shortTermStore: ShortTermStore;
    longTermStore?: LongTermStore;
}
/** @deprecated Use shortTermStore/longTermStore instead */
interface TaskEngineOptionsLegacy extends TaskEngineOptionsBase {
    shortTerm: ShortTermStore;
    longTerm?: LongTermStore;
}
export type TaskEngineOptions = TaskEngineOptionsCanonical | TaskEngineOptionsLegacy;
export interface PublishEventInput {
    type: string;
    level: TaskEvent['level'];
    data: unknown;
    seriesId?: string;
    seriesMode?: TaskEvent['seriesMode'];
    seriesAccField?: string;
}
export interface CreateTaskInput {
    id?: string;
    type?: string;
    params?: Record<string, unknown>;
    metadata?: Record<string, unknown>;
    ttl?: number;
    webhooks?: Task['webhooks'];
    cleanup?: Task['cleanup'];
    authConfig?: Task['authConfig'];
    tags?: string[];
    assignMode?: Task['assignMode'];
    cost?: number;
    disconnectPolicy?: Task['disconnectPolicy'];
}
export type TransitionListener = (task: Task, from: TaskStatus, to: TaskStatus) => void;
export type CreationListener = (task: Task) => void;
export type StorageLifecycleObservation = Readonly<Record<string, unknown>>;
export type StorageLifecycleListener = (observation: StorageLifecycleObservation) => void;
export interface StorageReleaseSweepResult {
    claimed: number;
    released: number;
    recovered: number;
    stale: number;
    deferred: number;
    failed: number;
}
export declare class TaskEngine {
    private static readonly CREATION_CLAIM_TTL_MS;
    private shortTermStore;
    private longTermStore;
    private broadcast;
    private hooks;
    private storageCoordinator;
    private ttlCoordinator;
    private transitionListeners;
    private creationListeners;
    private storageLifecycleListeners;
    /** Per-task promise chain to serialize `_emit` calls, preventing race
     *  conditions where concurrent publishes store events out of index order. */
    private _emitChains;
    constructor(opts: TaskEngineOptions);
    addStorageLifecycleListener(listener: StorageLifecycleListener): () => void;
    createTask(input: CreateTaskInput): Promise<Task>;
    addTransitionListener(listener: TransitionListener): void;
    addCreationListener(listener: CreationListener): void;
    removeCreationListener(listener: CreationListener): void;
    getTask(taskId: string): Promise<Task | null>;
    transitionTask(taskId: string, to: TaskStatus, payload?: {
        result?: Task['result'];
        error?: Task['error'];
        reason?: string;
        resumeAfterMs?: number;
        blockedRequest?: BlockedRequest;
        ttl?: number;
    }): Promise<Task>;
    publishEvent(taskId: string, input: PublishEventInput): Promise<TaskEvent>;
    releaseTaskStorage(taskId: string, preconditions: ReleasePreconditions): Promise<ReleaseResult>;
    releaseTaskStorageAtCurrentDurableIndex(taskId: string, inactiveSince: number): Promise<ReleaseResult>;
    retryStorageReleaseRequests(limit: number, inactiveBefore?: number): Promise<StorageReleaseSweepResult>;
    registerStorageWriter(registration: StorageWriterRegistration, ttlMs: number): Promise<void>;
    listStorageWriters(): Promise<StorageWriterRegistration[]>;
    supportsStorageRelease(): boolean;
    supportsDurableTtl(): boolean;
    sweepDurableTtl(limit: number, claimTtlMs?: number): Promise<DurableTtlSweepResult>;
    sweepTerminalProjections(limit: number, claimTtlMs?: number): Promise<DurableTtlSweepResult>;
    recoverTaskStorage(taskId: string): Promise<ReleaseResult>;
    exportTaskArchive(taskId: string): Promise<TaskArchive>;
    private buildExportArchive;
    private mergeExportHistories;
    private getContiguousPrefixEnd;
    private normalizeExportArchive;
    private compactExportEvents;
    private isCompactableSeriesEvent;
    private toArchiveEvent;
    importTaskArchive(archive: TaskArchive, options?: TaskArchiveImportOptions): Promise<TaskArchiveImportResult>;
    listTasks(filter: TaskFilter): Promise<Task[]>;
    getEvents(taskId: string, opts?: EventQueryOptions): Promise<TaskEvent[]>;
    subscribe(taskId: string, handler: (event: TaskEvent) => void): () => void;
    getSeriesLatest(taskId: string, seriesId: string): Promise<TaskEvent | null>;
    private shouldOverlayHotHistory;
    private loadCanonicalDurableEvents;
    private _emit;
    private emitStorageLifecycleObservation;
    private storageErrorCode;
    private _emitInner;
    private commitTaskEventsForMutation;
    private finishCommittedEvent;
    private persistLongTermEvent;
}
export {};
//# sourceMappingURL=engine.d.ts.map