import { Queue } from '../core/queue.ts';
import type { JobStatus, JobMeta, QueueMessage, BaseJobOptions, WithPriority, WithDelay } from '../interfaces/job.ts';
import type { QueueOptions } from '../interfaces/plugin.ts';
export interface InMemoryJobRequest<TPayload> extends BaseJobOptions, WithPriority, WithDelay {
    /** Job payload */
    payload: TPayload;
}
interface InMemoryJobRecord {
    id: string;
    payload: unknown;
    meta: JobMeta;
    status: 'waiting' | 'reserved' | 'done' | 'failed';
    pushedAt: Date;
    reservedAt?: Date;
    doneAt?: Date;
    expireTime?: number;
    delayTime?: number;
    error?: string;
}
/**
 * Configuration options for InMemoryQueue.
 */
export interface InMemoryQueueOptions extends QueueOptions {
    /**
     * Maximum number of jobs to keep in memory.
     * Older completed/failed jobs will be automatically cleaned up.
     * Defaults to 1000.
     */
    maxJobs?: number;
}
/**
 * In-memory queue implementation for testing and development.
 *
 * Features:
 * - Full priority support (higher numbers = higher priority)
 * - Delay functionality using setTimeout
 * - TTR (Time To Run) with automatic job recovery
 * - Job status tracking
 * - Automatic cleanup of old completed jobs
 * - No external dependencies
 *
 * **Note**: All data is lost when the process exits. Use only for
 * testing, development, or temporary job processing.
 *
 * @example
 * ```typescript
 * import { InMemoryQueue } from 'adapter-queue/memory';
 *
 * const queue = new InMemoryQueue<MyJobs>({
 *   name: 'test-queue',
 *   maxJobs: 500
 * });
 *
 * queue.setHandlers({
 *   'my-job': async ({ payload }) => {
 *     console.log('Processing:', payload);
 *   }
 * });
 *
 * await queue.addJob('my-job', {
 *   payload: { data: 'test' },
 *   priority: 5,
 *   delaySeconds: 10
 * });
 *
 * await queue.run(true, 1);
 * ```
 */
export declare class InMemoryQueue<TJobMap = Record<string, any>> extends Queue<TJobMap, InMemoryJobRequest<any>> {
    private jobs;
    private waitingJobs;
    private reservedJobs;
    private delayedJobs;
    private ttrTimeouts;
    private nextJobId;
    private maxJobs;
    constructor(options: InMemoryQueueOptions);
    protected pushMessage(payload: unknown, meta: JobMeta): Promise<string>;
    protected reserve(timeout: number): Promise<QueueMessage | null>;
    protected completeJob(message: QueueMessage): Promise<void>;
    protected failJob(message: QueueMessage, error: unknown): Promise<void>;
    status(id: string): Promise<JobStatus>;
    /**
     * Get statistics about the queue state.
     */
    getStats(): {
        total: number;
        waiting: number;
        reserved: number;
        done: number;
        failed: number;
        delayed: number;
    };
    /**
     * Clear all jobs from the queue. Useful for testing.
     */
    clear(): void;
    /**
     * Get a job by ID (useful for testing and debugging).
     */
    getJob(id: string): InMemoryJobRecord | undefined;
    /**
     * Add job to waiting queue in priority order (high priority first).
     */
    private addToWaitingQueue;
    /**
     * Recover jobs whose TTR has expired.
     */
    private recoverExpiredJobs;
    /**
     * Recover a specific job back to waiting state.
     */
    private recoverJob;
    /**
     * Clear TTR timeout for a job.
     */
    private clearTtrTimeout;
    /**
     * Clean up old completed jobs to prevent memory leaks.
     */
    private cleanupOldJobs;
    /**
     * Cleanup method for graceful shutdown.
     */
    cleanup(): Promise<void>;
}
export {};