@boringnode/queue 0.1.0 → 0.3.0

package/build/{index-2Ng_OpVK.d.ts → index-PDfE6h8d.d.ts}

@@ -185,7 +185,34 @@ interface Logger {
     child(obj: LogObject): Logger;
 }
 
+/**
+ * Duration can be specified as milliseconds (number) or as a human-readable string.
+ *
+ * Supported string formats: '1s', '5m', '2h', '1d', etc.
+ *
+ * @example
+ * ```typescript
+ * const timeout: Duration = '30s'   // 30 seconds
+ * const delay: Duration = 5000      // 5000 milliseconds
+ * const interval: Duration = '5m'   // 5 minutes
+ * ```
+ */
 type Duration = number | string;
+/**
+ * Retention policy for completed/failed jobs.
+ *
+ * - `true` (default): Remove job immediately
+ * - `false`: Keep job in history indefinitely
+ * - `{ age?, count? }`: Keep with pruning by age and/or count
+ */
+type JobRetention = boolean | {
+    age?: Duration;
+    count?: number;
+};
+/**
+ * Possible statuses for a job in the queue.
+ */
+type JobStatus = 'pending' | 'active' | 'delayed' | 'completed' | 'failed';
 /**
  * Result returned when dispatching a job.
  *
@@ -199,23 +226,152 @@ interface DispatchResult {
     /** Unique identifier for this specific job instance */
     jobId: string;
 }
+/**
+ * Result returned when dispatching multiple jobs at once.
+ *
+ * @example
+ * ```typescript
+ * const { jobIds } = await SendEmailJob.dispatchMany(payloads)
+ * console.log(`Dispatched ${jobIds.length} jobs`)
+ * ```
+ */
+interface DispatchManyResult {
+    /** Unique identifiers for all dispatched job instances */
+    jobIds: string[];
+}
+/**
+ * Internal representation of a job in the queue.
+ *
+ * This is used by adapters to store and retrieve job data.
+ * Not typically used directly by application code.
+ */
 interface JobData {
+    /**
+     * Unique identifier for this job.
+     */
     id: string;
+    /**
+     * Job class name.
+     */
     name: string;
+    /**
+     * Serialized job payload.
+     */
     payload: any;
+    /**
+     * Number of execution attempts so far.
+     */
     attempts: number;
+    /**
+     * Job priority (lower = higher priority).
+     *
+     * @default 0
+     */
     priority?: number;
+    /**
+     * When to retry this job next (for failed jobs).
+     */
     nextRetryAt?: Date;
+    /**
+     * Number of times this job was recovered from stalled state.
+     */
     stalledCount?: number;
+    /**
+     * Optional group identifier for organizing related jobs.
+     *
+     * Jobs with the same groupId can be filtered and displayed together
+     * in monitoring UIs. Useful for batch operations like newsletters
+     * or bulk exports.
+     *
+     * @example
+     * ```typescript
+     * await SendEmailJob.dispatch({ to: 'user@example.com' })
+     *   .group('newsletter-jan-2025')
+     *   .run()
+     * ```
+     */
+    groupId?: string;
 }
+/**
+ * Record of a job's current state, including history for completed/failed jobs.
+ */
+interface JobRecord {
+    /** Current status of the job */
+    status: JobStatus;
+    /** Original job data */
+    data: JobData;
+    /** Timestamp when the job finished (for completed/failed jobs) */
+    finishedAt?: number;
+    /** Error message (for failed jobs) */
+    error?: string;
+}
+/**
+ * Static options for a Job class.
+ *
+ * Define these as a static property on your Job class to configure
+ * default behavior for all instances.
+ *
+ * @example
+ * ```typescript
+ * class SendEmailJob extends Job<EmailPayload> {
+ *   static options: JobOptions = {
+ *     name: 'SendEmailJob',
+ *     queue: 'emails',
+ *     maxRetries: 3,
+ *     timeout: '30s',
+ *   }
+ * }
+ * ```
+ */
 interface JobOptions {
+    /**
+     * Unique name for this job class.
+     *
+     * Used to identify the job when dispatching and processing.
+     *
+     * @default constructor.name
+     */
+    name?: string;
+    /**
+     * Queue name for this job.
+     *
+     * @default 'default'
+     */
     queue?: string;
+    /**
+     * Adapter name or factory to use for this job.
+     */
     adapter?: string | (() => Adapter);
+    /**
+     * Maximum retry attempts before permanent failure.
+     *
+     * @default 3
+     */
     maxRetries?: number;
+    /**
+     * Job priority (lower = higher priority).
+     *
+     * @default 0
+     */
     priority?: number;
+    /**
+     * Retry configuration (backoff strategy, delays, etc.).
+     */
     retry?: RetryConfig;
+    /**
+     * Maximum execution time before timeout.
+     *
+     * @default undefined (no timeout)
+     */
     timeout?: Duration;
+    /**
+     * Whether to mark job as failed on timeout.
+     *
+     * @default true
+     */
     failOnTimeout?: boolean;
+    removeOnComplete?: JobRetention;
+    removeOnFail?: JobRetention;
 }
 /**
  * Context information available to a job during execution.
@@ -249,34 +405,39 @@ interface JobContext {
     /** Number of times this job has been recovered from stalled state */
     stalledCount: number;
 }
-type JobClass<T extends Job = Job> = (new (payload: any, context: JobContext) => T) & {
+/**
+ * Type representing a Job class constructor.
+ *
+ * The constructor accepts any arguments for dependency injection.
+ * Payload and context are provided separately via `$hydrate()`.
+ */
+type JobClass<T extends Job = Job> = (new (...args: any[]) => T) & {
     options?: JobOptions;
 };
 /**
  * Factory function for custom job instantiation.
  *
  * Use this to integrate with IoC containers for dependency injection.
- * The factory receives the job class, payload, and context, and must return
- * a job instance (or a Promise that resolves to one).
+ * The factory receives only the job class and should return an instance
+ * with all dependencies injected. The worker will call `$hydrate()` separately
+ * to provide payload, context, and signal.
  *
  * @param JobClass - The job class to instantiate
- * @param payload - The payload data for the job
- * @param context - The job execution context (jobId, attempt, queue, etc.)
  * @returns The job instance, or a Promise resolving to the instance
  *
  * @example
  * ```typescript
  * // With AdonisJS IoC container
- * const worker = new Worker({
- *   worker: {
- *     jobFactory: async (JobClass, payload, context) => {
- *       return app.container.make(JobClass, [payload, context])
- *     }
+ * await QueueManager.init({
+ *   default: 'redis',
+ *   adapters: { redis: redis() },
+ *   jobFactory: async (JobClass) => {
+ *     return app.container.make(JobClass)
  *   }
  * })
  * ```
  */
-type JobFactory = (JobClass: JobClass, payload: any, context: JobContext) => Job | Promise<Job>;
+type JobFactory = (JobClass: JobClass) => Job | Promise<Job>;
 interface RetryConfig {
     maxRetries?: number;
     backoff?: () => BackoffStrategy$1;
@@ -292,6 +453,7 @@ interface BackoffConfig {
 interface QueueConfig {
     adapter?: string;
     retry?: any;
+    defaultJobOptions?: JobOptions;
 }
 interface WorkerConfig {
     /**
@@ -370,7 +532,7 @@ interface ScheduleConfig {
     /** Optional ID for the schedule (UUID if not set). Used for upsert. */
     id?: string;
     /** Job class name */
-    jobName: string;
+    name: string;
     /** Job payload */
     payload: any;
     /** Cron expression (mutually exclusive with everyMs) */
@@ -394,7 +556,7 @@ interface ScheduleData {
     /** Unique identifier */
     id: string;
     /** Job class name */
-    jobName: string;
+    name: string;
     /** Job payload */
     payload: any;
     /** Cron expression (null if using interval) */
@@ -438,6 +600,7 @@ interface QueueManagerConfig {
     default: string;
     adapters: Record<string, AdapterFactory>;
     retry?: RetryConfig;
+    defaultJobOptions?: JobOptions;
     queues?: Record<string, QueueConfig>;
     worker?: WorkerConfig;
     locations?: string[];
@@ -446,15 +609,17 @@ interface QueueManagerConfig {
      * Custom factory function for job instantiation.
      *
      * Use this to integrate with IoC containers for dependency injection.
-     * When provided, this factory is called instead of `new JobClass(payload, context)`.
+     * When provided, this factory is called instead of `new JobClass()`.
+     * The worker will call `$hydrate()` on the returned instance to provide
+     * payload, context, and signal.
      *
      * @example
      * ```typescript
      * await QueueManager.init({
      *   default: 'redis',
      *   adapters: { redis: redis() },
-     *   jobFactory: async (JobClass, payload, context) => {
-     *     return app.container.make(JobClass, [payload, context])
+     *   jobFactory: async (JobClass) => {
+     *     return app.container.make(JobClass)
      *   }
      * })
      * ```
@@ -529,16 +694,18 @@ interface Adapter {
      *
      * @param jobId - The job ID to complete
      * @param queue - The queue the job belongs to
+     * @param removeOnComplete - Optional retention policy for completed jobs
      */
-    completeJob(jobId: string, queue: string): Promise<void>;
+    completeJob(jobId: string, queue: string, removeOnComplete?: JobRetention): Promise<void>;
     /**
      * Mark a job as failed permanently and remove it from the queue.
      *
      * @param jobId - The job ID to fail
      * @param queue - The queue the job belongs to
      * @param error - Optional error that caused the failure
+     * @param removeOnFail - Optional retention policy for failed jobs
      */
-    failJob(jobId: string, queue: string, error?: Error): Promise<void>;
+    failJob(jobId: string, queue: string, error?: Error, removeOnFail?: JobRetention): Promise<void>;
     /**
      * Retry a job by moving it back to pending with incremented attempts.
      *
@@ -547,6 +714,14 @@ interface Adapter {
      * @param retryAt - Optional future date to delay the retry
      */
     retryJob(jobId: string, queue: string, retryAt?: Date): Promise<void>;
+    /**
+     * Get a job record by id.
+     *
+     * @param jobId - The job ID to retrieve
+     * @param queue - The queue the job belongs to
+     * @returns The job record, or null if not found
+     */
+    getJob(jobId: string, queue: string): Promise<JobRecord | null>;
     /**
      * Push a job to the default queue for immediate processing.
      *
@@ -575,6 +750,25 @@ interface Adapter {
      * @param delay - Delay in milliseconds before the job becomes available
      */
     pushLaterOn(queue: string, jobData: JobData, delay: number): Promise<void>;
+    /**
+     * Push multiple jobs to the default queue for immediate processing.
+     *
+     * This is more efficient than calling push() multiple times as it
+     * batches the operations (e.g., Redis pipeline, SQL batch insert).
+     *
+     * @param jobs - Array of job data to push
+     */
+    pushMany(jobs: JobData[]): Promise<void>;
+    /**
+     * Push multiple jobs to a specific queue for immediate processing.
+     *
+     * This is more efficient than calling pushOn() multiple times as it
+     * batches the operations (e.g., Redis pipeline, SQL batch insert).
+     *
+     * @param queue - The queue name to push to
+     * @param jobs - Array of job data to push
+     */
+    pushManyOn(queue: string, jobs: JobData[]): Promise<void>;
     /**
      * Get the number of pending jobs in the default queue.
      *
@@ -737,6 +931,25 @@ declare class JobDispatcher<T> {
      * ```
      */
     priority(priority: number): this;
+    /**
+     * Assign this job to a group.
+     *
+     * Jobs with the same groupId can be filtered and displayed together
+     * in monitoring UIs. Useful for batch operations like newsletters
+     * or bulk exports.
+     *
+     * @param groupId - Group identifier
+     * @returns This dispatcher for chaining
+     *
+     * @example
+     * ```typescript
+     * // Group newsletter jobs together
+     * await SendEmailJob.dispatch({ to: 'user@example.com' })
+     *   .group('newsletter-jan-2025')
+     *   .run()
+     * ```
+     */
+    group(groupId: string): this;
     /**
      * Use a specific adapter for this job.
      *
@@ -777,6 +990,127 @@ declare class JobDispatcher<T> {
     then(onFulfilled?: (value: DispatchResult) => any, onRejected?: (reason: any) => any): Promise<any>;
 }
 
+/**
+ * Fluent builder for dispatching multiple jobs to the queue in a single batch.
+ *
+ * Provides a chainable API for configuring job options before dispatch.
+ * Usually created via `Job.dispatchMany()` rather than directly.
+ *
+ * ```
+ * Job.dispatchMany(payloads)
+ *     .toQueue('emails')     // optional: target queue
+ *     .priority(1)           // optional: 1-10, lower = higher priority
+ *     .group('batch-123')    // optional: group all jobs together
+ *     .with('redis')         // optional: specific adapter
+ *     .run()                 // dispatch all jobs
+ * ```
+ *
+ * @typeParam T - The payload type for these jobs
+ *
+ * @example
+ * ```typescript
+ * // Batch dispatch for newsletter
+ * const { jobIds } = await SendEmailJob.dispatchMany([
+ *   { to: 'user1@example.com', subject: 'Newsletter' },
+ *   { to: 'user2@example.com', subject: 'Newsletter' },
+ * ])
+ *   .group('newsletter-jan-2025')
+ *   .toQueue('emails')
+ *   .run()
+ *
+ * console.log(`Dispatched ${jobIds.length} jobs`)
+ * ```
+ */
+declare class JobBatchDispatcher<T> {
+    #private;
+    /**
+     * Create a new batch job dispatcher.
+     *
+     * @param name - The job class name (used to locate the class at runtime)
+     * @param payloads - Array of data to pass to each job
+     */
+    constructor(name: string, payloads: T[]);
+    /**
+     * Set the target queue for all jobs.
+     *
+     * @param queue - Queue name (default: 'default')
+     * @returns This dispatcher for chaining
+     *
+     * @example
+     * ```typescript
+     * await SendEmailJob.dispatchMany(payloads).toQueue('emails')
+     * ```
+     */
+    toQueue(queue: string): this;
+    /**
+     * Set the priority for all jobs.
+     *
+     * Lower numbers = higher priority. Jobs with lower priority values
+     * are processed before jobs with higher values.
+     *
+     * @param priority - Priority level (1-10, default: 5)
+     * @returns This dispatcher for chaining
+     *
+     * @example
+     * ```typescript
+     * await UrgentJob.dispatchMany(payloads).priority(1)
+     * ```
+     */
+    priority(priority: number): this;
+    /**
+     * Assign all jobs to a group.
+     *
+     * Jobs with the same groupId can be filtered and displayed together
+     * in monitoring UIs. Useful for batch operations like newsletters
+     * or bulk exports.
+     *
+     * @param groupId - Group identifier
+     * @returns This dispatcher for chaining
+     *
+     * @example
+     * ```typescript
+     * await SendEmailJob.dispatchMany(recipients)
+     *   .group('newsletter-jan-2025')
+     *   .run()
+     * ```
+     */
+    group(groupId: string): this;
+    /**
+     * Use a specific adapter for these jobs.
+     *
+     * @param adapter - Adapter name or factory function
+     * @returns This dispatcher for chaining
+     *
+     * @example
+     * ```typescript
+     * await Job.dispatchMany(payloads).with('redis')
+     * ```
+     */
+    with(adapter: string | (() => Adapter)): this;
+    /**
+     * Dispatch all jobs to the queue.
+     *
+     * @returns A DispatchManyResult containing all jobIds
+     *
+     * @example
+     * ```typescript
+     * const { jobIds } = await SendEmailJob.dispatchMany(payloads).run()
+     * console.log(`Dispatched ${jobIds.length} jobs`)
+     * ```
+     */
+    run(): Promise<DispatchManyResult>;
+    /**
+     * Thenable implementation for auto-dispatch when awaited.
+     *
+     * Allows `await Job.dispatchMany(payloads)` without explicit `.run()`.
+     *
+     * @param onFulfilled - Success callback
+     * @param onRejected - Error callback
+     * @returns Promise resolving to the DispatchManyResult
+     */
+    then(onFulfilled?: (value: DispatchManyResult) => any, onRejected?: (reason: any) => any): Promise<any>;
+}
+
 /**
  * Fluent builder for creating job schedules.
  *
@@ -797,7 +1131,7 @@ declare class JobDispatcher<T> {
  */
 declare class ScheduleBuilder implements PromiseLike<ScheduleResult> {
     #private;
-    constructor(jobName: string, payload: any);
+    constructor(name: string, payload: any);
     /**
      * Set a custom schedule ID.
      * If not specified, defaults to the job name.
@@ -854,12 +1188,14 @@ declare class ScheduleBuilder implements PromiseLike<ScheduleResult> {
  * Extend this class to create your own jobs. Each job must implement
  * the `execute()` method which contains the job's business logic.
  *
+ * The constructor is reserved for dependency injection. Payload and context
+ * are provided separately via the `$hydrate()` method (called by the worker).
+ *
  * @typeParam Payload - The type of data this job receives
  *
  * @example
  * ```typescript
  * import { Job } from '@boringnode/queue'
- * import type { JobContext } from '@boringnode/queue'
  *
  * interface SendEmailPayload {
  *   to: string
@@ -873,13 +1209,14 @@ declare class ScheduleBuilder implements PromiseLike<ScheduleResult> {
  *     maxRetries: 3,
  *   }
  *
- *   constructor(payload: SendEmailPayload, context: JobContext) {
- *     super(payload, context)
+ *   // Constructor is for dependency injection only
+ *   constructor(private mailer: MailerService) {
+ *     super()
  *   }
  *
  *   async execute() {
  *     console.log(`Attempt ${this.context.attempt} for job ${this.context.jobId}`)
- *     await sendEmail(this.payload.to, this.payload.subject, this.payload.body)
+ *     await this.mailer.send(this.payload.to, this.payload.subject, this.payload.body)
  *   }
  *
  *   async failed(error: Error) {
@@ -890,9 +1227,38 @@ declare class ScheduleBuilder implements PromiseLike<ScheduleResult> {
  */
 declare abstract class Job<Payload = any> {
     #private;
-    /** Static options for this job class (queue, retries, timeout, etc.) */
+    /**
+     * Static options for this job class.
+     *
+     * Override this property in subclasses to configure job behavior
+     * such as queue name, retry policy, timeout, and more.
+     *
+     * @example
+     * ```typescript
+     * class SendEmailJob extends Job<SendEmailPayload> {
+     *   static options = {
+     *     queue: 'emails',
+     *     maxRetries: 3,
+     *     timeout: '30s',
+     *   }
+     * }
+     * ```
+     */
     static options: JobOptions;
-    /** The payload data passed to this job instance */
+    /**
+     * The payload data passed to this job instance.
+     *
+     * Contains the data provided when the job was dispatched.
+     * Available after the job has been hydrated by the worker.
+     *
+     * @example
+     * ```typescript
+     * async execute() {
+     *   const { to, subject, body } = this.payload
+     *   await sendEmail(to, subject, body)
+     * }
+     * ```
+     */
     get payload(): Payload;
     /**
      * Context information for the current job execution.
@@ -912,12 +1278,36 @@ declare abstract class Job<Payload = any> {
      */
     get context(): JobContext;
     /**
-     * Create a new job instance.
+     * The abort signal for timeout handling.
+     *
+     * Check `signal.aborted` in long-running operations to handle timeouts gracefully.
+     *
+     * @example
+     * ```typescript
+     * async execute() {
+     *   for (const item of this.payload.items) {
+     *     if (this.signal?.aborted) {
+     *       throw new Error('Job timed out')
+     *     }
+     *     await processItem(item)
+     *   }
+     * }
+     * ```
+     */
+    get signal(): AbortSignal | undefined;
+    /**
+     * Hydrate the job with payload, context, and optional abort signal.
+     *
+     * This method is called by the worker after instantiation to provide
+     * the job's runtime data. It should not be called directly by user code.
      *
      * @param payload - The data to be processed by this job
-     * @param context - The job execution context (provided by the worker)
+     * @param context - The job execution context
+     * @param signal - Optional abort signal for timeout handling
+     *
+     * @internal
      */
-    constructor(payload: Payload, context: JobContext);
+    $hydrate(payload: Payload, context: JobContext, signal?: AbortSignal): void;
     /**
      * Dispatch this job to the queue.
      *
@@ -941,7 +1331,35 @@ declare abstract class Job<Payload = any> {
      *   .run()
      * ```
      */
-    static dispatch<T extends Job>(this: new (payload: any, context: JobContext) => T, payload: T extends Job<infer P> ? P : never): JobDispatcher<T extends Job<infer P> ? P : never>;
+    static dispatch<T extends Job>(this: new (...args: any[]) => T, payload: T extends Job<infer P> ? P : never): JobDispatcher<T extends Job<infer P> ? P : never>;
+    /**
+     * Dispatch multiple jobs to the queue in a single batch.
+     *
+     * Returns a JobBatchDispatcher for fluent configuration before dispatching.
+     * The jobs are not actually dispatched until `.run()` is called or the
+     * dispatcher is awaited.
+     *
+     * This is more efficient than calling `dispatch()` multiple times as it
+     * uses batched operations (e.g., Redis pipeline, SQL batch insert).
+     *
+     * @param payloads - Array of data to pass to each job
+     * @returns A JobBatchDispatcher for fluent configuration
+     *
+     * @example
+     * ```typescript
+     * // Batch dispatch for newsletter
+     * const { jobIds } = await SendEmailJob.dispatchMany([
+     *   { to: 'user1@example.com', subject: 'Newsletter' },
+     *   { to: 'user2@example.com', subject: 'Newsletter' },
+     * ])
+     *   .group('newsletter-jan-2025')
+     *   .toQueue('emails')
+     *   .run()
+     *
+     * console.log(`Dispatched ${jobIds.length} jobs`)
+     * ```
+     */
+    static dispatchMany<T extends Job>(this: new (...args: any[]) => T, payloads: (T extends Job<infer P> ? P : never)[]): JobBatchDispatcher<T extends Job<infer P> ? P : never>;
     /**
      * Create a schedule for this job.
      *
@@ -967,22 +1385,22 @@ declare abstract class Job<Payload = any> {
      *   .run()
      * ```
      */
-    static schedule<T extends Job>(this: new (payload: any, context: JobContext) => T, payload: T extends Job<infer P> ? P : never): ScheduleBuilder;
+    static schedule<T extends Job>(this: new (...args: any[]) => T, payload: T extends Job<infer P> ? P : never): ScheduleBuilder;
     /**
      * Execute the job's business logic.
      *
      * This method is called by the worker when processing the job.
      * Implement your job's logic here.
      *
-     * @param signal - Optional AbortSignal for timeout handling.
-     *                 Check `signal.aborted` for long-running operations.
+     * For timeout handling, use `this.signal` which is available after hydration.
+     *
      * @throws Any error thrown will trigger retry logic (if configured)
      *
      * @example
      * ```typescript
-     * async execute(signal?: AbortSignal) {
+     * async execute() {
      *   for (const item of this.payload.items) {
-     *     if (signal?.aborted) {
+     *     if (this.signal?.aborted) {
      *       throw new Error('Job timed out')
      *     }
      *     await processItem(item)
@@ -990,7 +1408,7 @@ declare abstract class Job<Payload = any> {
      * }
      * ```
      */
-    abstract execute(signal?: AbortSignal): Promise<void>;
+    abstract execute(): Promise<void>;
     /**
      * Called when the job has permanently failed (after all retries exhausted).
      *
@@ -1010,4 +1428,4 @@ declare abstract class Job<Payload = any> {
     failed?(error: Error): Promise<void>;
 }
 
-export { type Adapter as A, type BackoffStrategy as B, type Duration as D, type JobData as J, type Logger as L, type QueueManagerConfig as Q, type RetryConfig as R, type ScheduleConfig as S, type WorkerCycle as W, type AcquiredJob as a, type ScheduleData as b, type ScheduleListOptions as c, type JobFactory as d, Job as e, type JobClass as f, type ScheduleStatus as g, ScheduleBuilder as h, customBackoff as i, exponentialBackoff as j, fixedBackoff as k, linearBackoff as l, type DispatchResult as m, type JobOptions as n, type JobContext as o, type BackoffConfig as p, type QueueConfig as q, type WorkerConfig as r, type AdapterFactory as s, type ScheduleResult as t };
+export { type Adapter as A, type BackoffStrategy as B, type DispatchManyResult as D, type JobRetention as J, type Logger as L, type QueueManagerConfig as Q, type RetryConfig as R, type ScheduleConfig as S, type WorkerCycle as W, type AcquiredJob as a, type JobRecord as b, type JobData as c, type ScheduleData as d, type ScheduleListOptions as e, type JobFactory as f, type JobOptions as g, Job as h, type JobClass as i, type ScheduleStatus as j, ScheduleBuilder as k, JobBatchDispatcher as l, type AdapterFactory as m, customBackoff as n, linearBackoff as o, exponentialBackoff as p, fixedBackoff as q, type Duration as r, type JobStatus as s, type DispatchResult as t, type JobContext as u, type BackoffConfig as v, type QueueConfig as w, type WorkerConfig as x, type ScheduleResult as y };