@gravito/stream 2.0.1 → 2.1.0

package/dist/index.d.cts

@@ -1,2242 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { GravitoOrbit, PlanetCore } from '@gravito/core';
-import { ConnectionContract } from '@gravito/atlas';
-
-/**
- * Represents a job that has been serialized for storage in a queue.
- * @public
- */
-interface SerializedJob {
-    /** Unique job identifier */
-    id: string;
-    /** Serializer type: 'json' for plain objects or 'class' for instances */
-    type: 'json' | 'class' | 'msgpack';
-    /** Serialized data string */
-    data: string;
-    /** Fully qualified class name (only used for 'class' type) */
-    className?: string;
-    /** Timestamp when the job was created */
-    createdAt: number;
-    /** Optional delay in seconds before the job becomes available for processing */
-    delaySeconds?: number;
-    /** Number of times the job has been attempted */
-    attempts?: number;
-    /** Maximum number of retry attempts before the job is marked as failed */
-    maxAttempts?: number;
-    /** Group ID for FIFO (strictly sequential) processing */
-    groupId?: string;
-    /** Initial delay in seconds before first retry attempt */
-    retryAfterSeconds?: number;
-    /** Multiplier for exponential backoff on retries */
-    retryMultiplier?: number;
-    /** Last error message if the job failed */
-    error?: string;
-    /** Timestamp when the job finally failed after max attempts */
-    failedAt?: number;
-    /** Optional priority for the job (string or numeric) */
-    priority?: string | number;
-}
-/**
- * Statistics for a single queue.
- * @public
- */
-interface QueueStats {
-    /** Queue name */
-    queue: string;
-    /** Number of pending jobs */
-    size: number;
-    /** Number of delayed jobs (if supported) */
-    delayed?: number;
-    /** Number of reserved/in-flight jobs (if supported) */
-    reserved?: number;
-    /** Number of failed jobs in DLQ (if supported) */
-    failed?: number;
-    /** Additional custom metrics */
-    metrics?: Record<string, number>;
-}
-/**
- * Advanced topic options for distributed queues (e.g., Kafka).
- * @public
- */
-interface TopicOptions {
-    /** Number of partitions for the topic */
-    partitions?: number;
-    /** Number of replicas for each partition */
-    replicationFactor?: number;
-    /** Additional driver-specific configurations */
-    config?: Record<string, string>;
-}
-/**
- * Database driver configuration.
- * @public
- */
-interface DatabaseDriverConfig$1 {
-    driver: 'database';
-    /** Database service implementation for executing queries */
-    dbService: any;
-    /** Optional table name for job storage */
-    table?: string;
-}
-/**
- * Redis driver configuration.
- * @public
- */
-interface RedisDriverConfig$1 {
-    driver: 'redis';
-    /** Redis client instance (ioredis or node-redis compatible) */
-    client: any;
-    /** Optional prefix for all Redis keys */
-    prefix?: string;
-}
-/**
- * Kafka driver configuration.
- */
-interface KafkaDriverConfig$1 {
-    driver: 'kafka';
-    client: any;
-    consumerGroupId?: string;
-}
-/**
- * SQS driver configuration.
- * @public
- */
-interface SQSDriverConfig$1 {
-    driver: 'sqs';
-    /** Amazon SQS client instance */
-    client: any;
-    /** Optional prefix for queue URLs */
-    queueUrlPrefix?: string;
-    /** The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a ReceiveMessage request. */
-    visibilityTimeout?: number;
-    /** The duration (in seconds) for which the call waits for a message to arrive in the queue before returning. */
-    waitTimeSeconds?: number;
-}
-/**
- * RabbitMQ driver configuration.
- */
-interface RabbitMQDriverConfig$1 {
-    driver: 'rabbitmq';
-    client: any;
-    exchange?: string;
-    exchangeType?: string;
-}
-/**
- * Configuration for a specific queue connection.
- * @public
- */
-type QueueConnectionConfig = {
-    driver: 'memory';
-} | DatabaseDriverConfig$1 | RedisDriverConfig$1 | KafkaDriverConfig$1 | SQSDriverConfig$1 | RabbitMQDriverConfig$1 | {
-    driver: 'nats';
-    [key: string]: unknown;
-} | {
-    driver: string;
-    [key: string]: unknown;
-};
-/**
- * Queue manager config.
- */
-interface QueueConfig {
-    /**
-     * Default connection name.
-     */
-    default?: string;
-    /**
-     * Connection configs.
-     */
-    connections?: Record<string, QueueConnectionConfig>;
-    /**
-     * Default serializer type.
-     */
-    defaultSerializer?: 'json' | 'class' | 'msgpack';
-    /**
-     * Whether to enable serialization caching.
-     * If true, re-queuing the same Job instance will use the cached serialized data.
-     * @default false
-     */
-    useSerializationCache?: boolean;
-    /**
-     * Enable verbose debug logging for QueueManager and Consumer.
-     * @default false
-     */
-    debug?: boolean;
-    /**
-     * Persistence configuration (SQL Archive).
-     */
-    persistence?: {
-        /**
-         * Persistence adapter instance or config.
-         */
-        adapter: PersistenceAdapter;
-        /**
-         * Whether to automatically archive completed jobs.
-         */
-        archiveCompleted?: boolean;
-        /**
-         * Whether to automatically archive failed jobs.
-         */
-        archiveFailed?: boolean;
-        /**
-         * Whether to archive jobs immediately upon enqueue (Audit Mode).
-         * @default false
-         */
-        archiveEnqueued?: boolean;
-        /**
-         * Buffer size for batched writes.
-         * If set, wraps the adapter in BufferedPersistence.
-         */
-        bufferSize?: number;
-        /**
-         * Flush interval in ms for batched writes.
-         * If set, wraps the adapter in BufferedPersistence.
-         */
-        flushInterval?: number;
-    };
-}
-/**
- * Persistence Adapter Interface
- * Used for long-term archiving of jobs in a SQL database.
- */
-interface PersistenceAdapter {
-    /**
-     * Archive a job.
-     */
-    archive(queue: string, job: SerializedJob, status: 'completed' | 'failed' | 'waiting' | string): Promise<void>;
-    /**
-     * Find a job in the archive.
-     */
-    find(queue: string, id: string): Promise<SerializedJob | null>;
-    /**
-     * List jobs from the archive.
-     */
-    list(queue: string, options?: {
-        limit?: number;
-        offset?: number;
-        status?: 'completed' | 'failed' | 'waiting' | string;
-        jobId?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<SerializedJob[]>;
-    /**
-     * Archive multiple jobs (batch write).
-     */
-    archiveMany?(jobs: Array<{
-        queue: string;
-        job: SerializedJob;
-        status: 'completed' | 'failed' | 'waiting' | string;
-    }>): Promise<void>;
-    /**
-     * Remove old data from the archive.
-     */
-    cleanup(days: number): Promise<number>;
-    /**
-     * Flush any buffered data.
-     */
-    flush?(): Promise<void>;
-    /**
-     * Count jobs in the archive.
-     */
-    count(queue: string, options?: {
-        status?: 'completed' | 'failed' | 'waiting' | string;
-        jobId?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<number>;
-    /**
-     * Archive a system log message.
-     */
-    archiveLog(log: {
-        level: string;
-        message: string;
-        workerId: string;
-        queue?: string;
-        timestamp: Date;
-    }): Promise<void>;
-    /**
-     * Archive multiple log messages (batch write).
-     */
-    archiveLogMany?(logs: Array<{
-        level: string;
-        message: string;
-        workerId: string;
-        queue?: string;
-        timestamp: Date;
-    }>): Promise<void>;
-    /**
-     * List system logs from the archive.
-     */
-    listLogs(options?: {
-        limit?: number;
-        offset?: number;
-        level?: string;
-        workerId?: string;
-        queue?: string;
-        search?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<any[]>;
-    /**
-     * Count system logs in the archive.
-     */
-    countLogs(options?: {
-        level?: string;
-        workerId?: string;
-        queue?: string;
-        search?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<number>;
-}
-/**
- * Options when pushing a job.
- */
-interface JobPushOptions {
-    /**
-     * Group ID for FIFO ordering (e.g. userId).
-     * If set, jobs with the same groupId will be processed strictly sequentially.
-     */
-    groupId?: string;
-    /**
-     * Job priority.
-     * Higher priority jobs are processed first (if supported by driver).
-     * Example: 'high', 'low', 'critical'
-     */
-    priority?: string | number;
-}
-
-/**
- * Queue driver interface.
- *
- * All queue drivers must implement this interface.
- * Defines basic queue operations plus optional enterprise-grade capabilities.
- *
- * @example
- * ```typescript
- * class MyDriver implements QueueDriver {
- *   async push(queue: string, job: SerializedJob, options?: JobPushOptions): Promise<void> {
- *     // push a job
- *   }
- *
- *   async pop(queue: string): Promise<SerializedJob | null> {
- *     // pop a job
- *   }
- *
- *   async complete(queue: string, job: SerializedJob): Promise<void> {
- *     // job completed (for FIFO handling)
- *   }
- *
- *   async size(queue: string): Promise<number> {
- *     // queue size
- *   }
- *
- *   async clear(queue: string): Promise<void> {
- *     // clear queue
- *   }
- * }
- * ```
- */
-interface QueueDriver {
-    /**
-     * Push a job to a queue.
-     * @param queue - Queue name
-     * @param job - Serialized job
-     * @param options - Push options (e.g. groupId)
-     */
-    push(queue: string, job: SerializedJob, options?: JobPushOptions): Promise<void>;
-    /**
-     * Pop a job from a queue (non-blocking).
-     * @param queue - Queue name
-     * @returns Serialized job, or `null` if the queue is empty
-     */
-    pop(queue: string): Promise<SerializedJob | null>;
-    /**
-     * Pop a job from a queue (blocking).
-     * @param queues - Queue name or array of queue names
-     * @param timeout - Timeout in seconds
-     * @returns Serialized job, or `null` if timeout reached
-     */
-    popBlocking?(queues: string | string[], timeout: number): Promise<SerializedJob | null>;
-    /**
-     * Mark a job as completed (used for FIFO/Group handling).
-     * @param queue - Queue name
-     * @param job - Serialized job
-     */
-    complete?(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Get queue size.
-     * @param queue - Queue name
-     * @returns Number of jobs in the queue
-     */
-    size(queue: string): Promise<number>;
-    /**
-     * Clear a queue.
-     * @param queue - Queue name
-     */
-    clear(queue: string): Promise<void>;
-    /**
-     * Mark a job as permanently failed (move to DLQ).
-     * @param queue - Queue name
-     * @param job - Serialized job with error info
-     */
-    fail?(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Get queue statistics including pending, delayed, and failed job counts.
-     * @param queue - Queue name
-     */
-    stats?(queue: string): Promise<QueueStats>;
-    /**
-     * Push multiple jobs (optional, higher throughput).
-     * @param queue - Queue name
-     * @param jobs - Serialized job array
-     */
-    pushMany?(queue: string, jobs: SerializedJob[]): Promise<void>;
-    /**
-     * Pop multiple jobs (optional, higher throughput).
-     * @param queue - Queue name
-     * @param count - Max number of jobs to pop
-     * @returns Serialized job array
-     */
-    popMany?(queue: string, count: number): Promise<SerializedJob[]>;
-    /**
-     * Acknowledge a message (enterprise capability, e.g. Kafka/SQS).
-     * @param messageId - Message ID
-     */
-    acknowledge?(messageId: string): Promise<void>;
-    /**
-     * Subscribe to a queue (push-based model, e.g. Kafka/SQS).
-     * @param queue - Queue name
-     * @param callback - Callback to process jobs
-     */
-    subscribe?(queue: string, callback: (job: SerializedJob) => Promise<void>): Promise<void>;
-    /**
-     * Create a topic (Kafka, etc.).
-     * @param topic - Topic name
-     * @param options - Topic options
-     */
-    createTopic?(topic: string, options?: TopicOptions): Promise<void>;
-    /**
-     * Delete a topic (Kafka, etc.).
-     * @param topic - Topic name
-     */
-    deleteTopic?(topic: string): Promise<void>;
-    /**
-     * Report worker heartbeat for monitoring.
-     * @param workerInfo - Worker information
-     * @param prefix - Optional prefix for monitoring keys
-     */
-    reportHeartbeat?(workerInfo: {
-        id: string;
-        status: string;
-        hostname: string;
-        pid: number;
-        uptime: number;
-        last_ping: string;
-        queues: string[];
-        metrics?: Record<string, any>;
-        [key: string]: any;
-    }, prefix?: string): Promise<void>;
-    /**
-     * Publish a log message for monitoring.
-     * @param logPayload - Log payload
-     * @param prefix - Optional prefix for monitoring channels/keys
-     */
-    publishLog?(logPayload: {
-        level: string;
-        message: string;
-        workerId: string;
-        jobId?: string;
-        timestamp: string;
-        [key: string]: any;
-    }, prefix?: string): Promise<void>;
-    /**
-     * Check if a queue is rate limited.
-     * @param queue - Queue name
-     * @param config - Rate limit configuration
-     * @returns true if allowed, false if limited
-     */
-    checkRateLimit?(queue: string, config: {
-        max: number;
-        duration: number;
-    }): Promise<boolean>;
-    /**
-     * Retry failed jobs from DLQ.
-     * @param queue - Queue name
-     * @param count - Optional count (default: all)
-     * @returns Number of jobs retried
-     */
-    retryFailed?(queue: string, count?: number): Promise<number>;
-    /**
-     * Get failed jobs from DLQ.
-     * @param queue - Queue name
-     * @param start - Start index
-     * @param end - End index
-     * @returns Array of failed jobs
-     */
-    getFailed?(queue: string, start?: number, end?: number): Promise<SerializedJob[]>;
-    /**
-     * Clear failed jobs from DLQ.
-     * @param queue - Queue name
-     */
-    clearFailed?(queue: string): Promise<void>;
-}
-
-/**
- * Queueable interface.
- *
- * Classes implementing this interface can be pushed to a queue for execution.
- * Provides a fluent API for queue/connection/delay configuration.
- *
- * @example
- * ```typescript
- * class MyJob implements Queueable {
- *   queueName?: string
- *   connectionName?: string
- *   delaySeconds?: number
- *
- *   onQueue(queue: string): this {
- *     this.queueName = queue
- *     return this
- *   }
- *
- *   onConnection(connection: string): this {
- *     this.connectionName = connection
- *     return this
- *   }
- *
- *   delay(seconds: number): this {
- *     this.delaySeconds = seconds
- *     return this
- *   }
- * }
- * ```
- */
-interface Queueable {
-    /**
-     * Queue name where the job should be pushed.
-     */
-    queueName?: string;
-    /**
-     * Connection name the job should use.
-     */
-    connectionName?: string;
-    /**
-     * Delay before execution (seconds).
-     */
-    delaySeconds?: number;
-    /**
-     * Job priority.
-     */
-    priority?: string | number;
-    /**
-     * Set target queue.
-     * @param queue - Queue name
-     * @returns Self for fluent chaining
-     */
-    onQueue(queue: string): this;
-    /**
-     * Set target connection.
-     * @param connection - Connection name
-     * @returns Self for fluent chaining
-     */
-    onConnection(connection: string): this;
-    /**
-     * Set job priority.
-     * @param priority - Priority level
-     * @returns Self for fluent chaining
-     */
-    withPriority(priority: string | number): this;
-    /**
-     * Set delay (seconds).
-     * @param delay - Delay seconds
-     * @returns Self for fluent chaining
-     */
-    delay(delay: number): this;
-}
-
-/**
- * Base Job.
- *
- * All tasks that should be pushed to a queue should extend this class.
- * Implements the `Queueable` interface, providing a fluent API for queue/connection/delay.
- *
- * @example
- * ```typescript
- * class SendWelcomeEmail extends Job {
- *   constructor(private userId: string) {
- *     super()
- *   }
- *
- *   async handle(): Promise<void> {
- *     const user = await User.find(this.userId)
- *     await mail.send(new WelcomeEmail(user))
- *   }
- * }
- *
- * // Usage
- * await queue.push(new SendWelcomeEmail('123'))
- *   .onQueue('emails')
- *   .delay(60)
- * ```
- * @public
- */
-declare abstract class Job implements Queueable {
-    /**
-     * Unique job identifier.
-     */
-    id?: string;
-    /**
-     * Queue name.
-     */
-    queueName?: string;
-    /**
-     * Connection name.
-     */
-    connectionName?: string;
-    /**
-     * Delay before execution (seconds).
-     */
-    delaySeconds?: number;
-    /**
-     * Current attempt number.
-     */
-    attempts?: number;
-    /**
-     * Maximum attempts.
-     */
-    maxAttempts?: number;
-    /**
-     * Group ID for FIFO.
-     */
-    groupId?: string;
-    /**
-     * Job priority.
-     */
-    priority?: string | number;
-    /**
-     * Initial retry delay (seconds).
-     */
-    retryAfterSeconds?: number;
-    /**
-     * Retry delay multiplier.
-     */
-    retryMultiplier?: number;
-    /**
-     * Set target queue.
-     */
-    onQueue(queue: string): this;
-    /**
-     * Set target connection.
-     */
-    onConnection(connection: string): this;
-    /**
-     * Set job priority.
-     * @param priority - 'high', 'low', or number
-     */
-    withPriority(priority: string | number): this;
-    /**
-     * Set delay (seconds).
-     */
-    delay(delay: number): this;
-    /**
-     * Set retry backoff strategy.
-     * @param seconds - Initial delay in seconds
-     * @param multiplier - Multiplier for each subsequent attempt (default: 2)
-     */
-    backoff(seconds: number, multiplier?: number): this;
-    /**
-     * Calculate retry delay for the next attempt.
-     * @param attempt - Current attempt number (1-based)
-     * @returns Delay in milliseconds
-     */
-    getRetryDelay(attempt: number): number;
-    /**
-     * Job handler logic.
-     *
-     * Subclasses must implement this method.
-     */
-    abstract handle(): Promise<void>;
-    /**
-     * Failure handler (optional).
-     *
-     * Called when the job fails and reaches the maximum number of attempts.
-     * Subclasses can override to implement custom failure handling.
-     *
-     * @param error - Error instance
-     */
-    failed(_error: Error): Promise<void>;
-}
-
-/**
- * Configuration for a recurring scheduled job.
- *
- * @public
- * @since 3.0.0
- */
-interface ScheduledJobConfig {
-    /** Unique identifier for the scheduled task. */
-    id: string;
-    /** Cron expression defining the schedule (e.g., '* * * * *'). */
-    cron: string;
-    /** The target queue name where the job should be pushed. */
-    queue: string;
-    /** The serialized job data. */
-    job: SerializedJob;
-    /** Timestamp of the last successful execution in milliseconds. */
-    lastRun?: number;
-    /** Timestamp of the next scheduled execution in milliseconds. */
-    nextRun?: number;
-    /** Whether the scheduled job is active. */
-    enabled: boolean;
-}
-/**
- * Scheduler manages recurring (cron) jobs in Gravito.
- *
- * It uses Redis to store schedule metadata and coordinates distributed
- * execution using locks to ensure jobs are triggered exactly once per interval.
- *
- * @example
- * ```typescript
- * const scheduler = new Scheduler(queueManager);
- * await scheduler.register({
- *   id: 'daily-cleanup',
- *   cron: '0 0 * * *',
- *   queue: 'default',
- *   job: myJob.serialize()
- * });
- * ```
- *
- * @public
- * @since 3.0.0
- */
-declare class Scheduler {
-    private manager;
-    private prefix;
-    constructor(manager: QueueManager, options?: {
-        prefix?: string;
-    });
-    private get client();
-    /**
-     * Register a scheduled job.
-     */
-    register(config: Omit<ScheduledJobConfig, 'nextRun' | 'enabled'>): Promise<void>;
-    /**
-     * Remove a scheduled job.
-     */
-    remove(id: string): Promise<void>;
-    /**
-     * List all scheduled jobs.
-     */
-    list(): Promise<ScheduledJobConfig[]>;
-    /**
-     * Run a scheduled job immediately (out of schedule).
-     */
-    runNow(id: string): Promise<void>;
-    /**
-     * Process due tasks (TICK).
-     * This should be called periodically (e.g. every minute).
-     */
-    tick(): Promise<number>;
-}
-
-/**
- * Job serializer interface.
- *
- * Responsible for serializing and deserializing jobs.
- * Supports multiple strategies (JSON, class-name, etc.).
- *
- * @example
- * ```typescript
- * class MySerializer implements JobSerializer {
- *   serialize(job: Job): SerializedJob {
- *     // serialization logic
- *   }
- *
- *   deserialize(serialized: SerializedJob): Job {
- *     // deserialization logic
- *   }
- * }
- * ```
- */
-interface JobSerializer {
-    /**
-     * Serialize a job.
-     * @param job - Job instance
-     * @returns Serialized job payload
-     */
-    serialize(job: Job): SerializedJob;
-    /**
-     * Deserialize a job.
-     * @param serialized - Serialized job payload
-     * @returns Job instance
-     */
-    deserialize(serialized: SerializedJob): Job;
-}
-
-/**
- * Queue Manager
- *
- * Manages multiple queue connections and drivers, exposing a unified API for pushing and consuming jobs.
- * Supports lazy-loading drivers to keep the core lightweight.
- *
- * @example
- * ```typescript
- * const manager = new QueueManager({
- *   default: 'database',
- *   connections: {
- *     database: { driver: 'database', table: 'jobs' },
- *     redis: { driver: 'redis', url: 'redis://...' }
- *   }
- * })
- *
- * await manager.push(new SendEmail('user@example.com'))
- * ```
- */
-declare class QueueManager {
-    private drivers;
-    private serializers;
-    private defaultConnection;
-    private defaultSerializer;
-    private persistence?;
-    private scheduler?;
-    private debug;
-    constructor(config?: QueueConfig);
-    /**
-     * Log debug message.
-     */
-    private log;
-    /**
-     * Register a connection.
-     * @param name - Connection name
-     * @param config - Connection config
-     */
-    registerConnection(name: string, config: QueueConnectionConfig): void;
-    /**
-     * Get a driver for a connection.
-     * @param connection - Connection name
-     * @returns Driver instance
-     */
-    getDriver(connection: string): QueueDriver;
-    /**
-     * Get the default connection name.
-     * @returns Default connection name
-     */
-    getDefaultConnection(): string;
-    /**
-     * Get a serializer.
-     * @param type - Serializer type
-     * @returns Serializer instance
-     */
-    getSerializer(type?: string): JobSerializer;
-    /**
-     * Register Job classes (used by ClassNameSerializer).
-     * @param jobClasses - Job class array
-     */
-    registerJobClasses(jobClasses: Array<new (...args: unknown[]) => Job>): void;
-    /**
-     * Push a Job to the queue.
-     *
-     * @template T - The type of the job.
-     * @param job - Job instance to push.
-     * @param options - Push options.
-     * @returns The same job instance (for fluent chaining).
-     *
-     * @example
-     * ```typescript
-     * await manager.push(new SendEmailJob('user@example.com'));
-     * ```
-     */
-    push<T extends Job & Queueable>(job: T, options?: JobPushOptions): Promise<T>;
-    /**
-     * Push multiple jobs to the queue.
-     *
-     * @template T - The type of the jobs.
-     * @param jobs - Array of job instances.
-     * @param options - Bulk push options.
-     *
-     * @example
-     * ```typescript
-     * await manager.pushMany(jobs, { batchSize: 500, concurrency: 2 });
-     * ```
-     */
-    pushMany<T extends Job & Queueable>(jobs: T[], options?: {
-        batchSize?: number;
-        concurrency?: number;
-    }): Promise<void>;
-    /**
-     * Pop a job from the queue.
-     *
-     * @param queue - Queue name (default: 'default').
-     * @param connection - Connection name (optional).
-     * @returns Job instance or null if queue is empty.
-     *
-     * @example
-     * ```typescript
-     * const job = await manager.pop('emails');
-     * if (job) await job.handle();
-     * ```
-     */
-    pop(queue?: string, connection?: string): Promise<Job | null>;
-    /**
-     * Pop multiple jobs from the queue.
-     *
-     * @param queue - Queue name (default: 'default').
-     * @param count - Number of jobs to pop (default: 10).
-     * @param connection - Connection name (optional).
-     * @returns Array of Job instances.
-     */
-    popMany(queue?: string, count?: number, connection?: string): Promise<Job[]>;
-    /**
-     * Get queue size.
-     *
-     * @param queue - Queue name (default: 'default').
-     * @param connection - Connection name (optional).
-     * @returns Number of jobs in the queue.
-     */
-    size(queue?: string, connection?: string): Promise<number>;
-    /**
-     * Pop a job from the queue (blocking).
-     *
-     * @param queue - Queue name (default: 'default').
-     * @param timeout - Timeout in seconds (default: 0, wait forever).
-     * @param connection - Connection name (optional).
-     */
-    popBlocking(queues?: string | string[], timeout?: number, connection?: string): Promise<Job | null>;
-    /**
-     * Clear all jobs from a queue.
-     *
-     * @param queue - Queue name (default: 'default').
-     * @param connection - Connection name (optional).
-     */
-    clear(queue?: string, connection?: string): Promise<void>;
-    /**
-     * Get queue statistics including size, delayed, and failed job counts.
-     *
-     * @param queue - Queue name (default: 'default').
-     * @param connection - Connection name (optional).
-     * @returns Queue statistics object.
-     */
-    stats(queue?: string, connection?: string): Promise<QueueStats>;
-    /**
-     * Mark a job as completed.
-     * @param job - Job instance
-     */
-    complete<T extends Job & Queueable>(job: T): Promise<void>;
-    /**
-     * Mark a job as permanently failed.
-     * @param job - Job instance
-     * @param error - Error object
-     */
-    fail<T extends Job & Queueable>(job: T, error: Error): Promise<void>;
-    /**
-     * Get the persistence adapter if configured.
-     */
-    getPersistence(): PersistenceAdapter | undefined;
-    /**
-     * Get the scheduler if configured.
-     */
-    getScheduler(): Scheduler;
-    /**
-     * Get failed jobs from DLQ (if driver supports it).
-     */
-    getFailed(queue: string, start?: number, end?: number, connection?: string): Promise<SerializedJob[]>;
-    /**
-     * Retry failed jobs from DLQ (if driver supports it).
-     */
-    retryFailed(queue: string, count?: number, connection?: string): Promise<number>;
-    /**
-     * Clear failed jobs from DLQ (if driver supports it).
-     */
-    clearFailed(queue: string, connection?: string): Promise<void>;
-}
-
-/**
- * Worker options.
- */
-interface WorkerOptions {
-    /**
-     * Maximum retry attempts.
-     */
-    maxAttempts?: number;
-    /**
-     * Job timeout (seconds).
-     */
-    timeout?: number;
-    /**
-     * Failure callback.
-     */
-    onFailed?: (job: Job, error: Error) => Promise<void>;
-}
-/**
- * Base Worker.
- *
- * Responsible for executing `Job` instances.
- * Provides error handling, retry logic, and timeout support.
- *
- * @example
- * ```typescript
- * const worker = new Worker({
- *   maxAttempts: 3,
- *   timeout: 60
- * })
- *
- * await worker.process(job)
- * ```
- */
-declare class Worker {
-    private options;
-    constructor(options?: WorkerOptions);
-    /**
-     * Process a Job.
-     * @param job - Job instance
-     */
-    process(job: Job): Promise<void>;
-    /**
-     * Handle failure.
-     */
-    private handleFailure;
-}
-
-/**
- * Consumer options.
- */
-interface ConsumerOptions {
-    /**
-     * Queues to listen on.
-     */
-    queues: string[];
-    /**
-     * Connection name.
-     */
-    connection?: string;
-    /**
-     * Worker options.
-     */
-    workerOptions?: WorkerOptions;
-    /**
-     * Polling interval (milliseconds).
-     */
-    pollInterval?: number;
-    /**
-     * Whether to keep polling when queues are empty.
-     */
-    keepAlive?: boolean;
-    /**
-     * Monitoring options.
-     */
-    monitor?: boolean | {
-        /**
-         * Heartbeat interval (milliseconds). Default: 5000.
-         */
-        interval?: number;
-        /**
-         * Extra info to report with heartbeat.
-         */
-        extraInfo?: Record<string, unknown>;
-        /**
-         * Prefix for monitoring keys/channels.
-         */
-        prefix?: string;
-    };
-    /**
-     * Rate limits per queue.
-     * Example: { 'emails': { max: 10, duration: 1000 } }
-     */
-    rateLimits?: Record<string, {
-        max: number;
-        duration: number;
-    }>;
-    /**
-     * Max concurrent jobs to process. Default: 1.
-     */
-    concurrency?: number;
-    /**
-     * Whether to process jobs with the same groupId sequentially.
-     * If true, jobs with the same groupId will never run concurrently,
-     * regardless of the global concurrency setting.
-     * @default true
-     */
-    groupJobsSequential?: boolean;
-    /**
-     * Minimum polling interval in ms (for adaptive polling).
-     * @default 100
-     */
-    minPollInterval?: number;
-    /**
-     * Maximum polling interval in ms (for adaptive polling).
-     * @default 5000
-     */
-    maxPollInterval?: number;
-    /**
-     * Backoff multiplier for adaptive polling.
-     * @default 1.5
-     */
-    backoffMultiplier?: number;
-    /**
-     * Batch size for consuming jobs.
-     * If > 1, tries to fetch multiple jobs at once.
-     * @default 1
-     */
-    batchSize?: number;
-    /**
-     * Whether to use blocking pop (BLPOP/long-polling) if supported by driver.
-     * Only applies when batchSize is 1.
-     * @default true
-     */
-    useBlocking?: boolean;
-    /**
-     * Timeout in seconds for blocking pop.
-     * @default 5
-     */
-    blockingTimeout?: number;
-    /**
-     * Enable verbose debug logging.
-     * @default false
-     */
-    debug?: boolean;
-}
-/**
- * Consumer
- *
- * Consumes and executes jobs from queues.
- * Supports embedded mode (inside the main app) and standalone mode (as a worker service).
- *
- * @example
- * ```typescript
- * // Embedded mode
- * const consumer = new Consumer(queueManager, {
- *   queues: ['default', 'emails'],
- *   pollInterval: 1000
- * })
- *
- * consumer.start()
- *
- * // Standalone mode (CLI)
- * // Start via CLI tooling with graceful shutdown
- * ```
- *
- * @emits job:started - When a job begins processing. Payload: { job: Job, queue: string }
- * @emits job:processed - When a job completes successfully. Payload: { job: Job, duration: number, queue: string }
- * @emits job:failed - When a job fails an attempt. Payload: { job: Job, error: Error, duration: number, queue: string }
- * @emits job:retried - When a job is scheduled for a retry. Payload: { job: Job, attempt: number, delay: number }
- * @emits job:failed_permanently - When a job fails all attempts and is moved to DLQ. Payload: { job: Job, error: Error }
- */
-declare class Consumer extends EventEmitter {
-    private queueManager;
-    private options;
-    private running;
-    private stopRequested;
-    private workerId;
-    private heartbeatTimer;
-    private groupLimiters;
-    private stats;
-    constructor(queueManager: QueueManager, options: ConsumerOptions);
-    private get connectionName();
-    /**
-     * Log debug message.
-     */
-    private log;
-    /**
-     * Start the consumer loop.
-     */
-    start(): Promise<void>;
-    /**
-     * Run a job with concurrency controls.
-     */
-    private runJob;
-    /**
-     * Handle a single job.
-     */
-    private handleJob;
-    private startHeartbeat;
-    private stopHeartbeat;
-    private publishLog;
-    /**
-     * Stop the consumer loop (graceful shutdown).
-     */
-    stop(): Promise<void>;
-    /**
-     * Check whether the consumer is running.
-     */
-    isRunning(): boolean;
-    /**
-     * Get current consumer statistics.
-     */
-    getStats(): {
-        processed: number;
-        failed: number;
-        retried: number;
-        active: number;
-    };
-    /**
-     * Reset statistics counters.
-     */
-    resetStats(): void;
-}
-
-/**
- * Generic database service interface.
- * Users should implement this interface with their preferred ORM/database client.
- */
-interface DatabaseService {
-    /**
-     * Execute a raw SQL query.
-     * @param sql - The SQL query string with placeholders ($1, $2, etc.)
-     * @param bindings - The values to bind to placeholders
-     */
-    execute<T = unknown>(sql: string, bindings?: unknown[]): Promise<T[] | T>;
-    /**
-     * Execute multiple queries within a transaction.
-     * @param callback - The callback to execute within the transaction
-     */
-    transaction<T>(callback: (tx: DatabaseService) => Promise<T>): Promise<T>;
-}
-/**
- * Database driver configuration.
- */
-interface DatabaseDriverConfig {
-    /**
-     * Table name (default: `jobs`).
-     */
-    table?: string;
-    /**
-     * Database service instance that implements DatabaseService interface.
-     */
-    dbService?: DatabaseService;
-}
-/**
- * Database Driver
- *
- * Uses a database as the queue backend.
- * Works with any database service that implements the DatabaseService interface.
- *
- * @example
- * ```typescript
- * // Create a database service adapter
- * const dbService = {
- *   execute: async (sql, bindings) => yourDbClient.query(sql, bindings),
- *   transaction: async (callback) => yourDbClient.transaction(callback),
- * }
- *
- * const driver = new DatabaseDriver({ dbService, table: 'jobs' })
- * await driver.push('default', serializedJob)
- * ```
- */
-declare class DatabaseDriver implements QueueDriver {
-    private tableName;
-    private dbService;
-    constructor(config: DatabaseDriverConfig);
-    /**
-     * Push a job to a queue.
-     */
-    push(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Pop a job from the queue (FIFO, with delay support).
-     */
-    pop(queue: string): Promise<SerializedJob | null>;
-    /**
-     * Pop multiple jobs from the queue.
-     */
-    popMany(queue: string, count: number): Promise<SerializedJob[]>;
-    /**
-     * Get queue statistics.
-     */
-    stats(queue: string): Promise<QueueStats>;
-    /**
-     * Get queue size.
-     */
-    size(queue: string): Promise<number>;
-    /**
-     * Clear a queue.
-     */
-    clear(queue: string): Promise<void>;
-    /**
-     * Pop a job from the queue (blocking).
-     * Simple polling fallback for databases.
-     */
-    popBlocking(queue: string, timeout: number): Promise<SerializedJob | null>;
-    /**
-     * Push multiple jobs.
-     * Optimizes by using a single multi-row insert if possible.
-     */
-    pushMany(queue: string, jobs: SerializedJob[]): Promise<void>;
-    /**
-     * Mark a job as failed (DLQ).
-     */
-    fail(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Acknowledge/Complete a job.
-     */
-    complete(_queue: string, job: SerializedJob): Promise<void>;
-}
-
-/**
- * Kafka driver configuration.
- */
-interface KafkaDriverConfig {
-    /**
-     * Kafka client instance (kafkajs).
-     */
-    client: {
-        producer: () => {
-            connect: () => Promise<void>;
-            send: (args: {
-                topic: string;
-                messages: Array<{
-                    key?: string;
-                    value: string;
-                }>;
-            }) => Promise<void>;
-            disconnect: () => Promise<void>;
-        };
-        admin: () => {
-            connect: () => Promise<void>;
-            createTopics: (args: {
-                topics: Array<{
-                    topic: string;
-                    numPartitions?: number;
-                    replicationFactor?: number;
-                }>;
-            }) => Promise<void>;
-            deleteTopics: (args: {
-                topics: string[];
-            }) => Promise<void>;
-            disconnect: () => Promise<void>;
-        };
-        consumer: (args: {
-            groupId: string;
-        }) => {
-            connect: () => Promise<void>;
-            subscribe: (args: {
-                topics: string[];
-            }) => Promise<void>;
-            run: (args: {
-                eachMessage: (args: {
-                    topic: string;
-                    partition: number;
-                    message: {
-                        key?: Buffer;
-                        value: Buffer;
-                        offset: string;
-                    };
-                }) => Promise<void>;
-            }) => Promise<void>;
-            disconnect: () => Promise<void>;
-        };
-    };
-    /**
-     * Consumer group ID (for consuming messages).
-     */
-    consumerGroupId?: string;
-}
-/**
- * Kafka Driver
- *
- * Uses Apache Kafka as the queue backend.
- * Supports topic management, consumer groups, and batch operations.
- *
- * Requires `kafkajs`.
- *
- * @example
- * ```typescript
- * import { Kafka } from 'kafkajs'
- *
- * const kafka = new Kafka({
- *   brokers: ['localhost:9092'],
- *   clientId: 'gravito-app'
- * })
- *
- * const driver = new KafkaDriver({ client: kafka, consumerGroupId: 'workers' })
- * await driver.push('default', serializedJob)
- * ```
- */
-declare class KafkaDriver implements QueueDriver {
-    private client;
-    private consumerGroupId;
-    private producer?;
-    private admin?;
-    constructor(config: KafkaDriverConfig);
-    /**
-     * Ensure the producer is connected.
-     */
-    private ensureProducer;
-    /**
-     * Ensure the admin client is connected.
-     */
-    private ensureAdmin;
-    /**
-     * Push a job to a topic.
-     */
-    push(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Pop is not supported for Kafka.
-     *
-     * Note: Kafka uses a push-based model, so you should use `subscribe()`.
-     */
-    pop(_queue: string): Promise<SerializedJob | null>;
-    /**
-     * Kafka does not provide a direct queue size.
-     *
-     * Returns 0; use Kafka tooling/metrics for lag/size insights.
-     */
-    size(_queue: string): Promise<number>;
-    /**
-     * Clear a queue by deleting the topic.
-     */
-    clear(queue: string): Promise<void>;
-    /**
-     * Push multiple jobs.
-     */
-    pushMany(queue: string, jobs: SerializedJob[]): Promise<void>;
-    /**
-     * Create a topic.
-     */
-    createTopic(topic: string, options?: TopicOptions): Promise<void>;
-    /**
-     * Delete a topic.
-     */
-    deleteTopic(topic: string): Promise<void>;
-    /**
-     * Subscribe to a topic (push-based model).
-     */
-    subscribe(queue: string, callback: (job: SerializedJob) => Promise<void>): Promise<void>;
-}
-
-interface MemoryDriverConfig {
-    /**
-     * Maximum number of jobs per queue.
-     * @default Infinity
-     */
-    maxSize?: number;
-}
-/**
- * Memory Driver
- *
- * In-memory driver for development and testing.
- * All data is stored in memory and will be lost when the process restarts.
- *
- * Zero-config: works out of the box.
- *
- * @example
- * ```typescript
- * const driver = new MemoryDriver({ maxSize: 1000 })
- * await driver.push('default', serializedJob)
- * const job = await driver.pop('default')
- * ```
- */
-declare class MemoryDriver implements QueueDriver {
-    private queues;
-    private maxSize;
-    constructor(config?: MemoryDriverConfig);
-    /**
-     * Push a job to a queue.
-     */
-    push(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Pop a job from a queue (FIFO).
-     */
-    pop(queue: string): Promise<SerializedJob | null>;
-    /**
-     * Get queue size.
-     */
-    size(queue: string): Promise<number>;
-    /**
-     * Clear a queue.
-     */
-    clear(queue: string): Promise<void>;
-    /**
-     * Mark a job as permanently failed.
-     */
-    fail(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Get queue statistics.
-     */
-    stats(queue: string): Promise<QueueStats>;
-    /**
-     * Push multiple jobs.
-     */
-    pushMany(queue: string, jobs: SerializedJob[]): Promise<void>;
-    /**
-     * Pop multiple jobs.
-     */
-    popMany(queue: string, count: number): Promise<SerializedJob[]>;
-}
-
-/**
- * RabbitMQ driver configuration.
- */
-interface RabbitMQDriverConfig {
-    /**
-     * RabbitMQ client (amqplib) Connection or Channel.
-     * If a Connection is provided, the driver will create and manage a Channel.
-     */
-    client: any;
-    /**
-     * Exchange name (optional).
-     */
-    exchange?: string;
-    /**
-     * Exchange type (default: 'fanout').
-     */
-    exchangeType?: 'direct' | 'topic' | 'headers' | 'fanout' | 'match';
-}
-/**
- * RabbitMQ Driver
- *
- * Uses RabbitMQ as the queue backend.
- * Implements FIFO via RabbitMQ Queues.
- *
- * Requires `amqplib`.
- *
- * @example
- * ```typescript
- * import amqp from 'amqplib'
- *
- * const connection = await amqp.connect('amqp://localhost')
- * const driver = new RabbitMQDriver({ client: connection })
- *
- * await driver.push('default', serializedJob)
- * ```
- */
-declare class RabbitMQDriver implements QueueDriver {
-    private connection;
-    private channel;
-    private exchange?;
-    private exchangeType;
-    constructor(config: RabbitMQDriverConfig);
-    /**
-     * Ensure channel is created.
-     */
-    ensureChannel(): Promise<any>;
-    /**
-     * Get the underlying connection.
-     */
-    getRawConnection(): any;
-    /**
-     * Push a job (sendToQueue / publish).
-     */
-    push(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Pop a job (get).
-     */
-    pop(queue: string): Promise<SerializedJob | null>;
-    /**
-     * Pop multiple jobs.
-     * Uses channel.get() in a loop (no native batch get in AMQP).
-     */
-    popMany(queue: string, count: number): Promise<SerializedJob[]>;
-    /**
-     * Acknowledge a message.
-     */
-    acknowledge(messageId: string): Promise<void>;
-    /**
-     * Negative acknowledge a message.
-     */
-    nack(message: any, requeue?: boolean): Promise<void>;
-    /**
-     * Reject a message.
-     */
-    reject(message: any, requeue?: boolean): Promise<void>;
-    /**
-     * Subscribe to a queue.
-     */
-    subscribe(queue: string, callback: (job: SerializedJob) => Promise<void>, options?: {
-        autoAck?: boolean;
-        prefetch?: number;
-    }): Promise<void>;
-    /**
-     * Get queue size.
-     */
-    size(queue: string): Promise<number>;
-    /**
-     * Clear a queue.
-     */
-    clear(queue: string): Promise<void>;
-}
-
-/**
- * Interface for Redis clients (compatible with ioredis and node-redis).
- */
-interface RedisClient {
-    lpush(key: string, ...values: string[]): Promise<number>;
-    rpop(key: string, count?: number): Promise<string | string[] | null>;
-    llen(key: string): Promise<number>;
-    del(key: string, ...keys: string[]): Promise<number>;
-    lpushx?(key: string, ...values: string[]): Promise<number>;
-    rpoplpush?(src: string, dst: string): Promise<string | null>;
-    zadd?(key: string, score: number, member: string): Promise<number>;
-    zrange?(key: string, start: number, end: number, ...args: string[]): Promise<string[]>;
-    zrem?(key: string, ...members: string[]): Promise<number>;
-    get?(key: string): Promise<string | null>;
-    set?(key: string, value: string, ...args: any[]): Promise<'OK' | null>;
-    ltrim?(key: string, start: number, stop: number): Promise<'OK'>;
-    lrange?(key: string, start: number, stop: number): Promise<string[]>;
-    publish?(channel: string, message: string): Promise<number>;
-    pipeline?(): any;
-    defineCommand?(name: string, options: {
-        numberOfKeys: number;
-        lua: string;
-    }): void;
-    incr?(key: string): Promise<number>;
-    expire?(key: string, seconds: number): Promise<number>;
-    eval(script: string, numKeys: number, ...args: (string | number)[]): Promise<any>;
-    [key: string]: any;
-}
-/**
- * Redis driver configuration.
- */
-interface RedisDriverConfig {
-    /**
-     * Redis client instance (ioredis or node-redis).
-     */
-    client: RedisClient;
-    /**
-     * Key prefix (default: `queue:`).
-     */
-    prefix?: string;
-}
-/**
- * Redis Driver
- *
- * Uses Redis as the queue backend.
- * Implements FIFO via Redis Lists (LPUSH/RPOP).
- *
- * Requires `ioredis` or `redis`.
- *
- * @example
- * ```typescript
- * import Redis from 'ioredis'
- *
- * const redis = new Redis('redis://localhost:6379')
- * const redis = new Redis('ioredis://localhost:6379')
- * const driver = new RedisDriver({ client: redis })
- *
- * await driver.push('default', serializedJob)
- * ```
- */
-declare class RedisDriver implements QueueDriver {
-    private prefix;
-    private client;
-    private static PUSH_SCRIPT;
-    private static COMPLETE_SCRIPT;
-    private static POP_MANY_SCRIPT;
-    constructor(config: RedisDriverConfig);
-    /**
-     * Get full Redis key for a queue.
-     */
-    private getKey;
-    /**
-     * Push a job (LPUSH).
-     */
-    push(queue: string, job: SerializedJob, options?: JobPushOptions): Promise<void>;
-    /**
-     * Complete a job (handle Group FIFO).
-     */
-    complete(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Pop a job from a queue (non-blocking).
-     * Optimized with Lua script for atomic priority polling.
-     */
-    pop(queue: string): Promise<SerializedJob | null>;
-    /**
-     * Manual fallback for pop if Lua fails.
-     */
-    private popManualFallback;
-    /**
-     * Pop a job from the queue (blocking).
-     * Uses BRPOP for efficiency. Supports multiple queues and priorities.
-     */
-    popBlocking(queues: string | string[], timeout: number): Promise<SerializedJob | null>;
-    /**
-     * Parse Redis payload.
-     */
-    private parsePayload;
-    /**
-     * Get queue size.
-     */
-    size(queue: string): Promise<number>;
-    /**
-     * Mark a job as permanently failed (DLQ).
-     */
-    fail(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Clear a queue.
-     */
-    clear(queue: string): Promise<void>;
-    /**
-     * Get queue statistics.
-     * Optimized with Redis Pipeline to fetch all priorities and DLQ stats in one trip.
-     */
-    stats(queue: string): Promise<QueueStats>;
-    /**
-     * Push multiple jobs.
-     */
-    pushMany(queue: string, jobs: SerializedJob[]): Promise<void>;
-    /**
-     * Pop multiple jobs.
-     * Atomic operation across multiple priority levels.
-     */
-    popMany(queue: string, count: number): Promise<SerializedJob[]>;
-    /**
-     * Report worker heartbeat for monitoring.
-     */
-    reportHeartbeat(workerInfo: any, prefix?: string): Promise<void>;
-    /**
-     * Publish a log message for monitoring.
-     */
-    publishLog(logPayload: any, prefix?: string): Promise<void>;
-    /**
-     * Check if a queue is rate limited.
-     * Uses a fixed window counter.
-     */
-    checkRateLimit(queue: string, config: {
-        max: number;
-        duration: number;
-    }): Promise<boolean>;
-    /**
-     * Get failed jobs from DLQ.
-     */
-    getFailed(queue: string, start?: number, end?: number): Promise<SerializedJob[]>;
-    /**
-     * Retry failed jobs from DLQ.
-     * Moves jobs from failed list back to the main queue.
-     */
-    retryFailed(queue: string, count?: number): Promise<number>;
-    /**
-     * Clear failed jobs from DLQ.
-     */
-    clearFailed(queue: string): Promise<void>;
-}
-
-/**
- * SQS driver configuration.
- */
-interface SQSDriverConfig {
-    /**
-     * SQS client instance (`@aws-sdk/client-sqs`).
-     */
-    client: {
-        send: (command: unknown) => Promise<{
-            MessageId?: string;
-            Messages?: Array<{
-                MessageId?: string;
-                ReceiptHandle?: string;
-                Body?: string;
-            }>;
-        }>;
-    };
-    /**
-     * Queue URL prefix (used to build full queue URLs).
-     */
-    queueUrlPrefix?: string;
-    /**
-     * Visibility timeout (seconds, default: 30).
-     */
-    visibilityTimeout?: number;
-    /**
-     * Long-polling duration (seconds, default: 20).
-     */
-    waitTimeSeconds?: number;
-}
-/**
- * SQS Driver
- *
- * Uses AWS SQS as the queue backend.
- * Supports standard/FIFO queues, long polling, DLQ setups, etc.
- *
- * Requires `@aws-sdk/client-sqs`.
- *
- * @example
- * ```typescript
- * import { SQSClient } from '@aws-sdk/client-sqs'
- *
- * const sqs = new SQSClient({
- *   region: 'us-east-1',
- *   credentials: {
- *     accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
- *     secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
- *   }
- * })
- *
- * const driver = new SQSDriver({ client: sqs })
- * await driver.push('default', serializedJob)
- * ```
- */
-declare class SQSDriver implements QueueDriver {
-    private client;
-    private queueUrlPrefix;
-    private visibilityTimeout;
-    private waitTimeSeconds;
-    private queueUrls;
-    constructor(config: SQSDriverConfig);
-    /**
-     * Resolve the full queue URL.
-     */
-    private getQueueUrl;
-    /**
-     * Push a job to SQS.
-     */
-    push(queue: string, job: SerializedJob): Promise<void>;
-    /**
-     * Pop a job (long polling).
-     */
-    pop(queue: string): Promise<SerializedJob | null>;
-    /**
-     * Pop multiple jobs.
-     * Leverages SQS MaxNumberOfMessages (up to 10).
-     */
-    popMany(queue: string, count: number): Promise<SerializedJob[]>;
-    /**
-     * Get queue size (approximate).
-     */
-    size(queue: string): Promise<number>;
-    /**
-     * Clear a queue by receiving and deleting messages.
-     *
-     * Note: SQS does not provide a direct "purge" API via this wrapper. This method will
-     * keep receiving and deleting messages until the queue is empty.
-     */
-    clear(queue: string): Promise<void>;
-    /**
-     * Push multiple jobs.
-     */
-    pushMany(queue: string, jobs: SerializedJob[]): Promise<void>;
-    /**
-     * Acknowledge is not supported via messageId.
-     */
-    acknowledge(_messageId: string): Promise<void>;
-    /**
-     * Delete a message (acknowledge processing completion).
-     */
-    deleteMessage(queue: string, receiptHandle: string): Promise<void>;
-}
-
-/**
- * Options for configuring OrbitStream (Queue Orbit).
- * @public
- */
-interface OrbitStreamOptions extends QueueConfig {
-    /**
-     * Whether to automatically start an embedded worker in development mode.
-     * Useful for simple local testing without running a separate worker process.
-     */
-    autoStartWorker?: boolean;
-    /**
-     * Configuration for the embedded worker/consumer.
-     */
-    workerOptions?: ConsumerOptions;
-}
-/**
- * OrbitStream provides a powerful, multi-driver queue system for Gravito.
- * It integrates with various backends (Redis, Database, SQS, RabbitMQ)
- * and supports job serialization, delayed jobs, and FIFO processing.
- *
- * @example
- * ```typescript
- * const stream = new OrbitStream({
- *   default: 'redis',
- *   connections: {
- *     redis: { driver: 'redis', host: 'localhost' }
- *   }
- * });
- * core.addOrbit(stream);
- * ```
- * @public
- */
-declare class OrbitStream implements GravitoOrbit {
-    private options;
-    private queueManager?;
-    private consumer?;
-    constructor(options?: OrbitStreamOptions);
-    /**
-     * Static configuration helper.
-     */
-    static configure(options: OrbitStreamOptions): OrbitStream;
-    /**
-     * Install into PlanetCore.
-     */
-    install(core: PlanetCore): void;
-    /**
-     * Start embedded worker.
-     */
-    startWorker(options: ConsumerOptions): void;
-    /**
-     * Stop embedded worker.
-     */
-    stopWorker(): Promise<void>;
-    /**
-     * Get QueueManager instance.
-     */
-    getQueueManager(): QueueManager | undefined;
-}
-declare module '@gravito/core' {
-    interface GravitoVariables {
-        /** Queue manager for job processing */
-        queue?: QueueManager;
-        /** Database service (from orbit-db) */
-        db?: unknown;
-    }
-}
-
-/**
- * Buffered Persistence Wrapper.
- * Wraps any PersistenceAdapter to add buffering and batch writing capabilities.
- */
-declare class BufferedPersistence implements PersistenceAdapter {
-    private adapter;
-    private jobBuffer;
-    private logBuffer;
-    private flushTimer;
-    private maxBufferSize;
-    private flushInterval;
-    constructor(adapter: PersistenceAdapter, options?: {
-        maxBufferSize?: number;
-        flushInterval?: number;
-    });
-    archive(queue: string, job: SerializedJob, status: 'completed' | 'failed' | 'waiting' | string): Promise<void>;
-    find(queue: string, id: string): Promise<SerializedJob | null>;
-    list(queue: string, options?: {
-        limit?: number;
-        offset?: number;
-        status?: 'completed' | 'failed' | 'waiting' | string;
-        jobId?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<SerializedJob[]>;
-    archiveMany(jobs: Array<{
-        queue: string;
-        job: SerializedJob;
-        status: 'completed' | 'failed' | 'waiting' | string;
-    }>): Promise<void>;
-    cleanup(days: number): Promise<number>;
-    flush(): Promise<void>;
-    count(queue: string, options?: {
-        status?: 'completed' | 'failed' | 'waiting' | string;
-        jobId?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<number>;
-    archiveLog(log: {
-        level: string;
-        message: string;
-        workerId: string;
-        queue?: string;
-        timestamp: Date;
-    }): Promise<void>;
-    archiveLogMany(logs: Array<{
-        level: string;
-        message: string;
-        workerId: string;
-        queue?: string;
-        timestamp: Date;
-    }>): Promise<void>;
-    listLogs(options?: {
-        limit?: number;
-        offset?: number;
-        level?: string;
-        workerId?: string;
-        queue?: string;
-        search?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<any[]>;
-    countLogs(options?: {
-        level?: string;
-        workerId?: string;
-        queue?: string;
-        search?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<number>;
-    private ensureFlushTimer;
-}
-
-/**
- * MySQL Persistence Adapter.
- * Archives jobs into a MySQL table for long-term auditing.
- */
-declare class MySQLPersistence implements PersistenceAdapter {
-    private db;
-    private table;
-    private logsTable;
-    /**
-     * @param db - An Atlas DB instance or compatible QueryBuilder.
-     * @param table - The name of the table to store archived jobs.
-     * @param logsTable - The name of the table to store system logs.
-     * @param options - Buffering options (Deprecated: Use BufferedPersistence wrapper instead).
-     */
-    constructor(db: ConnectionContract, table?: string, logsTable?: string, _options?: {
-        maxBufferSize?: number;
-        flushInterval?: number;
-    });
-    archive(queue: string, job: SerializedJob, status: 'completed' | 'failed' | 'waiting' | string): Promise<void>;
-    archiveMany(jobs: Array<{
-        queue: string;
-        job: SerializedJob;
-        status: 'completed' | 'failed' | 'waiting' | string;
-    }>): Promise<void>;
-    flush(): Promise<void>;
-    find(queue: string, id: string): Promise<SerializedJob | null>;
-    /**
-     * List jobs from the archive.
-     */
-    list(queue: string, options?: {
-        limit?: number;
-        offset?: number;
-        status?: 'completed' | 'failed' | 'waiting' | string;
-        jobId?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<SerializedJob[]>;
-    /**
-     * Search jobs from the archive.
-     */
-    search(query: string, options?: {
-        limit?: number;
-        offset?: number;
-        queue?: string;
-    }): Promise<SerializedJob[]>;
-    /**
-     * Archive a system log message (buffered).
-     */
-    archiveLog(log: {
-        level: string;
-        message: string;
-        workerId: string;
-        queue?: string;
-        timestamp: Date;
-    }): Promise<void>;
-    /**
-     * Archive multiple log messages (direct batch write).
-     */
-    archiveLogMany(logs: Array<{
-        level: string;
-        message: string;
-        workerId: string;
-        queue?: string;
-        timestamp: Date;
-    }>): Promise<void>;
-    /**
-     * List system logs from the archive.
-     */
-    listLogs(options?: {
-        limit?: number;
-        offset?: number;
-        level?: string;
-        workerId?: string;
-        queue?: string;
-        search?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<any[]>;
-    /**
-     * Count system logs in the archive.
-     */
-    countLogs(options?: {
-        level?: string;
-        workerId?: string;
-        queue?: string;
-        search?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<number>;
-    /**
-     * Remove old records from the archive.
-     */
-    cleanup(days: number): Promise<number>;
-    /**
-     * Count jobs in the archive.
-     */
-    count(queue: string, options?: {
-        status?: 'completed' | 'failed' | 'waiting' | string;
-        jobId?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<number>;
-    /**
-     * Help script to create the necessary table.
-     */
-    setupTable(): Promise<void>;
-    private setupJobsTable;
-    private setupLogsTable;
-}
-
-/**
- * SQLite Persistence Adapter.
- * Archives jobs into a local SQLite database for zero-config persistence.
- */
-declare class SQLitePersistence implements PersistenceAdapter {
-    private db;
-    private table;
-    private logsTable;
-    /**
-     * @param db - An Atlas DB instance (SQLite driver).
-     * @param table - The name of the table to store archived jobs.
-     * @param logsTable - The name of the table to store system logs.
-     * @param options - Buffering options (Deprecated: Use BufferedPersistence wrapper instead).
-     */
-    constructor(db: ConnectionContract, table?: string, logsTable?: string, _options?: {
-        maxBufferSize?: number;
-        flushInterval?: number;
-    });
-    archive(queue: string, job: SerializedJob, status: 'completed' | 'failed' | 'waiting' | string): Promise<void>;
-    archiveMany(jobs: Array<{
-        queue: string;
-        job: SerializedJob;
-        status: 'completed' | 'failed' | 'waiting' | string;
-    }>): Promise<void>;
-    flush(): Promise<void>;
-    find(queue: string, id: string): Promise<SerializedJob | null>;
-    /**
-     * List jobs from the archive.
-     */
-    list(queue: string, options?: {
-        limit?: number;
-        offset?: number;
-        status?: 'completed' | 'failed' | 'waiting' | string;
-        jobId?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<SerializedJob[]>;
-    /**
-     * Search jobs from the archive.
-     */
-    search(query: string, options?: {
-        limit?: number;
-        offset?: number;
-        queue?: string;
-    }): Promise<SerializedJob[]>;
-    /**
-     * Archive a system log message (buffered).
-     */
-    archiveLog(log: {
-        level: string;
-        message: string;
-        workerId: string;
-        queue?: string;
-        timestamp: Date;
-    }): Promise<void>;
-    /**
-     * Archive multiple log messages (direct batch write).
-     */
-    archiveLogMany(logs: Array<{
-        level: string;
-        message: string;
-        workerId: string;
-        queue?: string;
-        timestamp: Date;
-    }>): Promise<void>;
-    /**
-     * List system logs from the archive.
-     */
-    listLogs(options?: {
-        limit?: number;
-        offset?: number;
-        level?: string;
-        workerId?: string;
-        queue?: string;
-        search?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<any[]>;
-    /**
-     * Count system logs in the archive.
-     */
-    countLogs(options?: {
-        level?: string;
-        workerId?: string;
-        queue?: string;
-        search?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<number>;
-    /**
-     * Remove old records from the archive.
-     */
-    cleanup(days: number): Promise<number>;
-    /**
-     * Count jobs in the archive.
-     */
-    count(queue: string, options?: {
-        status?: 'completed' | 'failed' | 'waiting' | string;
-        jobId?: string;
-        startTime?: Date;
-        endTime?: Date;
-    }): Promise<number>;
-    /**
-     * Setup table for SQLite.
-     */
-    setupTable(): Promise<void>;
-    private setupJobsTable;
-    private setupLogsTable;
-}
-
-/**
- * Class name serializer (Laravel-style).
- *
- * Stores the class name and properties, then recreates an instance at runtime.
- * This is the recommended serializer because it can restore class instances correctly.
- *
- * Requirement: Job classes must be dynamically loadable (by class name).
- *
- * @example
- * ```typescript
- * const serializer = new ClassNameSerializer()
- * const serialized = serializer.serialize(new SendEmail('user@example.com'))
- * // serialized.data contains class name and properties
- *
- * const job = serializer.deserialize(serialized)
- * // job is an instance of SendEmail
- * ```
- */
-declare class ClassNameSerializer implements JobSerializer {
-    /**
-     * Job class registry (for resolving classes by name).
-     */
-    private jobClasses;
-    /**
-     * Register a Job class.
-     * @param jobClass - Job class
-     */
-    register(jobClass: new (...args: unknown[]) => Job): void;
-    /**
-     * Register multiple Job classes.
-     * @param jobClasses - Job class array
-     */
-    registerMany(jobClasses: Array<new (...args: unknown[]) => Job>): void;
-    /**
-     * Serialize a Job.
-     */
-    serialize(job: Job): SerializedJob;
-    /**
-     * Deserialize a Job.
-     */
-    deserialize(serialized: SerializedJob): Job;
-}
-
-/**
- * JSON Serializer
- *
- * Serializes jobs using JSON.
- * Suitable for simple scenarios where you only need to persist plain properties.
- *
- * Limitation: cannot restore class instances, functions, or complex objects.
- *
- * @example
- * ```typescript
- * const serializer = new JsonSerializer()
- * const serialized = serializer.serialize(job)
- * const job = serializer.deserialize(serialized)
- * ```
- */
-declare class JsonSerializer implements JobSerializer {
-    /**
-     * Serialize a job.
-     */
-    serialize(job: Job): SerializedJob;
-    /**
-     * Deserialize a job.
-     */
-    deserialize(serialized: SerializedJob): Job;
-}
-
-export { BufferedPersistence, ClassNameSerializer, Consumer, type ConsumerOptions, DatabaseDriver, type DatabaseDriverConfig, Job, type JobSerializer, JsonSerializer, KafkaDriver, type KafkaDriverConfig, MemoryDriver, MySQLPersistence, OrbitStream, type OrbitStreamOptions, type PersistenceAdapter, type QueueConfig, type QueueConnectionConfig, type QueueDriver, QueueManager, type Queueable, RabbitMQDriver, type RabbitMQDriverConfig, RedisDriver, type RedisDriverConfig, SQLitePersistence, SQSDriver, type SQSDriverConfig, Scheduler, type SerializedJob, type TopicOptions, Worker, type WorkerOptions };