/**
 * Background Jobs - Persisted job queue with adapter support
 */
export type JobStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
export type JobPriority = 'low' | 'normal' | 'high' | 'critical';
export interface Job<T = any> {
    id: string;
    name: string;
    data: T;
    status: JobStatus;
    priority: JobPriority;
    attempts: number;
    maxAttempts: number;
    createdAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    result?: any;
    error?: string;
    progress?: number;
    metadata?: Record<string, any>;
}
export interface JobQueueConfig {
    name?: string;
    concurrency?: number;
    maxAttempts?: number;
    retryDelay?: number;
    storage?: JobStorageAdapter;
}
export interface JobStorageAdapter {
    save(job: Job): Promise<void>;
    get(id: string): Promise<Job | null>;
    getAll(): Promise<Job[]>;
    getByStatus(status: JobStatus): Promise<Job[]>;
    update(id: string, updates: Partial<Job>): Promise<void>;
    delete(id: string): Promise<void>;
    clear(): Promise<void>;
}
export type JobHandler<T = any, R = any> = (job: Job<T>, context: JobContext) => Promise<R>;
export interface JobContext {
    updateProgress: (progress: number) => Promise<void>;
    log: (message: string) => void;
}
/**
 * In-memory job storage adapter
 */
export declare class MemoryJobStorage implements JobStorageAdapter {
    private jobs;
    save(job: Job): Promise<void>;
    get(id: string): Promise<Job | null>;
    getAll(): Promise<Job[]>;
    getByStatus(status: JobStatus): Promise<Job[]>;
    update(id: string, updates: Partial<Job>): Promise<void>;
    delete(id: string): Promise<void>;
    clear(): Promise<void>;
}
/**
 * File-based job storage adapter
 */
export declare class FileJobStorage implements JobStorageAdapter {
    private filePath;
    private jobs;
    private initialized;
    constructor(filePath: string);
    private init;
    private persist;
    save(job: Job): Promise<void>;
    get(id: string): Promise<Job | null>;
    getAll(): Promise<Job[]>;
    getByStatus(status: JobStatus): Promise<Job[]>;
    update(id: string, updates: Partial<Job>): Promise<void>;
    delete(id: string): Promise<void>;
    clear(): Promise<void>;
}
/**
 * Job Queue class
 */
export declare class JobQueue {
    private config;
    private storage;
    private handlers;
    private running;
    private activeJobs;
    private processInterval?;
    constructor(config?: JobQueueConfig);
    /**
     * Register a job handler
     */
    register<T = any, R = any>(name: string, handler: JobHandler<T, R>): void;
    /**
     * Add a job to the queue
     */
    add<T = any>(name: string, data: T, options?: Partial<Job<T>>): Promise<Job<T>>;
    /**
     * Get a job by ID
     */
    get(id: string): Promise<Job | null>;
    /**
     * Get all jobs
     */
    getAll(): Promise<Job[]>;
    /**
     * Get jobs by status
     */
    getByStatus(status: JobStatus): Promise<Job[]>;
    /**
     * Cancel a job
     */
    cancel(id: string): Promise<boolean>;
    /**
     * Retry a failed job
     */
    retry(id: string): Promise<boolean>;
    /**
     * Start processing jobs
     */
    start(): void;
    /**
     * Stop processing jobs
     */
    stop(): void;
    /**
     * Process pending jobs
     */
    private process;
    /**
     * Run a single job
     */
    private runJob;
    /**
     * Process a job immediately (bypass queue)
     */
    processNow(id: string): Promise<any>;
    /**
     * Get queue stats
     */
    getStats(): Promise<{
        pending: number;
        running: number;
        completed: number;
        failed: number;
        cancelled: number;
    }>;
    /**
     * Clear completed/failed jobs
     */
    cleanup(olderThan?: Date): Promise<number>;
}
/**
 * Create a job queue
 */
export declare function createJobQueue(config?: JobQueueConfig): JobQueue;
/**
 * Create a file-based job storage
 */
export declare function createFileJobStorage(filePath: string): FileJobStorage;