import type { BuiltObservationLogTaskLockStore, ObservationLogTaskKind } from '../../types/sdk/observation-log';
import { BackgroundTaskTracker } from '../state/background-task-tracker';
export interface ScopedMemoryTaskDescriptor {
    taskKind: ObservationLogTaskKind;
    observationScopeId: string;
}
export type ScopedMemoryTaskStatus = 'queued' | 'running';
export interface ScopedMemoryTaskInfo extends ScopedMemoryTaskDescriptor {
    id: string;
    status: ScopedMemoryTaskStatus;
    queuedAt: Date;
    startedAt?: Date;
}
export type ScopedMemoryTaskResult<T> = {
    status: 'completed';
    value: T;
} | {
    status: 'skipped';
    reason: 'lock-held';
} | {
    status: 'failed';
    error: unknown;
};
export interface ScopedMemoryTaskHandle<T> extends ScopedMemoryTaskDescriptor {
    id: string;
    done: Promise<ScopedMemoryTaskResult<T>>;
}
export interface ScopedMemoryTaskError extends ScopedMemoryTaskDescriptor {
    id: string;
    error: unknown;
    createdAt: Date;
}
export type ScopedMemoryTaskEvent<T = unknown> = {
    type: 'queued';
    task: ScopedMemoryTaskInfo;
} | {
    type: 'started';
    task: ScopedMemoryTaskInfo;
} | {
    type: 'completed';
    task: ScopedMemoryTaskInfo;
    value: T;
} | {
    type: 'skipped';
    task: ScopedMemoryTaskInfo;
    reason: 'lock-held';
} | {
    type: 'failed';
    task: ScopedMemoryTaskInfo;
    error: unknown;
};
export interface ScopedMemoryTaskRunnerOptions {
    tracker?: BackgroundTaskTracker;
    lockStore?: BuiltObservationLogTaskLockStore;
    lockTtlMs?: number;
    maxCapturedErrors?: number;
    onEvent?: (event: ScopedMemoryTaskEvent) => void;
}
export declare class ScopedMemoryTaskRunner {
    private readonly tracker;
    private readonly lockStore;
    private readonly lockTtlMs;
    private readonly maxCapturedErrors;
    private readonly onEvent;
    private readonly queuesByScope;
    private readonly inFlightTasks;
    private readonly capturedErrors;
    constructor(options?: ScopedMemoryTaskRunnerOptions);
    get pendingCount(): number;
    getInFlightTasks(): ScopedMemoryTaskInfo[];
    getCapturedErrors(): ScopedMemoryTaskError[];
    flush(): Promise<void>;
    schedule<T>(descriptor: ScopedMemoryTaskDescriptor, task: () => Promise<T>): ScopedMemoryTaskHandle<T>;
    private runTask;
    private startLockRenewal;
    private acquireLock;
    private releaseLock;
    private captureError;
    private emit;
    private cloneTaskInfo;
}