@nicnocquee/dataqueue 1.34.0 → 1.35.0-beta.20260224110011

package/dist/index.d.cts

@@ -3,6 +3,44 @@ import { Pool } from 'pg';
 import { Cron } from 'croner';
 
 type JobType<PayloadMap> = keyof PayloadMap & string;
+/**
+ * Abstract database client interface for transactional job creation.
+ * Compatible with `pg.Pool`, `pg.PoolClient`, `pg.Client`, or any object
+ * that exposes a `.query()` method matching the `pg` signature.
+ */
+interface DatabaseClient {
+    query(text: string, values?: any[]): Promise<{
+        rows: any[];
+        rowCount: number | null;
+    }>;
+}
+/**
+ * Options for `addJob()` beyond the job itself.
+ * Use `db` to insert the job within an existing database transaction.
+ */
+interface AddJobOptions {
+    /**
+     * An external database client (e.g., a `pg.PoolClient` inside a transaction).
+     * When provided, the INSERT runs on this client instead of the internal pool,
+     * so the job is part of the caller's transaction.
+     *
+     * **PostgreSQL only.** Throws if used with the Redis backend.
+     */
+    db?: DatabaseClient;
+}
+/**
+ * Optional grouping metadata for a job.
+ * Use `id` to enforce global per-group concurrency limits when
+ * `ProcessorOptions.groupConcurrency` is set.
+ *
+ * `tier` is reserved for future tier-based policies.
+ */
+interface JobGroup {
+    /** Stable group identifier (for example: tenant ID, user ID, organization ID). */
+    id: string;
+    /** Optional tier label reserved for future tier-based concurrency controls. */
+    tier?: string;
+}
 interface JobOptions<PayloadMap, T extends JobType<PayloadMap>> {
     jobType: T;
     payload: PayloadMap[T];
@@ -75,6 +113,32 @@ interface JobOptions<PayloadMap, T extends JobType<PayloadMap>> {
      * Once a key exists, it cannot be reused until the job is cleaned up (via `cleanupOldJobs`).
      */
     idempotencyKey?: string;
+    /**
+     * Base delay between retries in seconds. When `retryBackoff` is true (the default),
+     * this is the base for exponential backoff: `retryDelay * 2^attempts`.
+     * When `retryBackoff` is false, retries use this fixed delay.
+     * @default 60
+     */
+    retryDelay?: number;
+    /**
+     * Whether to use exponential backoff for retries. When true, delay doubles
+     * with each attempt and includes jitter to prevent thundering herd.
+     * When false, a fixed `retryDelay` is used between every retry.
+     * @default true
+     */
+    retryBackoff?: boolean;
+    /**
+     * Maximum delay between retries in seconds. Caps the exponential backoff
+     * so retries never wait longer than this value. Only meaningful when
+     * `retryBackoff` is true. No limit when omitted.
+     */
+    retryDelayMax?: number;
+    /**
+     * Optional group metadata for this job.
+     * When `ProcessorOptions.groupConcurrency` is configured, grouped jobs are
+     * globally limited by `group.id` across all workers/instances.
+     */
+    group?: JobGroup;
 }
 /**
  * Options for editing a pending job.
@@ -187,6 +251,31 @@ interface JobRecord<PayloadMap, T extends JobType<PayloadMap>> {
      * Updated by the handler via `ctx.setProgress(percent)`.
      */
     progress?: number | null;
+    /**
+     * Handler output stored via `ctx.setOutput(data)` or by returning a value
+     * from the handler. `null` if no output has been stored.
+     */
+    output?: unknown;
+    /**
+     * Base delay between retries in seconds, or null if using legacy default.
+     */
+    retryDelay?: number | null;
+    /**
+     * Whether exponential backoff is enabled for retries, or null if using legacy default.
+     */
+    retryBackoff?: boolean | null;
+    /**
+     * Maximum delay cap for retries in seconds, or null if no cap.
+     */
+    retryDelayMax?: number | null;
+    /**
+     * Group identifier for this job, if provided at enqueue time.
+     */
+    groupId?: string | null;
+    /**
+     * Group tier for this job, if provided at enqueue time.
+     */
+    groupTier?: string | null;
 }
 /**
  * Callback registered via `onTimeout`. Invoked when the timeout fires, before the AbortSignal is triggered.
@@ -274,6 +363,16 @@ interface JobContext {
      * @throws If percent is outside the 0-100 range.
      */
     setProgress: (percent: number) => Promise<void>;
+    /**
+     * Store an output/result for this job. The value is persisted to the database
+     * as JSONB and can be read by clients via `getJob()` or the React SDK's `useJob()` hook.
+     *
+     * Can be called multiple times — each call overwrites the previous value.
+     * If `setOutput()` is called, the handler's return value is ignored.
+     *
+     * @param data - Any JSON-serializable value to store as the job's output.
+     */
+    setOutput: (data: unknown) => Promise<void>;
 }
 /**
  * Duration specification for `ctx.waitFor()`.
@@ -349,7 +448,7 @@ interface WaitpointRecord {
     completedAt: Date | null;
     tags: string[] | null;
 }
-type JobHandler<PayloadMap, T extends keyof PayloadMap> = (payload: PayloadMap[T], signal: AbortSignal, ctx: JobContext) => Promise<void>;
+type JobHandler<PayloadMap, T extends keyof PayloadMap> = (payload: PayloadMap[T], signal: AbortSignal, ctx: JobContext) => Promise<unknown>;
 type JobHandlers<PayloadMap> = {
     [K in keyof PayloadMap]: JobHandler<PayloadMap, K>;
 };
@@ -368,6 +467,13 @@ interface ProcessorOptions {
      * - Set to a lower value to avoid resource exhaustion.
      */
     concurrency?: number;
+    /**
+     * Global per-group concurrency limit across all workers/instances.
+     * - Applies only to jobs with `group.id` set.
+     * - Jobs without a group are unaffected.
+     * - Disabled when omitted.
+     */
+    groupConcurrency?: number;
     /**
      * The interval in milliseconds to poll for new jobs.
      * - If not provided, the processor will process jobs every 5 seconds when startInBackground is called.
@@ -417,6 +523,88 @@ interface Processor {
      */
     start: () => Promise<number>;
 }
+interface SupervisorOptions {
+    /**
+     * How often the maintenance loop runs, in milliseconds.
+     * @default 60000 (1 minute)
+     */
+    intervalMs?: number;
+    /**
+     * Reclaim jobs stuck in `processing` longer than this many minutes.
+     * @default 10
+     */
+    stuckJobsTimeoutMinutes?: number;
+    /**
+     * Auto-delete completed jobs older than this many days. Set to 0 to disable.
+     * @default 30
+     */
+    cleanupJobsDaysToKeep?: number;
+    /**
+     * Auto-delete job events older than this many days. Set to 0 to disable.
+     * @default 30
+     */
+    cleanupEventsDaysToKeep?: number;
+    /**
+     * Batch size for cleanup deletions.
+     * @default 1000
+     */
+    cleanupBatchSize?: number;
+    /**
+     * Whether to reclaim stuck jobs each cycle.
+     * @default true
+     */
+    reclaimStuckJobs?: boolean;
+    /**
+     * Whether to expire timed-out waitpoint tokens each cycle.
+     * @default true
+     */
+    expireTimedOutTokens?: boolean;
+    /**
+     * Called when a maintenance task throws. One failure does not block other tasks.
+     * @default console.error
+     */
+    onError?: (error: Error) => void;
+    /** Enable verbose logging. */
+    verbose?: boolean;
+}
+interface SupervisorRunResult {
+    /** Number of stuck jobs reclaimed back to pending. */
+    reclaimedJobs: number;
+    /** Number of old completed jobs deleted. */
+    cleanedUpJobs: number;
+    /** Number of old job events deleted. */
+    cleanedUpEvents: number;
+    /** Number of timed-out waitpoint tokens expired. */
+    expiredTokens: number;
+}
+interface Supervisor {
+    /**
+     * Run all maintenance tasks once and return the results.
+     * Ideal for serverless or cron-triggered invocations.
+     */
+    start: () => Promise<SupervisorRunResult>;
+    /**
+     * Start the maintenance loop in the background.
+     * Runs every `intervalMs` milliseconds (default: 60 000).
+     * Call `stop()` or `stopAndDrain()` to halt the loop.
+     */
+    startInBackground: () => void;
+    /**
+     * Stop the background maintenance loop immediately.
+     * Does not wait for an in-flight maintenance run to complete.
+     */
+    stop: () => void;
+    /**
+     * Stop the background loop and wait for the current maintenance run
+     * (if any) to finish before resolving.
+     *
+     * @param timeoutMs - Maximum time to wait (default: 30 000 ms).
+     *   If the run does not finish within this time the promise resolves anyway.
+     */
+    stopAndDrain: (timeoutMs?: number) => Promise<void>;
+    /** Whether the background maintenance loop is currently running. */
+    isRunning: () => boolean;
+}
 interface DatabaseSSLConfig {
     /**
      * CA certificate as PEM string or file path. If the value starts with 'file://', it will be loaded from file, otherwise treated as PEM string.
@@ -438,10 +626,13 @@ interface DatabaseSSLConfig {
 /**
  * Configuration for PostgreSQL backend (default).
  * Backward-compatible: omitting `backend` defaults to 'postgres'.
+ *
+ * Provide either `databaseConfig` (the library creates a pool) or `pool`
+ * (bring your own `pg.Pool`). At least one must be set.
  */
 interface PostgresJobQueueConfig {
     backend?: 'postgres';
-    databaseConfig: {
+    databaseConfig?: {
         connectionString?: string;
         host?: string;
         port?: number;
@@ -467,6 +658,11 @@ interface PostgresJobQueueConfig {
          */
         connectionTimeoutMillis?: number;
     };
+    /**
+     * Bring your own `pg.Pool` instance. When provided, `databaseConfig` is
+     * ignored and the library will not close the pool on shutdown.
+     */
+    pool?: pg.Pool;
     verbose?: boolean;
 }
 /**
@@ -480,10 +676,13 @@ interface RedisTLSConfig {
 }
 /**
  * Configuration for Redis backend.
+ *
+ * Provide either `redisConfig` (the library creates an ioredis client) or
+ * `client` (bring your own ioredis instance). At least one must be set.
  */
 interface RedisJobQueueConfig {
     backend: 'redis';
-    redisConfig: {
+    redisConfig?: {
         /** Redis URL (e.g. redis://localhost:6379) */
         url?: string;
         host?: string;
@@ -498,6 +697,17 @@ interface RedisJobQueueConfig {
          */
         keyPrefix?: string;
     };
+    /**
+     * Bring your own ioredis client instance. When provided, `redisConfig` is
+     * ignored and the library will not close the client on shutdown.
+     * Use `keyPrefix` to set the key namespace (default: 'dq:').
+     */
+    client?: unknown;
+    /**
+     * Key prefix when using an external `client`. Ignored when `redisConfig` is used
+     * (set `redisConfig.keyPrefix` instead). Default: 'dq:'.
+     */
+    keyPrefix?: string;
     verbose?: boolean;
 }
 /**
@@ -544,6 +754,12 @@ interface CronScheduleOptions<PayloadMap, T extends JobType<PayloadMap>> {
      * is still pending, processing, or waiting.
      */
     allowOverlap?: boolean;
+    /** Base delay between retries in seconds for each job instance (default: 60). */
+    retryDelay?: number;
+    /** Whether to use exponential backoff for retries (default: true). */
+    retryBackoff?: boolean;
+    /** Maximum delay cap for retries in seconds. */
+    retryDelayMax?: number;
 }
 /**
  * A persisted cron schedule record.
@@ -567,6 +783,9 @@ interface CronScheduleRecord {
     nextRunAt: Date | null;
     createdAt: Date;
     updatedAt: Date;
+    retryDelay: number | null;
+    retryBackoff: boolean | null;
+    retryDelayMax: number | null;
 }
 /**
  * Options for editing an existing cron schedule.
@@ -582,12 +801,94 @@ interface EditCronScheduleOptions {
     tags?: string[] | null;
     timezone?: string;
     allowOverlap?: boolean;
+    retryDelay?: number | null;
+    retryBackoff?: boolean | null;
+    retryDelayMax?: number | null;
+}
+/**
+ * Payload types for each event emitted by the job queue.
+ */
+interface QueueEventMap {
+    /** Fired after a job is successfully added to the queue. */
+    'job:added': {
+        jobId: number;
+        jobType: string;
+    };
+    /** Fired when a processor claims a job and begins executing its handler. */
+    'job:processing': {
+        jobId: number;
+        jobType: string;
+    };
+    /** Fired when a job handler completes successfully. */
+    'job:completed': {
+        jobId: number;
+        jobType: string;
+    };
+    /** Fired when a job handler fails. `willRetry` indicates whether the job will be retried. */
+    'job:failed': {
+        jobId: number;
+        jobType: string;
+        error: Error;
+        willRetry: boolean;
+    };
+    /** Fired after a job is cancelled via `cancelJob()`. */
+    'job:cancelled': {
+        jobId: number;
+    };
+    /** Fired after a failed job is manually retried via `retryJob()`. */
+    'job:retried': {
+        jobId: number;
+    };
+    /** Fired when a job enters the `waiting` state (via `ctx.waitFor`, `ctx.waitUntil`, or `ctx.waitForToken`). */
+    'job:waiting': {
+        jobId: number;
+        jobType: string;
+    };
+    /** Fired when a job reports progress via `ctx.setProgress()`. */
+    'job:progress': {
+        jobId: number;
+        progress: number;
+    };
+    /** Fired when a job stores output via `ctx.setOutput()`. */
+    'job:output': {
+        jobId: number;
+        output: unknown;
+    };
+    /** Fired on internal errors from the processor or supervisor. */
+    error: Error;
 }
+/** Union of all event names supported by the job queue. */
+type QueueEventName = keyof QueueEventMap;
+/**
+ * Callback type for `emit`. Used internally to pass the emitter
+ * from `initJobQueue` into the processor and supervisor.
+ */
+type QueueEmitFn = <K extends QueueEventName>(event: K, data: QueueEventMap[K]) => void;
 interface JobQueue<PayloadMap> {
     /**
      * Add a job to the job queue.
+     *
+     * @param job - The job to enqueue.
+     * @param options - Optional. Pass `{ db }` with an external database client
+     *   to insert the job within an existing transaction (PostgreSQL only).
      */
-    addJob: <T extends JobType<PayloadMap>>(job: JobOptions<PayloadMap, T>) => Promise<number>;
+    addJob: <T extends JobType<PayloadMap>>(job: JobOptions<PayloadMap, T>, options?: AddJobOptions) => Promise<number>;
+    /**
+     * Add multiple jobs to the queue in a single operation.
+     *
+     * More efficient than calling `addJob` in a loop because it batches the
+     * INSERT into a single database round-trip (PostgreSQL) or a single
+     * atomic Lua script (Redis).
+     *
+     * Returns an array of job IDs in the same order as the input array.
+     * Each job may independently have an `idempotencyKey`; duplicates
+     * resolve to the existing job's ID without creating a new row.
+     *
+     * @param jobs - Array of jobs to enqueue.
+     * @param options - Optional. Pass `{ db }` with an external database client
+     *   to insert the jobs within an existing transaction (PostgreSQL only).
+     */
+    addJobs: <T extends JobType<PayloadMap>>(jobs: JobOptions<PayloadMap, T>[], options?: AddJobOptions) => Promise<number[]>;
     /**
      * Get a job by its ID.
      */
@@ -732,6 +1033,12 @@ interface JobQueue<PayloadMap> {
      * Create a job processor. Handlers must be provided per-processor.
      */
     createProcessor: (handlers: JobHandlers<PayloadMap>, options?: ProcessorOptions) => Processor;
+    /**
+     * Create a background supervisor that automatically reclaims stuck jobs,
+     * cleans up old completed jobs/events, and expires timed-out waitpoint
+     * tokens on a configurable interval.
+     */
+    createSupervisor: (options?: SupervisorOptions) => Supervisor;
     /**
      * Get the job events for a job.
      */
@@ -817,6 +1124,36 @@ interface JobQueue<PayloadMap> {
      * @returns The number of jobs that were enqueued.
      */
     enqueueDueCronJobs: () => Promise<number>;
+    /**
+     * Register a listener for a queue event. The listener is called every
+     * time the event fires. Works identically with both PostgreSQL and Redis.
+     *
+     * @param event - The event name (e.g. `'job:completed'`, `'error'`).
+     * @param listener - Callback receiving the event payload.
+     */
+    on: <K extends QueueEventName>(event: K, listener: (data: QueueEventMap[K]) => void) => void;
+    /**
+     * Register a one-time listener. The listener is automatically removed
+     * after it fires once.
+     *
+     * @param event - The event name.
+     * @param listener - Callback receiving the event payload.
+     */
+    once: <K extends QueueEventName>(event: K, listener: (data: QueueEventMap[K]) => void) => void;
+    /**
+     * Remove a previously registered listener.
+     *
+     * @param event - The event name.
+     * @param listener - The exact function reference passed to `on` or `once`.
+     */
+    off: <K extends QueueEventName>(event: K, listener: (data: QueueEventMap[K]) => void) => void;
+    /**
+     * Remove all listeners for a specific event, or all listeners for
+     * all events when called without arguments.
+     *
+     * @param event - Optional event name. If omitted, removes everything.
+     */
+    removeAllListeners: (event?: QueueEventName) => void;
     /**
      * Get the PostgreSQL database pool.
      * Throws if the backend is not PostgreSQL.
@@ -863,6 +1200,9 @@ interface JobUpdates {
     runAt?: Date | null;
     timeoutMs?: number | null;
     tags?: string[] | null;
+    retryDelay?: number | null;
+    retryBackoff?: boolean | null;
+    retryDelayMax?: number | null;
 }
 /**
  * Input shape for creating a cron schedule in the backend.
@@ -881,6 +1221,9 @@ interface CronScheduleInput {
     timezone: string;
     allowOverlap: boolean;
     nextRunAt: Date | null;
+    retryDelay: number | null;
+    retryBackoff: boolean | null;
+    retryDelayMax: number | null;
 }
 /**
  * Abstract backend interface that both PostgreSQL and Redis implement.
@@ -888,8 +1231,26 @@ interface CronScheduleInput {
  * and public API are backend-agnostic.
  */
 interface QueueBackend {
-    /** Add a job and return its numeric ID. */
-    addJob<PayloadMap, T extends JobType<PayloadMap>>(job: JobOptions<PayloadMap, T>): Promise<number>;
+    /**
+     * Add a job and return its numeric ID.
+     *
+     * @param job - Job configuration.
+     * @param options - Optional. Pass `{ db }` to run the INSERT on an external
+     *   client (e.g., inside a transaction). PostgreSQL only.
+     */
+    addJob<PayloadMap, T extends JobType<PayloadMap>>(job: JobOptions<PayloadMap, T>, options?: AddJobOptions): Promise<number>;
+    /**
+     * Add multiple jobs in a single operation and return their IDs.
+     *
+     * IDs are returned in the same order as the input array.
+     * Each job may independently have an `idempotencyKey`; duplicates
+     * resolve to the existing job's ID without creating a new row.
+     *
+     * @param jobs - Array of job configurations.
+     * @param options - Optional. Pass `{ db }` to run the INSERTs on an external
+     *   client (e.g., inside a transaction). PostgreSQL only.
+     */
+    addJobs<PayloadMap, T extends JobType<PayloadMap>>(jobs: JobOptions<PayloadMap, T>[], options?: AddJobOptions): Promise<number[]>;
     /** Get a single job by ID, or null if not found. */
     getJob<PayloadMap, T extends JobType<PayloadMap>>(id: number): Promise<JobRecord<PayloadMap, T> | null>;
     /** Get jobs filtered by status, ordered by createdAt DESC. */
@@ -904,9 +1265,9 @@ interface QueueBackend {
      * Atomically claim a batch of ready jobs for the given worker.
      * Equivalent to SELECT … FOR UPDATE SKIP LOCKED in Postgres.
      */
-    getNextBatch<PayloadMap, T extends JobType<PayloadMap>>(workerId: string, batchSize?: number, jobType?: string | string[]): Promise<JobRecord<PayloadMap, T>[]>;
-    /** Mark a job as completed. */
-    completeJob(jobId: number): Promise<void>;
+    getNextBatch<PayloadMap, T extends JobType<PayloadMap>>(workerId: string, batchSize?: number, jobType?: string | string[], groupConcurrency?: number): Promise<JobRecord<PayloadMap, T>[]>;
+    /** Mark a job as completed, optionally storing output data. */
+    completeJob(jobId: number, output?: unknown): Promise<void>;
     /** Mark a job as failed with error info and schedule retry. */
     failJob(jobId: number, error: Error, failureReason?: FailureReason): Promise<void>;
     /** Update locked_at to keep the job alive (heartbeat). */
@@ -929,6 +1290,8 @@ interface QueueBackend {
     reclaimStuckJobs(maxProcessingTimeMinutes?: number): Promise<number>;
     /** Update the progress percentage (0-100) for a job. */
     updateProgress(jobId: number, progress: number): Promise<void>;
+    /** Update the output data for a job. Best-effort: should not throw. */
+    updateOutput(jobId: number, output: unknown): Promise<void>;
     /** Record a job event. Should not throw. */
     recordJobEvent(jobId: number, eventType: JobEventType, metadata?: any): Promise<void>;
     /** Get all events for a job, ordered by createdAt ASC. */
@@ -1022,17 +1385,33 @@ declare class PostgresBackend implements QueueBackend {
     getPool(): Pool;
     recordJobEvent(jobId: number, eventType: JobEventType, metadata?: any): Promise<void>;
     getJobEvents(jobId: number): Promise<JobEvent[]>;
-    addJob<PayloadMap, T extends JobType<PayloadMap>>({ jobType, payload, maxAttempts, priority, runAt, timeoutMs, forceKillOnTimeout, tags, idempotencyKey, }: JobOptions<PayloadMap, T>): Promise<number>;
+    /**
+     * Add a job and return its numeric ID.
+     *
+     * @param job - Job configuration.
+     * @param options - Optional. Pass `{ db }` to run the INSERT on an external
+     *   client (e.g., inside a transaction) so the job is part of the caller's
+     *   transaction. The event INSERT also uses the same client.
+     */
+    addJob<PayloadMap, T extends JobType<PayloadMap>>({ jobType, payload, maxAttempts, priority, runAt, timeoutMs, forceKillOnTimeout, tags, idempotencyKey, retryDelay, retryBackoff, retryDelayMax, group, }: JobOptions<PayloadMap, T>, options?: AddJobOptions): Promise<number>;
+    /**
+     * Insert multiple jobs in a single database round-trip.
+     *
+     * Uses a multi-row INSERT with ON CONFLICT handling for idempotency keys.
+     * Returns IDs in the same order as the input array.
+     */
+    addJobs<PayloadMap, T extends JobType<PayloadMap>>(jobs: JobOptions<PayloadMap, T>[], options?: AddJobOptions): Promise<number[]>;
     getJob<PayloadMap, T extends JobType<PayloadMap>>(id: number): Promise<JobRecord<PayloadMap, T> | null>;
     getJobsByStatus<PayloadMap, T extends JobType<PayloadMap>>(status: string, limit?: number, offset?: number): Promise<JobRecord<PayloadMap, T>[]>;
     getAllJobs<PayloadMap, T extends JobType<PayloadMap>>(limit?: number, offset?: number): Promise<JobRecord<PayloadMap, T>[]>;
     getJobs<PayloadMap, T extends JobType<PayloadMap>>(filters?: JobFilters, limit?: number, offset?: number): Promise<JobRecord<PayloadMap, T>[]>;
     getJobsByTags<PayloadMap, T extends JobType<PayloadMap>>(tags: string[], mode?: TagQueryMode, limit?: number, offset?: number): Promise<JobRecord<PayloadMap, T>[]>;
-    getNextBatch<PayloadMap, T extends JobType<PayloadMap>>(workerId: string, batchSize?: number, jobType?: string | string[]): Promise<JobRecord<PayloadMap, T>[]>;
-    completeJob(jobId: number): Promise<void>;
+    getNextBatch<PayloadMap, T extends JobType<PayloadMap>>(workerId: string, batchSize?: number, jobType?: string | string[], groupConcurrency?: number): Promise<JobRecord<PayloadMap, T>[]>;
+    completeJob(jobId: number, output?: unknown): Promise<void>;
     failJob(jobId: number, error: Error, failureReason?: FailureReason): Promise<void>;
     prolongJob(jobId: number): Promise<void>;
     updateProgress(jobId: number, progress: number): Promise<void>;
+    updateOutput(jobId: number, output: unknown): Promise<void>;
     retryJob(jobId: number): Promise<void>;
     cancelJob(jobId: number): Promise<void>;
     cancelAllUpcomingJobs(filters?: JobFilters): Promise<number>;
@@ -1217,7 +1596,9 @@ declare function validateCronExpression(cronExpression: string, CronImpl?: typeo
  * Initialize the job queue system.
  *
  * Defaults to PostgreSQL when `backend` is omitted.
+ * For PostgreSQL, provide either `databaseConfig` or `pool` (bring your own).
+ * For Redis, provide either `redisConfig` or `client` (bring your own).
  */
 declare const initJobQueue: <PayloadMap = any>(config: JobQueueConfig) => JobQueue<PayloadMap>;
 
-export { type CreateTokenOptions, type CronScheduleInput, type CronScheduleOptions, type CronScheduleRecord, type CronScheduleStatus, type DatabaseSSLConfig, type EditCronScheduleOptions, type EditJobOptions, FailureReason, type JobContext, type JobEvent, JobEventType, type JobHandler, type JobHandlers, type JobOptions, type JobQueue, type JobQueueConfig, type JobQueueConfigLegacy, type JobRecord, type JobStatus, type JobType, type OnTimeoutCallback, PostgresBackend, type PostgresJobQueueConfig, type Processor, type ProcessorOptions, type QueueBackend, type RedisJobQueueConfig, type RedisTLSConfig, type TagQueryMode, type WaitDuration, WaitSignal, type WaitToken, type WaitTokenResult, type WaitpointRecord, type WaitpointStatus, getNextCronOccurrence, initJobQueue, testHandlerSerialization, validateCronExpression, validateHandlerSerializable };
+export { type AddJobOptions, type CreateTokenOptions, type CronScheduleInput, type CronScheduleOptions, type CronScheduleRecord, type CronScheduleStatus, type DatabaseClient, type DatabaseSSLConfig, type EditCronScheduleOptions, type EditJobOptions, FailureReason, type JobContext, type JobEvent, JobEventType, type JobGroup, type JobHandler, type JobHandlers, type JobOptions, type JobQueue, type JobQueueConfig, type JobQueueConfigLegacy, type JobRecord, type JobStatus, type JobType, type OnTimeoutCallback, PostgresBackend, type PostgresJobQueueConfig, type Processor, type ProcessorOptions, type QueueBackend, type QueueEmitFn, type QueueEventMap, type QueueEventName, type RedisJobQueueConfig, type RedisTLSConfig, type Supervisor, type SupervisorOptions, type SupervisorRunResult, type TagQueryMode, type WaitDuration, WaitSignal, type WaitToken, type WaitTokenResult, type WaitpointRecord, type WaitpointStatus, getNextCronOccurrence, initJobQueue, testHandlerSerialization, validateCronExpression, validateHandlerSerializable };