import type { Job, ClientOptions } from './types';
/**
 * Minimal job reference returned from bulk operations.
 * Contains only the essential fields available immediately after creation.
 */
export interface JobReference<T = unknown> {
    /** Server-assigned job ID */
    id: number;
    /** Queue name */
    queue: string;
    /** Original job data */
    data: T;
}
export interface QueueOptions extends ClientOptions {
    /** Default job options for all jobs in this queue */
    defaultJobOptions?: JobOptions;
}
export interface JobOptions {
    /** Job priority (higher = first) */
    priority?: number;
    /** Delay in ms */
    delay?: number;
    /** Number of retry attempts (BullMQ-compatible alias for max_attempts) */
    attempts?: number;
    /** Backoff configuration */
    backoff?: number | {
        type: 'exponential' | 'fixed';
        delay: number;
    };
    /** Job timeout in ms */
    timeout?: number;
    /** Time-to-live in ms */
    ttl?: number;
    /** Unique key for deduplication */
    jobId?: string;
    /** Remove job on completion */
    removeOnComplete?: boolean | number;
    /** Remove job on failure */
    removeOnFail?: boolean | number;
    /** Job IDs that must complete before this job runs */
    depends_on?: number[];
    /** Tags for filtering */
    tags?: string[];
    /** Group ID for FIFO processing within group (only one job per group processed at a time) */
    group_id?: string;
}
/**
 * BullMQ-compatible Queue class
 *
 * @example
 * ```typescript
 * import { Queue } from 'flashq';
 *
 * const emailQueue = new Queue('emails');
 *
 * await emailQueue.add('send', { to: 'user@example.com' }, {
 *   attempts: 3,
 *   backoff: { type: 'exponential', delay: 1000 }
 * });
 * ```
 */
export declare class Queue<T = unknown> {
    private client;
    private defaultJobOptions;
    readonly name: string;
    constructor(name: string, options?: QueueOptions);
    /**
     * Add a job to the queue (BullMQ-compatible)
     */
    add(name: string, data: T, options?: JobOptions): Promise<Job<T>>;
    /**
     * Add multiple jobs (BullMQ-compatible)
     *
     * @returns Array of job references with id, queue, and data.
     *          Use getJob() if you need full job details.
     */
    addBulk(jobs: Array<{
        name: string;
        data: T;
        opts?: JobOptions;
    }>): Promise<JobReference<T>[]>;
    /**
     * Get a job by ID
     */
    getJob(jobId: number): Promise<Job<T> | null>;
    /**
     * Wait for a job to complete and return its result
     */
    finished<R = unknown>(jobId: number, timeout?: number): Promise<R | null>;
    /**
     * Pause the queue
     */
    pause(): Promise<void>;
    /**
     * Resume the queue
     */
    resume(): Promise<void>;
    /**
     * Check if queue is paused
     */
    isPaused(): Promise<boolean>;
    /**
     * Get job counts by state
     */
    getJobCounts(): Promise<{
        waiting: number;
        active: number;
        completed: number;
        failed: number;
        delayed: number;
    }>;
    /**
     * Drain the queue (remove all waiting jobs)
     */
    drain(): Promise<void>;
    /**
     * Obliterate the queue (remove all data)
     */
    obliterate(): Promise<void>;
    /**
     * Clean jobs by state and age
     */
    clean(grace: number, limit: number, type: 'completed' | 'failed' | 'delayed' | 'waiting'): Promise<number[]>;
    /**
     * Close the queue connection
     */
    close(): Promise<void>;
}
//# sourceMappingURL=queue.d.ts.map