@gravito/stream 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { GravitoOrbit, PlanetCore } from 'gravito-core';
+import { GravitoOrbit, PlanetCore } from '@gravito/core';
 
 /**
  * Serialized job payload.
@@ -36,6 +36,30 @@ interface SerializedJob {
      * Maximum attempts.
      */
     maxAttempts?: number;
+    /**
+     * Group ID for FIFO ordering.
+     */
+    groupId?: string;
+    /**
+     * Initial retry delay (seconds).
+     */
+    retryAfterSeconds?: number;
+    /**
+     * Retry delay multiplier.
+     */
+    retryMultiplier?: number;
+    /**
+     * Last error message.
+     */
+    error?: string;
+    /**
+     * Timestamp when the job failed permanently.
+     */
+    failedAt?: number;
+    /**
+     * Job priority.
+     */
+    priority?: string | number;
 }
 /**
  * Topic options (for Kafka, etc.).
@@ -83,6 +107,119 @@ interface QueueConfig {
      * Default serializer type.
      */
     defaultSerializer?: 'json' | 'class';
+    /**
+     * 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;
+    };
+}
+/**
+ * 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 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[]>;
+    /**
+     * Remove old data 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>;
+    /**
+     * Archive a system log message.
+     */
+    archiveLog(log: {
+        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;
 }
 
 /**
@@ -94,7 +231,7 @@ interface QueueConfig {
  * @example
  * ```typescript
  * class MyDriver implements QueueDriver {
- *   async push(queue: string, job: SerializedJob): Promise<void> {
+ *   async push(queue: string, job: SerializedJob, options?: JobPushOptions): Promise<void> {
  *     // push a job
  *   }
  *
@@ -102,6 +239,10 @@ interface QueueConfig {
  *     // pop a job
  *   }
  *
+ *   async complete(queue: string, job: SerializedJob): Promise<void> {
+ *     // job completed (for FIFO handling)
+ *   }
+ *
  *   async size(queue: string): Promise<number> {
  *     // queue size
  *   }
@@ -117,14 +258,21 @@ 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): Promise<void>;
+    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>;
+    /**
+     * 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
@@ -136,6 +284,12 @@ interface QueueDriver {
      * @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>;
     /**
      * Push multiple jobs (optional, higher throughput).
      * @param queue - Queue name
@@ -171,6 +325,48 @@ interface QueueDriver {
      * @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: 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: 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>;
 }
 
 /**
@@ -216,6 +412,10 @@ interface Queueable {
      * Delay before execution (seconds).
      */
     delaySeconds?: number;
+    /**
+     * Job priority.
+     */
+    priority?: string | number;
     /**
      * Set target queue.
      * @param queue - Queue name
@@ -228,6 +428,12 @@ interface Queueable {
      * @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
@@ -262,6 +468,10 @@ interface Queueable {
  * ```
  */
 declare abstract class Job implements Queueable {
+    /**
+     * Unique job identifier.
+     */
+    id?: string;
     /**
      * Queue name.
      */
@@ -282,6 +492,22 @@ declare abstract class Job implements Queueable {
      * 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.
      */
@@ -290,10 +516,27 @@ declare abstract class Job implements Queueable {
      * 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.
      *
@@ -369,6 +612,8 @@ declare class QueueManager {
     private serializers;
     private defaultConnection;
     private defaultSerializer;
+    private persistence?;
+    private scheduler?;
     constructor(config?: QueueConfig);
     /**
      * Register a connection.
@@ -382,6 +627,11 @@ declare class QueueManager {
      * @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
@@ -398,6 +648,7 @@ declare class QueueManager {
      *
      * @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
@@ -405,7 +656,7 @@ declare class QueueManager {
      * await manager.push(new SendEmailJob('user@example.com'));
      * ```
      */
-    push<T extends Job & Queueable>(job: T): Promise<T>;
+    push<T extends Job & Queueable>(job: T, options?: JobPushOptions): Promise<T>;
     /**
      * Push multiple jobs to the queue.
      *
@@ -447,6 +698,37 @@ declare class QueueManager {
      * @param connection - Connection name (optional).
      */
     clear(queue?: string, connection?: string): Promise<void>;
+    /**
+     * 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(): any;
+    /**
+     * Get the scheduler if configured.
+     */
+    getScheduler(): any;
+    /**
+     * 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>;
 }
 
 /**
@@ -520,6 +802,31 @@ interface ConsumerOptions {
      * 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, any>;
+        /**
+         * Prefix for monitoring keys/channels.
+         */
+        prefix?: string;
+    };
+    /**
+     * Rate limits per queue.
+     * Example: { 'emails': { max: 10, duration: 1000 } }
+     */
+    rateLimits?: Record<string, {
+        max: number;
+        duration: number;
+    }>;
 }
 /**
  * Consumer
@@ -546,11 +853,17 @@ declare class Consumer {
     private options;
     private running;
     private stopRequested;
+    private workerId;
+    private heartbeatTimer;
     constructor(queueManager: QueueManager, options: ConsumerOptions);
+    private get connectionName();
     /**
      * Start the consumer loop.
      */
     start(): Promise<void>;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private publishLog;
     /**
      * Stop the consumer loop (graceful shutdown).
      */
@@ -633,6 +946,14 @@ declare class DatabaseDriver implements QueueDriver {
      * Push multiple jobs.
      */
     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>;
 }
 
 /**
@@ -810,6 +1131,92 @@ declare class MemoryDriver implements QueueDriver {
     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>;
+    /**
+     * 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;
+    }): Promise<void>;
+    /**
+     * Get queue size.
+     */
+    size(queue: string): Promise<number>;
+    /**
+     * Clear a queue.
+     */
+    clear(queue: string): Promise<void>;
+}
+
 /**
  * Redis driver configuration.
  */
@@ -844,6 +1251,7 @@ interface RedisDriverConfig {
  * 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)
@@ -852,6 +1260,8 @@ interface RedisDriverConfig {
 declare class RedisDriver implements QueueDriver {
     private prefix;
     private client;
+    private static PUSH_SCRIPT;
+    private static COMPLETE_SCRIPT;
     constructor(config: RedisDriverConfig);
     /**
      * Get full Redis key for a queue.
@@ -860,9 +1270,14 @@ declare class RedisDriver implements QueueDriver {
     /**
      * Push a job (LPUSH).
      */
-    push(queue: string, job: SerializedJob): Promise<void>;
+    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 (RPOP, FIFO).
+     * Supports implicit priority polling (critical -> high -> default -> low).
      */
     pop(queue: string): Promise<SerializedJob | null>;
     /**
@@ -873,6 +1288,10 @@ declare class RedisDriver implements QueueDriver {
      * 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.
      */
@@ -885,6 +1304,35 @@ declare class RedisDriver implements QueueDriver {
      * Pop multiple jobs.
      */
     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>;
 }
 
 /**
@@ -1048,7 +1496,7 @@ declare class OrbitStream implements GravitoOrbit {
      */
     getQueueManager(): QueueManager | undefined;
 }
-declare module 'gravito-core' {
+declare module '@gravito/core' {
     interface GravitoVariables {
         /** Queue manager for job processing */
         queue?: QueueManager;
@@ -1057,6 +1505,240 @@ declare module 'gravito-core' {
     }
 }
 
+/**
+ * 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.
+     */
+    constructor(db: any, table?: string, logsTable?: string);
+    /**
+     * Archive a job.
+     */
+    archive(queue: string, job: SerializedJob, status: 'completed' | 'failed' | 'waiting' | string): Promise<void>;
+    /**
+     * Find a specific 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[]>;
+    /**
+     * Search jobs from the archive.
+     */
+    search(query: string, options?: {
+        limit?: number;
+        offset?: number;
+        queue?: string;
+    }): Promise<SerializedJob[]>;
+    /**
+     * Archive a system log message.
+     */
+    archiveLog(log: {
+        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.
+     */
+    constructor(db: any, table?: string, logsTable?: string);
+    /**
+     * Archive a job.
+     */
+    archive(queue: string, job: SerializedJob, status: 'completed' | 'failed' | 'waiting' | string): Promise<void>;
+    /**
+     * Find a specific 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[]>;
+    /**
+     * Search jobs from the archive.
+     */
+    search(query: string, options?: {
+        limit?: number;
+        offset?: number;
+        queue?: string;
+    }): Promise<SerializedJob[]>;
+    /**
+     * Archive a system log message.
+     */
+    archiveLog(log: {
+        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;
+}
+
+interface ScheduledJobConfig {
+    id: string;
+    cron: string;
+    queue: string;
+    job: SerializedJob;
+    lastRun?: number;
+    nextRun?: number;
+    enabled: boolean;
+}
+/**
+ * Scheduler
+ *
+ * Manages recurring (cron) jobs.
+ */
+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>;
+}
+
 /**
  * Class name serializer (Laravel-style).
  *
@@ -1129,4 +1811,4 @@ declare class JsonSerializer implements JobSerializer {
     deserialize(serialized: SerializedJob): Job;
 }
 
-export { ClassNameSerializer, Consumer, type ConsumerOptions, DatabaseDriver, type DatabaseDriverConfig, Job, type JobSerializer, JsonSerializer, KafkaDriver, type KafkaDriverConfig, MemoryDriver, OrbitStream, type OrbitStreamOptions, type QueueConfig, type QueueConnectionConfig, type QueueDriver, QueueManager, type Queueable, RedisDriver, type RedisDriverConfig, SQSDriver, type SQSDriverConfig, type SerializedJob, type TopicOptions, Worker, type WorkerOptions };
+export { 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 };