/**
 * Simple In-Memory Job Queue
 *
 * A lightweight job queue for async task processing.
 * Works well with persistent containers (Fly.io) without external dependencies.
 *
 * For production at scale, swap for Quirrel or BullMQ.
 */
import { EventEmitter } from "events";
export type JobStatus = "pending" | "processing" | "complete" | "failed";
export interface Job<T = unknown, R = unknown> {
    id: string;
    payload: T;
    status: JobStatus;
    result?: R;
    error?: string;
    createdAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    retries: number;
    maxRetries: number;
}
export interface JobResult<R = unknown> {
    status: "complete" | "failed";
    result?: R;
    error?: string;
}
export interface QueueOptions {
    /** Max concurrent jobs (default: 2) */
    concurrency?: number;
    /** Max retries on failure (default: 3) */
    maxRetries?: number;
    /** Job timeout in ms (default: 5 min) */
    timeout?: number;
}
export declare class SimpleQueue<T, R> extends EventEmitter {
    private jobs;
    private queue;
    private processing;
    private concurrency;
    private maxRetries;
    private timeout;
    private handler;
    private name;
    constructor(name: string, handler: (payload: T) => Promise<R>, options?: QueueOptions);
    /**
     * Add a job to the queue.
     * Returns the job ID for tracking.
     */
    enqueue(payload: T): Promise<{
        id: string;
    }>;
    /**
     * Get job by ID.
     */
    getJob(id: string): Job<T, R> | undefined;
    /**
     * Get job status by ID.
     */
    getStatus(id: string): JobStatus | undefined;
    /**
     * Get all jobs (for debugging).
     */
    getAllJobs(): Job<T, R>[];
    /**
     * Process pending jobs up to concurrency limit.
     */
    private processQueue;
    /**
     * Process a single job.
     */
    private processJob;
    /**
     * Clear completed/failed jobs older than maxAge (default: 1 hour).
     */
    cleanup(maxAgeMs?: number): number;
}
/**
 * Get or create a queue by name.
 */
export declare function getQueue<T, R>(name: string, handler?: (payload: T) => Promise<R>, options?: QueueOptions): SimpleQueue<T, R>;
/**
 * Start periodic cleanup of old jobs.
 */
export declare function startQueueCleanup(intervalMs?: number): void;