@monque/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1460 @@
+import { Db, ObjectId } from "mongodb";
+import { EventEmitter } from "node:events";
+
+//#region src/jobs/types.d.ts
+
+/**
+ * Represents the lifecycle states of a job in the queue.
+ *
+ * Jobs transition through states as follows:
+ * - PENDING → PROCESSING (when picked up by a worker)
+ * - PROCESSING → COMPLETED (on success)
+ * - PROCESSING → PENDING (on failure, if retries remain)
+ * - PROCESSING → FAILED (on failure, after max retries exhausted)
+ *
+ * @example
+ * ```typescript
+ * if (job.status === JobStatus.PENDING) {
+ *   // job is waiting to be picked up
+ * }
+ * ```
+ */
+declare const JobStatus: {
+  /** Job is waiting to be picked up by a worker */
+  readonly PENDING: "pending";
+  /** Job is currently being executed by a worker */
+  readonly PROCESSING: "processing";
+  /** Job completed successfully */
+  readonly COMPLETED: "completed";
+  /** Job permanently failed after exhausting all retry attempts */
+  readonly FAILED: "failed";
+};
+/**
+ * Union type of all possible job status values: `'pending' | 'processing' | 'completed' | 'failed'`
+ */
+type JobStatusType = (typeof JobStatus)[keyof typeof JobStatus];
+/**
+ * Represents a job in the Monque queue.
+ *
+ * @template T - The type of the job's data payload
+ *
+ * @example
+ * ```typescript
+ * interface EmailJobData {
+ *   to: string;
+ *   subject: string;
+ *   template: string;
+ * }
+ *
+ * const job: Job<EmailJobData> = {
+ *   name: 'send-email',
+ *   data: { to: 'user@example.com', subject: 'Welcome!', template: 'welcome' },
+ *   status: JobStatus.PENDING,
+ *   nextRunAt: new Date(),
+ *   failCount: 0,
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+interface Job<T = unknown> {
+  /** MongoDB document identifier */
+  _id?: ObjectId;
+  /** Job type identifier, matches worker registration */
+  name: string;
+  /** Job payload - must be JSON-serializable */
+  data: T;
+  /** Current lifecycle state */
+  status: JobStatusType;
+  /** When the job should be processed */
+  nextRunAt: Date;
+  /** Timestamp when job was locked for processing */
+  lockedAt?: Date | null;
+  /**
+   * Unique identifier of the scheduler instance that claimed this job.
+   * Used for atomic claim pattern - ensures only one instance processes each job.
+   * Set when a job is claimed, cleared when job completes or fails.
+   */
+  claimedBy?: string | null;
+  /**
+   * Timestamp of the last heartbeat update for this job.
+   * Used to detect stale jobs when a scheduler instance crashes without releasing.
+   * Updated periodically while job is being processed.
+   */
+  lastHeartbeat?: Date | null;
+  /**
+   * Heartbeat interval in milliseconds for this job.
+   * Stored on the job to allow recovery logic to use the correct timeout.
+   */
+  heartbeatInterval?: number;
+  /** Number of failed attempts */
+  failCount: number;
+  /** Last failure error message */
+  failReason?: string;
+  /** Cron expression for recurring jobs */
+  repeatInterval?: string;
+  /** Deduplication key to prevent duplicate jobs */
+  uniqueKey?: string;
+  /** Job creation timestamp */
+  createdAt: Date;
+  /** Last modification timestamp */
+  updatedAt: Date;
+}
+/**
+ * A job that has been persisted to MongoDB and has a guaranteed `_id`.
+ * This is returned by `enqueue()`, `now()`, and `schedule()` methods.
+ *
+ * @template T - The type of the job's data payload
+ */
+type PersistedJob<T = unknown> = Job<T> & {
+  _id: ObjectId;
+};
+/**
+ * Options for enqueueing a job.
+ *
+ * @example
+ * ```typescript
+ * await monque.enqueue('sync-user', { userId: '123' }, {
+ *   uniqueKey: 'sync-user-123',
+ *   runAt: new Date(Date.now() + 5000), // Run in 5 seconds
+ * });
+ * ```
+ */
+interface EnqueueOptions {
+  /**
+   * Deduplication key. If a job with this key is already pending or processing,
+   * the enqueue operation will not create a duplicate.
+   */
+  uniqueKey?: string;
+  /**
+   * When the job should be processed. Defaults to immediately (new Date()).
+   */
+  runAt?: Date;
+}
+/**
+ * Options for scheduling a recurring job.
+ *
+ * @example
+ * ```typescript
+ * await monque. schedule('0 * * * *', 'hourly-cleanup', { dir: '/tmp' }, {
+ *   uniqueKey: 'hourly-cleanup-job',
+ * });
+ * ```
+ */
+interface ScheduleOptions {
+  /**
+   * Deduplication key. If a job with this key is already pending or processing,
+   * the schedule operation will not create a duplicate.
+   */
+  uniqueKey?: string;
+}
+/**
+ * Filter options for querying jobs.
+ *
+ * Use with `monque.getJobs()` to filter jobs by name, status, or limit results.
+ *
+ * @example
+ * ```typescript
+ * // Get all pending email jobs
+ * const pendingEmails = await monque.getJobs({
+ *   name: 'send-email',
+ *   status: JobStatus.PENDING,
+ * });
+ *
+ * // Get all failed or completed jobs (paginated)
+ * const finishedJobs = await monque.getJobs({
+ *   status: [JobStatus.COMPLETED, JobStatus.FAILED],
+ *   limit: 50,
+ *   skip: 100,
+ * });
+ * ```
+ */
+interface GetJobsFilter {
+  /** Filter by job type name */
+  name?: string;
+  /** Filter by status (single or multiple) */
+  status?: JobStatusType | JobStatusType[];
+  /** Maximum number of jobs to return (default: 100) */
+  limit?: number;
+  /** Number of jobs to skip for pagination */
+  skip?: number;
+}
+/**
+ * Handler function signature for processing jobs.
+ *
+ * @template T - The type of the job's data payload
+ *
+ * @example
+ * ```typescript
+ * const emailHandler: JobHandler<EmailJobData> = async (job) => {
+ *   await sendEmail(job.data.to, job.data.subject);
+ * };
+ * ```
+ */
+type JobHandler<T = unknown> = (job: Job<T>) => Promise<void> | void;
+//#endregion
+//#region src/jobs/guards.d.ts
+/**
+ * Type guard to check if a job has been persisted to MongoDB.
+ *
+ * A persisted job is guaranteed to have an `_id` field, which means it has been
+ * successfully inserted into the database. This is useful when you need to ensure
+ * a job can be updated or referenced by its ID.
+ *
+ * @template T - The type of the job's data payload
+ * @param job - The job to check
+ * @returns `true` if the job has a valid `_id`, narrowing the type to `PersistedJob<T>`
+ *
+ * @example Basic usage
+ * ```typescript
+ * const job: Job<EmailData> = await monque.enqueue('send-email', emailData);
+ *
+ * if (isPersistedJob(job)) {
+ *   // TypeScript knows job._id exists
+ *   console.log(`Job ID: ${job._id.toString()}`);
+ * }
+ * ```
+ *
+ * @example In a conditional
+ * ```typescript
+ * function logJobId(job: Job) {
+ *   if (!isPersistedJob(job)) {
+ *     console.log('Job not yet persisted');
+ *     return;
+ *   }
+ *   // TypeScript knows job is PersistedJob here
+ *   console.log(`Processing job ${job._id.toString()}`);
+ * }
+ * ```
+ */
+declare function isPersistedJob<T>(job: Job<T>): job is PersistedJob<T>;
+/**
+ * Type guard to check if a value is a valid job status.
+ *
+ * Validates that a value is one of the four valid job statuses: `'pending'`,
+ * `'processing'`, `'completed'`, or `'failed'`. Useful for runtime validation
+ * of user input or external data.
+ *
+ * @param value - The value to check
+ * @returns `true` if the value is a valid `JobStatusType`, narrowing the type
+ *
+ * @example Validating user input
+ * ```typescript
+ * function filterByStatus(status: string) {
+ *   if (!isValidJobStatus(status)) {
+ *     throw new Error(`Invalid status: ${status}`);
+ *   }
+ *   // TypeScript knows status is JobStatusType here
+ *   return db.jobs.find({ status });
+ * }
+ * ```
+ *
+ * @example Runtime validation
+ * ```typescript
+ * const statusFromApi = externalData.status;
+ *
+ * if (isValidJobStatus(statusFromApi)) {
+ *   job.status = statusFromApi;
+ * } else {
+ *   job.status = JobStatus.PENDING;
+ * }
+ * ```
+ */
+declare function isValidJobStatus(value: unknown): value is JobStatusType;
+/**
+ * Type guard to check if a job is in pending status.
+ *
+ * A convenience helper for checking if a job is waiting to be processed.
+ * Equivalent to `job.status === JobStatus.PENDING` but with better semantics.
+ *
+ * @template T - The type of the job's data payload
+ * @param job - The job to check
+ * @returns `true` if the job status is `'pending'`
+ *
+ * @example Filter pending jobs
+ * ```typescript
+ * const jobs = await monque.getJobs();
+ * const pendingJobs = jobs.filter(isPendingJob);
+ * console.log(`${pendingJobs.length} jobs waiting to be processed`);
+ * ```
+ *
+ * @example Conditional logic
+ * ```typescript
+ * if (isPendingJob(job)) {
+ *   await monque.now(job.name, job.data);
+ * }
+ * ```
+ */
+declare function isPendingJob<T>(job: Job<T>): boolean;
+/**
+ * Type guard to check if a job is currently being processed.
+ *
+ * A convenience helper for checking if a job is actively running.
+ * Equivalent to `job.status === JobStatus.PROCESSING` but with better semantics.
+ *
+ * @template T - The type of the job's data payload
+ * @param job - The job to check
+ * @returns `true` if the job status is `'processing'`
+ *
+ * @example Monitor active jobs
+ * ```typescript
+ * const jobs = await monque.getJobs();
+ * const activeJobs = jobs.filter(isProcessingJob);
+ * console.log(`${activeJobs.length} jobs currently running`);
+ * ```
+ */
+declare function isProcessingJob<T>(job: Job<T>): boolean;
+/**
+ * Type guard to check if a job has completed successfully.
+ *
+ * A convenience helper for checking if a job finished without errors.
+ * Equivalent to `job.status === JobStatus.COMPLETED` but with better semantics.
+ *
+ * @template T - The type of the job's data payload
+ * @param job - The job to check
+ * @returns `true` if the job status is `'completed'`
+ *
+ * @example Find completed jobs
+ * ```typescript
+ * const jobs = await monque.getJobs();
+ * const completedJobs = jobs.filter(isCompletedJob);
+ * console.log(`${completedJobs.length} jobs completed successfully`);
+ * ```
+ */
+declare function isCompletedJob<T>(job: Job<T>): boolean;
+/**
+ * Type guard to check if a job has permanently failed.
+ *
+ * A convenience helper for checking if a job exhausted all retries.
+ * Equivalent to `job.status === JobStatus.FAILED` but with better semantics.
+ *
+ * @template T - The type of the job's data payload
+ * @param job - The job to check
+ * @returns `true` if the job status is `'failed'`
+ *
+ * @example Handle failed jobs
+ * ```typescript
+ * const jobs = await monque.getJobs();
+ * const failedJobs = jobs.filter(isFailedJob);
+ *
+ * for (const job of failedJobs) {
+ *   console.error(`Job ${job.name} failed: ${job.failReason}`);
+ *   await sendAlert(job);
+ * }
+ * ```
+ */
+declare function isFailedJob<T>(job: Job<T>): boolean;
+/**
+ * Type guard to check if a job is a recurring scheduled job.
+ *
+ * A recurring job has a `repeatInterval` cron expression and will be automatically
+ * rescheduled after each successful completion.
+ *
+ * @template T - The type of the job's data payload
+ * @param job - The job to check
+ * @returns `true` if the job has a `repeatInterval` defined
+ *
+ * @example Filter recurring jobs
+ * ```typescript
+ * const jobs = await monque.getJobs();
+ * const recurringJobs = jobs.filter(isRecurringJob);
+ * console.log(`${recurringJobs.length} jobs will repeat automatically`);
+ * ```
+ *
+ * @example Conditional cleanup
+ * ```typescript
+ * if (!isRecurringJob(job) && isCompletedJob(job)) {
+ *   // Safe to delete one-time completed jobs
+ *   await deleteJob(job._id);
+ * }
+ * ```
+ */
+declare function isRecurringJob<T>(job: Job<T>): boolean;
+//#endregion
+//#region src/events/types.d.ts
+/**
+ * Event payloads for Monque lifecycle events.
+ */
+interface MonqueEventMap {
+  /**
+   * Emitted when a job begins processing.
+   */
+  'job:start': Job;
+  /**
+   * Emitted when a job finishes successfully.
+   */
+  'job:complete': {
+    job: Job;
+    /** Processing duration in milliseconds */
+    duration: number;
+  };
+  /**
+   * Emitted when a job fails (may retry).
+   */
+  'job:fail': {
+    job: Job;
+    error: Error;
+    /** Whether the job will be retried */
+    willRetry: boolean;
+  };
+  /**
+   * Emitted for unexpected errors during processing.
+   */
+  'job:error': {
+    error: Error;
+    job?: Job;
+  };
+  /**
+   * Emitted when stale jobs are recovered on startup.
+   */
+  'stale:recovered': {
+    count: number;
+  };
+  /**
+   * Emitted when the change stream is successfully connected.
+   */
+  'changestream:connected': undefined;
+  /**
+   * Emitted when a change stream error occurs.
+   */
+  'changestream:error': {
+    error: Error;
+  };
+  /**
+   * Emitted when the change stream is closed.
+   */
+  'changestream:closed': undefined;
+  /**
+   * Emitted when falling back from change streams to polling-only mode.
+   */
+  'changestream:fallback': {
+    reason: string;
+  };
+}
+//#endregion
+//#region src/workers/types.d.ts
+/**
+ * Options for registering a worker.
+ *
+ * @example
+ * ```typescript
+ * monque.worker('send-email', emailHandler, {
+ *   concurrency: 3,
+ * });
+ * ```
+ */
+interface WorkerOptions {
+  /**
+   * Number of concurrent jobs this worker can process.
+   * @default 5 (uses defaultConcurrency from MonqueOptions)
+   */
+  concurrency?: number;
+  /**
+   * Allow replacing an existing worker for the same job name.
+   * If false (default) and a worker already exists, throws WorkerRegistrationError.
+   * @default false
+   */
+  replace?: boolean;
+}
+//#endregion
+//#region src/scheduler/types.d.ts
+/**
+ * Configuration options for the Monque scheduler.
+ *
+ * @example
+ * ```typescript
+ * const monque = new Monque(db, {
+ *   collectionName: 'jobs',
+ *   pollInterval: 1000,
+ *   maxRetries: 10,
+ *   baseRetryInterval: 1000,
+ *   shutdownTimeout: 30000,
+ *   defaultConcurrency: 5,
+ * });
+ * ```
+ */
+interface MonqueOptions {
+  /**
+   * Name of the MongoDB collection for storing jobs.
+   * @default 'monque_jobs'
+   */
+  collectionName?: string;
+  /**
+   * Interval in milliseconds between polling for new jobs.
+   * @default 1000
+   */
+  pollInterval?: number;
+  /**
+   * Maximum number of retry attempts before marking a job as permanently failed.
+   * @default 10
+   */
+  maxRetries?: number;
+  /**
+   * Base interval in milliseconds for exponential backoff calculation.
+   * Actual delay = 2^failCount * baseRetryInterval
+   * @default 1000
+   */
+  baseRetryInterval?: number;
+  /**
+   * Maximum delay in milliseconds for exponential backoff.
+   * If calculated delay exceeds this value, it will be capped.
+   *
+   * Defaults to 24 hours to prevent unbounded delays.
+   * @default 86400000 (24 hours)
+   */
+  maxBackoffDelay?: number | undefined;
+  /**
+   * Timeout in milliseconds for graceful shutdown.
+   * @default 30000
+   */
+  shutdownTimeout?: number;
+  /**
+   * Default number of concurrent jobs per worker.
+   * @default 5
+   */
+  defaultConcurrency?: number;
+  /**
+   * Maximum time in milliseconds a job can be in 'processing' status before
+   * being considered stale and eligible for recovery.
+   *
+   * Stale recovery uses `lockedAt` as the source of truth; this is an absolute
+   * “time locked” limit, not a heartbeat timeout.
+   * @default 1800000 (30 minutes)
+   */
+  lockTimeout?: number;
+  /**
+   * Unique identifier for this scheduler instance.
+   * Used for atomic job claiming - each instance uses this ID to claim jobs.
+   * Defaults to a randomly generated UUID v4.
+   * @default crypto.randomUUID()
+   */
+  schedulerInstanceId?: string;
+  /**
+   * Interval in milliseconds for heartbeat updates during job processing.
+   * The scheduler periodically updates `lastHeartbeat` for all jobs it is processing
+   * to indicate liveness for monitoring/debugging.
+   *
+   * Note: stale recovery is based on `lockedAt` + `lockTimeout`, not `lastHeartbeat`.
+   * @default 30000 (30 seconds)
+   */
+  heartbeatInterval?: number;
+  /**
+   * Whether to recover stale processing jobs on scheduler startup.
+   * When true, jobs with lockedAt older than lockTimeout will be reset to pending.
+   * @default true
+   */
+  recoverStaleJobs?: boolean;
+  /**
+   * Configuration for automatic cleanup of completed and failed jobs.
+   * If undefined, no cleanup is performed.
+   */
+  jobRetention?: {
+    /**
+     * Age in milliseconds after which completed jobs are deleted.
+     * Cleaned up based on 'updatedAt' timestamp.
+     */
+    completed?: number;
+    /**
+     * Age in milliseconds after which failed jobs are deleted.
+     * Cleaned up based on 'updatedAt' timestamp.
+     */
+    failed?: number;
+    /**
+     * Interval in milliseconds for running the cleanup job.
+     * @default 3600000 (1 hour)
+     */
+    interval?: number;
+  } | undefined;
+}
+//#endregion
+//#region src/scheduler/monque.d.ts
+/**
+ * Monque - MongoDB-backed job scheduler
+ *
+ * A type-safe job scheduler with atomic locking, exponential backoff, cron scheduling,
+ * stale job recovery, and event-driven observability. Built on native MongoDB driver.
+ *
+ * @example Complete lifecycle
+ * ```;
+typescript
+ *
+
+import { Monque } from '@monque/core';
+
+*
+
+import { MongoClient } from 'mongodb';
+
+*
+ *
+const client = new MongoClient('mongodb://localhost:27017');
+* await client.connect()
+*
+const db = client.db('myapp');
+*
+ * // Create instance with options
+ *
+const monque = new Monque(db, {
+ *   collectionName: 'jobs',
+ *   pollInterval: 1000,
+ *   maxRetries: 10,
+ *   shutdownTimeout: 30000,
+ * });
+*
+ * // Initialize (sets up indexes and recovers stale jobs)
+ * await monque.initialize()
+*
+ * // Register workers with type safety
+ *
+type EmailJob = {};
+*   to: string
+*   subject: string
+*   body: string
+* }
+ *
+ * monque.worker<EmailJob>('send-email', async (job) =>
+{
+    *   await emailService.send(job.data.to, job.data.subject, job.data.body)
+    *
+}
+)
+*
+ * // Monitor events for observability
+ * monque.on('job:complete', (
+{
+    job, duration;
+}
+) =>
+{
+ *   logger.info(`Job $job.namecompleted in $durationms`);
+ * });
+ *
+ * monque.on('job:fail', ({ job, error, willRetry }) => {
+ *   logger.error(`Job $job.namefailed:`, error);
+ * });
+ *
+ * // Start processing
+ * monque.start();
+ *
+ * // Enqueue jobs
+ * await monque.enqueue('send-email', {
+ *   to: 'user@example.com',
+ *   subject: 'Welcome!',
+ *   body: 'Thanks for signing up.'
+ * });
+ *
+ * // Graceful shutdown
+ * process.on('SIGTERM', async () => {
+ *   await monque.stop();
+ *   await client.close();
+ *   process.exit(0);
+ * });
+ * ```
+ */
+declare class Monque extends EventEmitter {
+  private readonly db;
+  private readonly options;
+  private collection;
+  private workers;
+  private pollIntervalId;
+  private heartbeatIntervalId;
+  private cleanupIntervalId;
+  private isRunning;
+  private isInitialized;
+  /**
+   * MongoDB Change Stream for real-time job notifications.
+   * When available, provides instant job processing without polling delay.
+   */
+  private changeStream;
+  /**
+   * Number of consecutive reconnection attempts for change stream.
+   * Used for exponential backoff during reconnection.
+   */
+  private changeStreamReconnectAttempts;
+  /**
+   * Maximum reconnection attempts before falling back to polling-only mode.
+   */
+  private readonly maxChangeStreamReconnectAttempts;
+  /**
+   * Debounce timer for change stream event processing.
+   * Prevents claim storms when multiple events arrive in quick succession.
+   */
+  private changeStreamDebounceTimer;
+  /**
+   * Whether the scheduler is currently using change streams for notifications.
+   */
+  private usingChangeStreams;
+  /**
+   * Timer ID for change stream reconnection with exponential backoff.
+   * Tracked to allow cancellation during shutdown.
+   */
+  private changeStreamReconnectTimer;
+  constructor(db: Db, options?: MonqueOptions);
+  /**
+   * Initialize the scheduler by setting up the MongoDB collection and indexes.
+   * Must be called before start().
+   *
+   * @throws {ConnectionError} If collection or index creation fails
+   */
+  initialize(): Promise<void>;
+  /**
+   * Create required MongoDB indexes for efficient job processing.
+   *
+   * The following indexes are created:
+   * - `{status, nextRunAt}` - For efficient job polling queries
+   * - `{name, uniqueKey}` - Partial unique index for deduplication (pending/processing only)
+   * - `{name, status}` - For job lookup by type
+   * - `{claimedBy, status}` - For finding jobs owned by a specific scheduler instance
+   * - `{lastHeartbeat, status}` - For monitoring/debugging queries (e.g., inspecting heartbeat age)
+   * - `{status, nextRunAt, claimedBy}` - For atomic claim queries (find unclaimed pending jobs)
+   * - `{lockedAt, lastHeartbeat, status}` - Supports recovery scans and monitoring access patterns
+   */
+  private createIndexes;
+  /**
+   * Recover stale jobs that were left in 'processing' status.
+   * A job is considered stale if its `lockedAt` timestamp exceeds the configured `lockTimeout`.
+   * Stale jobs are reset to 'pending' so they can be picked up by workers again.
+   */
+  private recoverStaleJobs;
+  /**
+   * Clean up old completed and failed jobs based on retention policy.
+   *
+   * - Removes completed jobs older than `jobRetention.completed`
+   * - Removes failed jobs older than `jobRetention.failed`
+   *
+   * The cleanup runs concurrently for both statuses if configured.
+   *
+   * @returns Promise resolving when all deletion operations complete
+   */
+  private cleanupJobs;
+  /**
+   * Enqueue a job for processing.
+   *
+   * Jobs are stored in MongoDB and processed by registered workers. Supports
+   * delayed execution via `runAt` and deduplication via `uniqueKey`.
+   *
+   * When a `uniqueKey` is provided, only one pending or processing job with that key
+   * can exist. Completed or failed jobs don't block new jobs with the same key.
+   *
+   * Failed jobs are automatically retried with exponential backoff up to `maxRetries`
+   * (default: 10 attempts). The delay between retries is calculated as `2^failCount × baseRetryInterval`.
+   *
+   * @template T - The job data payload type (must be JSON-serializable)
+   * @param name - Job type identifier, must match a registered worker
+   * @param data - Job payload, will be passed to the worker handler
+   * @param options - Scheduling and deduplication options
+   * @returns Promise resolving to the created or existing job document
+   * @throws {ConnectionError} If database operation fails or scheduler not initialized
+   *
+   * @example Basic job enqueueing
+   * ```typescript
+   * await monque.enqueue('send-email', {
+   *   to: 'user@example.com',
+   *   subject: 'Welcome!',
+   *   body: 'Thanks for signing up.'
+   * });
+   * ```
+   *
+   * @example Delayed execution
+   * ```typescript
+   * const oneHourLater = new Date(Date.now() + 3600000);
+   * await monque.enqueue('reminder', { message: 'Check in!' }, {
+   *   runAt: oneHourLater
+   * });
+   * ```
+   *
+   * @example Prevent duplicates with unique key
+   * ```typescript
+   * await monque.enqueue('sync-user', { userId: '123' }, {
+   *   uniqueKey: 'sync-user-123'
+   * });
+   * // Subsequent enqueues with same uniqueKey return existing pending/processing job
+   * ```
+   */
+  enqueue<T>(name: string, data: T, options?: EnqueueOptions): Promise<PersistedJob<T>>;
+  /**
+   * Enqueue a job for immediate processing.
+   *
+   * Convenience method equivalent to `enqueue(name, data, { runAt: new Date() })`.
+   * Jobs are picked up on the next poll cycle (typically within 1 second based on `pollInterval`).
+   *
+   * @template T - The job data payload type (must be JSON-serializable)
+   * @param name - Job type identifier, must match a registered worker
+   * @param data - Job payload, will be passed to the worker handler
+   * @returns Promise resolving to the created job document
+   * @throws {ConnectionError} If database operation fails or scheduler not initialized
+   *
+   * @example Send email immediately
+   * ```typescript
+   * await monque.now('send-email', {
+   *   to: 'admin@example.com',
+   *   subject: 'Alert',
+   *   body: 'Immediate attention required'
+   * });
+   * ```
+   *
+   * @example Process order in background
+   * ```typescript
+   * const order = await createOrder(data);
+   * await monque.now('process-order', { orderId: order.id });
+   * return order; // Return immediately, processing happens async
+   * ```
+   */
+  now<T>(name: string, data: T): Promise<PersistedJob<T>>;
+  /**
+   * Schedule a recurring job with a cron expression.
+   *
+   * Creates a job that automatically re-schedules itself based on the cron pattern.
+   * Uses standard 5-field cron format: minute, hour, day of month, month, day of week.
+   * Also supports predefined expressions like `@daily`, `@weekly`, `@monthly`, etc.
+   * After successful completion, the job is reset to `pending` status and scheduled
+   * for its next run based on the cron expression.
+   *
+   * When a `uniqueKey` is provided, only one pending or processing job with that key
+   * can exist. This prevents duplicate scheduled jobs on application restart.
+   *
+   * @template T - The job data payload type (must be JSON-serializable)
+   * @param cron - Cron expression (5 fields or predefined expression)
+   * @param name - Job type identifier, must match a registered worker
+   * @param data - Job payload, will be passed to the worker handler on each run
+   * @param options - Scheduling options (uniqueKey for deduplication)
+   * @returns Promise resolving to the created job document with `repeatInterval` set
+   * @throws {InvalidCronError} If cron expression is invalid
+   * @throws {ConnectionError} If database operation fails or scheduler not initialized
+   *
+   * @example Hourly cleanup job
+   * ```typescript
+   * await monque.schedule('0 * * * *', 'cleanup-temp-files', {
+   *   directory: '/tmp/uploads'
+   * });
+   * ```
+   *
+   * @example Prevent duplicate scheduled jobs with unique key
+   * ```typescript
+   * await monque.schedule('0 * * * *', 'hourly-report', { type: 'sales' }, {
+   *   uniqueKey: 'hourly-report-sales'
+   * });
+   * // Subsequent calls with same uniqueKey return existing pending/processing job
+   * ```
+   *
+   * @example Daily report at midnight (using predefined expression)
+   * ```typescript
+   * await monque.schedule('@daily', 'daily-report', {
+   *   reportType: 'sales',
+   *   recipients: ['analytics@example.com']
+   * });
+   * ```
+   */
+  schedule<T>(cron: string, name: string, data: T, options?: ScheduleOptions): Promise<PersistedJob<T>>;
+  /**
+   * Register a worker to process jobs of a specific type.
+   *
+   * Workers can be registered before or after calling `start()`. Each worker
+   * processes jobs concurrently up to its configured concurrency limit (default: 5).
+   *
+   * The handler function receives the full job object including metadata (`_id`, `status`,
+   * `failCount`, etc.). If the handler throws an error, the job is retried with exponential
+   * backoff up to `maxRetries` times. After exhausting retries, the job is marked as `failed`.
+   *
+   * Events are emitted during job processing: `job:start`, `job:complete`, `job:fail`, and `job:error`.
+   *
+   * **Duplicate Registration**: By default, registering a worker for a job name that already has
+   * a worker will throw a `WorkerRegistrationError`. This fail-fast behavior prevents accidental
+   * replacement of handlers. To explicitly replace a worker, pass `{ replace: true }`.
+   *
+   * @template T - The job data payload type for type-safe access to `job.data`
+   * @param name - Job type identifier to handle
+   * @param handler - Async function to execute for each job
+   * @param options - Worker configuration
+   * @param options.concurrency - Maximum concurrent jobs for this worker (default: `defaultConcurrency`)
+   * @param options.replace - When `true`, replace existing worker instead of throwing error
+   * @throws {WorkerRegistrationError} When a worker is already registered for `name` and `replace` is not `true`
+   *
+   * @example Basic email worker
+   * ```typescript
+   * interface EmailJob {
+   *   to: string;
+   *   subject: string;
+   *   body: string;
+   * }
+   *
+   * monque.worker<EmailJob>('send-email', async (job) => {
+   *   await emailService.send(job.data.to, job.data.subject, job.data.body);
+   * });
+   * ```
+   *
+   * @example Worker with custom concurrency
+   * ```typescript
+   * // Limit to 2 concurrent video processing jobs (resource-intensive)
+   * monque.worker('process-video', async (job) => {
+   *   await videoProcessor.transcode(job.data.videoId);
+   * }, { concurrency: 2 });
+   * ```
+   *
+   * @example Replacing an existing worker
+   * ```typescript
+   * // Replace the existing handler for 'send-email'
+   * monque.worker('send-email', newEmailHandler, { replace: true });
+   * ```
+   *
+   * @example Worker with error handling
+   * ```typescript
+   * monque.worker('sync-user', async (job) => {
+   *   try {
+   *     await externalApi.syncUser(job.data.userId);
+   *   } catch (error) {
+   *     // Job will retry with exponential backoff
+   *     // Delay = 2^failCount × baseRetryInterval (default: 1000ms)
+   *     throw new Error(`Sync failed: ${error.message}`);
+   *   }
+   * });
+   * ```
+   */
+  worker<T>(name: string, handler: JobHandler<T>, options?: WorkerOptions): void;
+  /**
+   * Start polling for and processing jobs.
+   *
+   * Begins polling MongoDB at the configured interval (default: 1 second) to pick up
+   * pending jobs and dispatch them to registered workers. Must call `initialize()` first.
+   * Workers can be registered before or after calling `start()`.
+   *
+   * Jobs are processed concurrently up to each worker's configured concurrency limit.
+   * The scheduler continues running until `stop()` is called.
+   *
+   * @example Basic startup
+   * ```typescript
+   * const monque = new Monque(db);
+   * await monque.initialize();
+   *
+   * monque.worker('send-email', emailHandler);
+   * monque.worker('process-order', orderHandler);
+   *
+   * monque.start(); // Begin processing jobs
+   * ```
+   *
+   * @example With event monitoring
+   * ```typescript
+   * monque.on('job:start', (job) => {
+   *   logger.info(`Starting job ${job.name}`);
+   * });
+   *
+   * monque.on('job:complete', ({ job, duration }) => {
+   *   metrics.recordJobDuration(job.name, duration);
+   * });
+   *
+   * monque.on('job:fail', ({ job, error, willRetry }) => {
+   *   logger.error(`Job ${job.name} failed:`, error);
+   *   if (!willRetry) {
+   *     alerting.sendAlert(`Job permanently failed: ${job.name}`);
+   *   }
+   * });
+   *
+   * monque.start();
+   * ```
+   *
+   * @throws {ConnectionError} If scheduler not initialized (call `initialize()` first)
+   */
+  start(): void;
+  /**
+   * Stop the scheduler gracefully, waiting for in-progress jobs to complete.
+   *
+   * Stops polling for new jobs and waits for all active jobs to finish processing.
+   * Times out after the configured `shutdownTimeout` (default: 30 seconds), emitting
+   * a `job:error` event with a `ShutdownTimeoutError` containing incomplete jobs.
+   * On timeout, jobs still in progress are left as `processing` for stale job recovery.
+   *
+   * It's safe to call `stop()` multiple times - subsequent calls are no-ops if already stopped.
+   *
+   * @returns Promise that resolves when all jobs complete or timeout is reached
+   *
+   * @example Graceful application shutdown
+   * ```typescript
+   * process.on('SIGTERM', async () => {
+   *   console.log('Shutting down gracefully...');
+   *   await monque.stop(); // Wait for jobs to complete
+   *   await mongoClient.close();
+   *   process.exit(0);
+   * });
+   * ```
+   *
+   * @example With timeout handling
+   * ```typescript
+   * monque.on('job:error', ({ error }) => {
+   *   if (error.name === 'ShutdownTimeoutError') {
+   *     logger.warn('Forced shutdown after timeout:', error.incompleteJobs);
+   *   }
+   * });
+   *
+   * await monque.stop();
+   * ```
+   */
+  stop(): Promise<void>;
+  /**
+   * Check if the scheduler is healthy (running and connected).
+   *
+   * Returns `true` when the scheduler is started, initialized, and has an active
+   * MongoDB collection reference. Useful for health check endpoints and monitoring.
+   *
+   * A healthy scheduler:
+   * - Has called `initialize()` successfully
+   * - Has called `start()` and is actively polling
+   * - Has a valid MongoDB collection reference
+   *
+   * @returns `true` if scheduler is running and connected, `false` otherwise
+   *
+   * @example Express health check endpoint
+   * ```typescript
+   * app.get('/health', (req, res) => {
+   *   const healthy = monque.isHealthy();
+   *   res.status(healthy ? 200 : 503).json({
+   *     status: healthy ? 'ok' : 'unavailable',
+   *     scheduler: healthy,
+   *     timestamp: new Date().toISOString()
+   *   });
+   * });
+   * ```
+   *
+   * @example Kubernetes readiness probe
+   * ```typescript
+   * app.get('/readyz', (req, res) => {
+   *   if (monque.isHealthy() && dbConnected) {
+   *     res.status(200).send('ready');
+   *   } else {
+   *     res.status(503).send('not ready');
+   *   }
+   * });
+   * ```
+   *
+   * @example Periodic health monitoring
+   * ```typescript
+   * setInterval(() => {
+   *   if (!monque.isHealthy()) {
+   *     logger.error('Scheduler unhealthy');
+   *     metrics.increment('scheduler.unhealthy');
+   *   }
+   * }, 60000); // Check every minute
+   * ```
+   */
+  isHealthy(): boolean;
+  /**
+   * Query jobs from the queue with optional filters.
+   *
+   * Provides read-only access to job data for monitoring, debugging, and
+   * administrative purposes. Results are ordered by `nextRunAt` ascending.
+   *
+   * @template T - The expected type of the job data payload
+   * @param filter - Optional filter criteria
+   * @returns Promise resolving to array of matching jobs
+   * @throws {ConnectionError} If scheduler not initialized
+   *
+   * @example Get all pending jobs
+   * ```typescript
+   * const pendingJobs = await monque.getJobs({ status: JobStatus.PENDING });
+   * console.log(`${pendingJobs.length} jobs waiting`);
+   * ```
+   *
+   * @example Get failed email jobs
+   * ```typescript
+   * const failedEmails = await monque.getJobs({
+   *   name: 'send-email',
+   *   status: JobStatus.FAILED,
+   * });
+   * for (const job of failedEmails) {
+   *   console.error(`Job ${job._id} failed: ${job.failReason}`);
+   * }
+   * ```
+   *
+   * @example Paginated job listing
+   * ```typescript
+   * const page1 = await monque.getJobs({ limit: 50, skip: 0 });
+   * const page2 = await monque.getJobs({ limit: 50, skip: 50 });
+   * ```
+   *
+   * @example Use with type guards from @monque/core
+   * ```typescript
+   * import { isPendingJob, isRecurringJob } from '@monque/core';
+   *
+   * const jobs = await monque.getJobs();
+   * const pendingRecurring = jobs.filter(job => isPendingJob(job) && isRecurringJob(job));
+   * ```
+   */
+  getJobs<T = unknown>(filter?: GetJobsFilter): Promise<PersistedJob<T>[]>;
+  /**
+   * Get a single job by its MongoDB ObjectId.
+   *
+   * Useful for retrieving job details when you have a job ID from events,
+   * logs, or stored references.
+   *
+   * @template T - The expected type of the job data payload
+   * @param id - The job's ObjectId
+   * @returns Promise resolving to the job if found, null otherwise
+   * @throws {ConnectionError} If scheduler not initialized
+   *
+   * @example Look up job from event
+   * ```typescript
+   * monque.on('job:fail', async ({ job }) => {
+   *   // Later, retrieve the job to check its status
+   *   const currentJob = await monque.getJob(job._id);
+   *   console.log(`Job status: ${currentJob?.status}`);
+   * });
+   * ```
+   *
+   * @example Admin endpoint
+   * ```typescript
+   * app.get('/jobs/:id', async (req, res) => {
+   *   const job = await monque.getJob(new ObjectId(req.params.id));
+   *   if (!job) {
+   *     return res.status(404).json({ error: 'Job not found' });
+   *   }
+   *   res.json(job);
+   * });
+   * ```
+   */
+  getJob<T = unknown>(id: ObjectId): Promise<PersistedJob<T> | null>;
+  /**
+   * Poll for available jobs and process them.
+   *
+   * Called at regular intervals (configured by `pollInterval`). For each registered worker,
+   * attempts to acquire jobs up to the worker's available concurrency slots.
+   *
+   * @private
+   */
+  private poll;
+  /**
+   * Atomically acquire a pending job for processing using the claimedBy pattern.
+   *
+   * Uses MongoDB's `findOneAndUpdate` with atomic operations to ensure only one scheduler
+   * instance can claim a job. The query ensures the job is:
+   * - In pending status
+   * - Has nextRunAt <= now
+   * - Is not claimed by another instance (claimedBy is null/undefined)
+   *
+   * @private
+   * @param name - The job type to acquire
+   * @returns The acquired job with updated status, claimedBy, and heartbeat info, or `null` if no jobs available
+   */
+  private acquireJob;
+  /**
+   * Execute a job using its registered worker handler.
+   *
+   * Tracks the job as active during processing, emits lifecycle events, and handles
+   * both success and failure cases. On success, calls `completeJob()`. On failure,
+   * calls `failJob()` which implements exponential backoff retry logic.
+   *
+   * @private
+   * @param job - The job to process
+   * @param worker - The worker registration containing the handler and active job tracking
+   */
+  private processJob;
+  /**
+   * Mark a job as completed successfully.
+   *
+   * For recurring jobs (with `repeatInterval`), schedules the next run based on the cron
+   * expression and resets `failCount` to 0. For one-time jobs, sets status to `completed`.
+   * Clears `lockedAt` and `failReason` fields in both cases.
+   *
+   * @private
+   * @param job - The job that completed successfully
+   */
+  private completeJob;
+  /**
+   * Handle job failure with exponential backoff retry logic.
+   *
+   * Increments `failCount` and calculates next retry time using exponential backoff:
+   * `nextRunAt = 2^failCount × baseRetryInterval` (capped by optional `maxBackoffDelay`).
+   *
+   * If `failCount >= maxRetries`, marks job as permanently `failed`. Otherwise, resets
+   * to `pending` status for retry. Stores error message in `failReason` field.
+   *
+   * @private
+   * @param job - The job that failed
+   * @param error - The error that caused the failure
+   */
+  private failJob;
+  /**
+   * Ensure the scheduler is initialized before operations.
+   *
+   * @private
+   * @throws {ConnectionError} If scheduler not initialized or collection unavailable
+   */
+  private ensureInitialized;
+  /**
+   * Update heartbeats for all jobs claimed by this scheduler instance.
+   *
+   * This method runs periodically while the scheduler is running to indicate
+   * that jobs are still being actively processed.
+   *
+   * `lastHeartbeat` is primarily an observability signal (monitoring/debugging).
+   * Stale recovery is based on `lockedAt` + `lockTimeout`.
+   *
+   * @private
+   */
+  private updateHeartbeats;
+  /**
+   * Set up MongoDB Change Stream for real-time job notifications.
+   *
+   * Change streams provide instant notifications when jobs are inserted or when
+   * job status changes to pending (e.g., after a retry). This eliminates the
+   * polling delay for reactive job processing.
+   *
+   * The change stream watches for:
+   * - Insert operations (new jobs)
+   * - Update operations where status field changes
+   *
+   * If change streams are unavailable (e.g., standalone MongoDB), the system
+   * gracefully falls back to polling-only mode.
+   *
+   * @private
+   */
+  private setupChangeStream;
+  /**
+   * Handle a change stream event by triggering a debounced poll.
+   *
+   * Events are debounced to prevent "claim storms" when multiple changes arrive
+   * in rapid succession (e.g., bulk job inserts). A 100ms debounce window
+   * collects multiple events and triggers a single poll.
+   *
+   * @private
+   * @param change - The change stream event document
+   */
+  private handleChangeStreamEvent;
+  /**
+   * Handle change stream errors with exponential backoff reconnection.
+   *
+   * Attempts to reconnect up to `maxChangeStreamReconnectAttempts` times with
+   * exponential backoff (base 1000ms). After exhausting retries, falls back to
+   * polling-only mode.
+   *
+   * @private
+   * @param error - The error that caused the change stream failure
+   */
+  private handleChangeStreamError;
+  /**
+   * Close the change stream cursor and emit closed event.
+   *
+   * @private
+   */
+  private closeChangeStream;
+  /**
+   * Get array of active job IDs across all workers.
+   *
+   * @private
+   * @returns Array of job ID strings currently being processed
+   */
+  private getActiveJobs;
+  /**
+   * Get list of active job documents (for shutdown timeout error).
+   *
+   * @private
+   * @returns Array of active Job objects
+   */
+  private getActiveJobsList;
+  /**
+   * Convert a MongoDB document to a typed PersistedJob object.
+   *
+   * Maps raw MongoDB document fields to the strongly-typed `PersistedJob<T>` interface,
+   * ensuring type safety and handling optional fields (`lockedAt`, `failReason`, etc.).
+   *
+   * @private
+   * @template T - The job data payload type
+   * @param doc - The raw MongoDB document with `_id`
+   * @returns A strongly-typed PersistedJob object with guaranteed `_id`
+   */
+  private documentToPersistedJob;
+  /**
+   * Type-safe event emitter methods
+   */
+  emit<K extends keyof MonqueEventMap>(event: K, payload: MonqueEventMap[K]): boolean;
+  on<K extends keyof MonqueEventMap>(event: K, listener: (payload: MonqueEventMap[K]) => void): this;
+  once<K extends keyof MonqueEventMap>(event: K, listener: (payload: MonqueEventMap[K]) => void): this;
+  off<K extends keyof MonqueEventMap>(event: K, listener: (payload: MonqueEventMap[K]) => void): this;
+}
+//#endregion
+//#region src/shared/errors.d.ts
+/**
+ * Base error class for all Monque-related errors.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await monque.enqueue('job', data);
+ * } catch (error) {
+ *   if (error instanceof MonqueError) {
+ *     console.error('Monque error:', error.message);
+ *   }
+ * }
+ * ```
+ */
+declare class MonqueError extends Error {
+  constructor(message: string);
+}
+/**
+ * Error thrown when an invalid cron expression is provided.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await monque.schedule('invalid cron', 'job', data);
+ * } catch (error) {
+ *   if (error instanceof InvalidCronError) {
+ *     console.error('Invalid expression:', error.expression);
+ *   }
+ * }
+ * ```
+ */
+declare class InvalidCronError extends MonqueError {
+  readonly expression: string;
+  constructor(expression: string, message: string);
+}
+/**
+ * Error thrown when there's a database connection issue.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await monque.enqueue('job', data);
+ * } catch (error) {
+ *   if (error instanceof ConnectionError) {
+ *     console.error('Database connection lost');
+ *   }
+ * }
+ * ```
+ */
+declare class ConnectionError extends MonqueError {
+  constructor(message: string, options?: {
+    cause?: Error;
+  });
+}
+/**
+ * Error thrown when graceful shutdown times out.
+ * Includes information about jobs that were still in progress.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await monque.stop();
+ * } catch (error) {
+ *   if (error instanceof ShutdownTimeoutError) {
+ *     console.error('Incomplete jobs:', error.incompleteJobs.length);
+ *   }
+ * }
+ * ```
+ */
+declare class ShutdownTimeoutError extends MonqueError {
+  readonly incompleteJobs: Job[];
+  constructor(message: string, incompleteJobs: Job[]);
+}
+/**
+ * Error thrown when attempting to register a worker for a job name
+ * that already has a registered worker, without explicitly allowing replacement.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   monque.worker('send-email', handler1);
+ *   monque.worker('send-email', handler2); // throws
+ * } catch (error) {
+ *   if (error instanceof WorkerRegistrationError) {
+ *     console.error('Worker already registered for:', error.jobName);
+ *   }
+ * }
+ *
+ * // To intentionally replace a worker:
+ * monque.worker('send-email', handler2, { replace: true });
+ * ```
+ */
+declare class WorkerRegistrationError extends MonqueError {
+  readonly jobName: string;
+  constructor(message: string, jobName: string);
+}
+//#endregion
+//#region src/shared/utils/backoff.d.ts
+/**
+ * Default base interval for exponential backoff in milliseconds.
+ * @default 1000
+ */
+declare const DEFAULT_BASE_INTERVAL = 1000;
+/**
+ * Default maximum delay cap for exponential backoff in milliseconds.
+ *
+ * This prevents unbounded delays (e.g. failCount=20 is >11 days at 1s base)
+ * and avoids precision/overflow issues for very large fail counts.
+ * @default 86400000 (24 hours)
+ */
+declare const DEFAULT_MAX_BACKOFF_DELAY: number;
+/**
+ * Calculate the next run time using exponential backoff.
+ *
+ * Formula: nextRunAt = now + (2^failCount × baseInterval)
+ *
+ * @param failCount - Number of previous failed attempts
+ * @param baseInterval - Base interval in milliseconds (default: 1000ms)
+ * @param maxDelay - Maximum delay in milliseconds (optional)
+ * @returns The next run date
+ *
+ * @example
+ * ```typescript
+ * // First retry (failCount=1): 2^1 * 1000 = 2000ms delay
+ * const nextRun = calculateBackoff(1);
+ *
+ * // Second retry (failCount=2): 2^2 * 1000 = 4000ms delay
+ * const nextRun = calculateBackoff(2);
+ *
+ * // With custom base interval
+ * const nextRun = calculateBackoff(3, 500); // 2^3 * 500 = 4000ms delay
+ *
+ * // With max delay
+ * const nextRun = calculateBackoff(10, 1000, 60000); // capped at 60000ms
+ * ```
+ */
+declare function calculateBackoff(failCount: number, baseInterval?: number, maxDelay?: number): Date;
+/**
+ * Calculate just the delay in milliseconds for a given fail count.
+ *
+ * @param failCount - Number of previous failed attempts
+ * @param baseInterval - Base interval in milliseconds (default: 1000ms)
+ * @param maxDelay - Maximum delay in milliseconds (optional)
+ * @returns The delay in milliseconds
+ */
+declare function calculateBackoffDelay(failCount: number, baseInterval?: number, maxDelay?: number): number;
+//#endregion
+//#region src/shared/utils/cron.d.ts
+/**
+ * Parse a cron expression and return the next scheduled run date.
+ *
+ * @param expression - A 5-field cron expression (minute hour day-of-month month day-of-week) or a predefined expression
+ * @param currentDate - The reference date for calculating next run (default: now)
+ * @returns The next scheduled run date
+ * @throws {InvalidCronError} If the cron expression is invalid
+ *
+ * @example
+ * ```typescript
+ * // Every minute
+ * const nextRun = getNextCronDate('* * * * *');
+ *
+ * // Every day at midnight
+ * const nextRun = getNextCronDate('0 0 * * *');
+ *
+ * // Using predefined expression
+ * const nextRun = getNextCronDate('@daily');
+ *
+ * // Every Monday at 9am
+ * const nextRun = getNextCronDate('0 9 * * 1');
+ * ```
+ */
+declare function getNextCronDate(expression: string, currentDate?: Date): Date;
+/**
+ * Validate a cron expression without calculating the next run date.
+ *
+ * @param expression - A 5-field cron expression
+ * @throws {InvalidCronError} If the cron expression is invalid
+ *
+ * @example
+ * ```typescript
+ * validateCronExpression('0 9 * * 1'); // Throws if invalid
+ * ```
+ */
+declare function validateCronExpression(expression: string): void;
+//#endregion
+export { ConnectionError, DEFAULT_BASE_INTERVAL, DEFAULT_MAX_BACKOFF_DELAY, type EnqueueOptions, type GetJobsFilter, InvalidCronError, type Job, type JobHandler, JobStatus, type JobStatusType, Monque, MonqueError, type MonqueEventMap, type MonqueOptions, type PersistedJob, type ScheduleOptions, ShutdownTimeoutError, type WorkerOptions, WorkerRegistrationError, calculateBackoff, calculateBackoffDelay, getNextCronDate, isCompletedJob, isFailedJob, isPendingJob, isPersistedJob, isProcessingJob, isRecurringJob, isValidJobStatus, validateCronExpression };
+//# sourceMappingURL=index.d.cts.map