@stacksjs/bun-queue 0.0.1

package/dist/cleanup.d.ts

@@ -0,0 +1,22 @@
+import type { Queue } from './queue';
+declare interface CleanupOptions {
+  maxCompletedJobs?: number
+  maxFailedJobs?: number
+  completedJobsLifetime?: number
+  failedJobsLifetime?: number
+  cleanupInterval?: number
+}
+declare class CleanupService {
+  readonly private queue: Queue;
+  readonly private logger: any;
+  readonly private options: CleanupOptions;
+  private timer: NodeJS.Timeout | null;
+  private running: any;
+  constructor(queue: Queue, options?: CleanupOptions);
+  start(): void;
+  stop(): void;
+  private cleanup(): Promise<void>;
+  private cleanupCompletedJobs(): Promise<void>;
+  private cleanupFailedJobs(): Promise<void>;
+}
+export { type CleanupOptions, CleanupService };

package/dist/commands/index.d.ts

@@ -0,0 +1,6 @@
+import { ScriptLoader, ScriptLoaderError } from './script-loader';
+import type { Command, ScriptMetadata } from './script-loader';
+export type { Command, ScriptMetadata };
+export { ScriptLoader };
+export { ScriptLoaderError };
+export { scriptLoader };

package/dist/commands/script-loader.d.ts

@@ -0,0 +1,44 @@
+import type { RedisClient } from '../types';
+export declare interface Command {
+  name: string
+  options: {
+    numberOfKeys: number
+    lua: string
+  }
+}
+/**
+ * Script metadata
+ */
+export declare interface ScriptMetadata {
+  name: string
+  numberOfKeys?: number
+  path: string
+  content: string
+  token: string
+  includes: ScriptMetadata[]
+}
+export declare class ScriptLoaderError extends Error {
+  readonly includes: string[];
+  readonly line: number;
+  readonly position: number;
+  constructor(message: string, path: string, stack?: string[], line?: number, position?: any);
+}
+/**
+ * Lua script loader with include support
+ */
+export declare class ScriptLoader {
+  private pathMapper: any;
+  private clientScripts: any;
+  private commandCache: any;
+  private rootPath: string;
+  constructor();
+  addPathMapping(name: string, mappedPath: string): void;
+  resolvePath(scriptName: string, stack?: string[]): string;
+  private resolveDependencies(file: ScriptMetadata, cache?: Map<string, ScriptMetadata>, isInclude?: any, stack?: string[]): Promise<void>;
+  parseScript(filename: string, content: string, cache?: Map<string, ScriptMetadata>): Promise<ScriptMetadata>;
+  interpolate(file: ScriptMetadata, processed?: Set<string>): string;
+  loadCommand(filename: string, cache?: Map<string, ScriptMetadata>): Promise<Command>;
+  loadScripts(dir?: string, cache?: Map<string, ScriptMetadata>): Promise<Command[]>;
+  load(client: RedisClient, pathname: string, cache?: Map<string, ScriptMetadata>): Promise<void>;
+  clearCache(): void;
+}

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { QueueConfig } from './types';
+export declare function getConfig(): Promise<QueueConfig>;
+// For backwards compatibility - synchronous access with default fallback
+export declare const config: QueueConfig;

package/dist/cron-scheduler.d.ts

@@ -0,0 +1,37 @@
+import type { JobOptions } from './types';
+import type { Queue } from './queue';
+/**
+ * CronSchedule represents the parsed cron expression
+ */
+declare interface CronSchedule {
+  minute: number[] | null
+  hour: number[] | null
+  dayOfMonth: number[] | null
+  month: number[] | null
+  dayOfWeek: number[] | null
+}
+/**
+ * Options for a cron job
+ */
+export declare interface CronJobOptions extends Omit<JobOptions, 'repeat'> {
+  cronExpression: string
+  timezone?: string
+  data: any
+  startDate?: Date | number
+  endDate?: Date | number
+  limit?: number
+}
+/**
+ * Class that handles scheduling jobs based on cron expressions
+ */
+export declare class CronScheduler {
+  readonly private queue: Queue;
+  readonly private logger: any;
+  private scheduledJobs: Map<string, NodeJS.Timeout>;
+  constructor(queue: Queue);
+  schedule(options: CronJobOptions): Promise<string>;
+  private parseCronExpression(expression: string): CronSchedule;
+  private parseField(field: string, min: number, max: number): number[] | null;
+  private getNextExecutionTime(schedule: CronSchedule, now: Date, timezone?: string): Date | null;
+  unschedule(jobId: string): Promise<boolean>;
+}

package/dist/dead-letter-queue.d.ts

@@ -0,0 +1,16 @@
+import { Job } from './job';
+import type { DeadLetterQueueOptions } from './types';
+import type { Queue } from './queue';
+export declare class DeadLetterQueue<T = any> {
+  private queue: Queue<T>;
+  private deadLetterQueueName: string;
+  private options: DeadLetterQueueOptions;
+  private logger: any;
+  constructor(queue: Queue<T>, options?: DeadLetterQueueOptions);
+  getQueueName(): string;
+  moveToDeadLetter(job: Job<T>, reason: string): Promise<string>;
+  getJobs(start?: any, end?: any): Promise<Job<T>[]>;
+  republishJob(jobId: string, options?: { resetRetries?: boolean }): Promise<Job<T> | null>;
+  removeJob(jobId: string): Promise<boolean>;
+  clear(): Promise<void>;
+}

package/dist/dispatch.d.ts

@@ -0,0 +1,84 @@
+import type { Job } from './job';
+import type { JobContract } from './job-base';
+export declare function dispatch<T extends JobContract>(job: T, ...args: any[]): Promise<Job<any>>;
+export declare function dispatchSync<T extends JobContract>(job: T, ...args: any[]): Promise<any>;
+export declare function dispatchIf<T extends JobContract>(condition: boolean, job: T, ...args: any[]): Promise<Job<any> | null>;
+export declare function dispatchUnless<T extends JobContract>(condition: boolean, job: T, ...args: any[]): Promise<Job<any> | null>;
+export declare function dispatchAfter<T extends JobContract>(delay: number, job: T, ...args: any[]): Promise<Job<any>>;
+export declare function chain<T extends JobContract>(job: T, ...args: any[]): DispatchableChain;
+export declare function batch(name?: string): JobBatch;
+export declare function dispatchChain(jobs: JobContract[]): Promise<Job<any>[]>;
+export declare function dispatchFunction(fn: QueuedClosure, ...args: any[]): Promise<Job<any>>;
+export declare interface DispatchChain {
+  onQueue: (queue: string) => this
+  onConnection: (connection: string) => this
+  delay: (ms: number) => this
+  after: (delay: number) => this
+  withTries: (attempts: number) => this
+  withTimeout: (timeout: number) => this
+  withBackoff: (backoff: number[]) => this
+  withTags: (...tags: string[]) => this
+  dispatch: () => Promise<Job<any>>
+  dispatchSync: () => Promise<any>
+}
+export declare interface Batch {
+  id: string
+  name?: string
+  jobs: JobContract[]
+  options?: BatchOptions
+  dispatch: () => Promise<BatchResult>
+}
+export declare interface BatchOptions {
+  allowFailures?: boolean
+  concurrency?: number
+  timeout?: number
+  onQueue?: string
+  onConnection?: string
+}
+export declare interface BatchResult {
+  id: string
+  jobs: Job<any>[]
+  completed: number
+  failed: number
+  total: number
+}
+export declare interface QueuedClosure {
+  (...args: any[]): Promise<any> | any
+}
+export declare class DispatchableChain implements DispatchChain {
+  private jobInstance: JobContract;
+  private args: any[];
+  private queueName?: string;
+  private connectionName?: string;
+  private delayMs?: number;
+  private attempts?: number;
+  private timeoutMs?: number;
+  private backoffArray?: number[];
+  private jobTags?: string[];
+  constructor(job: JobContract, args: any[]);
+  onQueue(queue: string): this;
+  onConnection(connection: string): this;
+  delay(ms: number): this;
+  after(delay: number): this;
+  withTries(attempts: number): this;
+  withTimeout(timeout: number): this;
+  withBackoff(backoff: number[]): this;
+  withTags(tags: string[]): this;
+  dispatch(): Promise<Job<any>>;
+  dispatchSync(): Promise<any>;
+}
+export declare class JobBatch implements Batch {
+  id: string;
+  name?: string;
+  jobs: JobContract[];
+  options?: BatchOptions;
+  constructor(name?: string);
+  add(job: JobContract): this;
+  addMany(jobs: JobContract[]): this;
+  allowFailures(allow?: any): this;
+  withConcurrency(concurrency: number): this;
+  withTimeout(timeout: number): this;
+  onQueue(queue: string): this;
+  onConnection(connection: string): this;
+  dispatch(): Promise<BatchResult>;
+}

package/dist/distributed-lock.d.ts

@@ -0,0 +1,25 @@
+import type { RedisClient } from 'bun';
+export declare interface LockOptions {
+  duration?: number
+  autoExtend?: boolean
+  extendInterval?: number
+  retries?: number
+  retryDelay?: number
+}
+/**
+ * Distributed lock implementation using Redis
+ */
+export declare class DistributedLock {
+  private redisClient: RedisClient;
+  private prefix: string;
+  readonly private logger: any;
+  constructor(redisClient: RedisClient, prefix?: any);
+  acquire(resource: string, options?: LockOptions): Promise<string | null>;
+  release(resource: string, token: string): Promise<boolean>;
+  isLocked(resource: string): Promise<boolean>;
+  extend(resource: string, token: string, duration: number): Promise<boolean>;
+  private setupAutoExtend(resource: string, token: string, duration: number, interval: number): void;
+  private getLockKey(resource: string): string;
+  static private autoExtendTimers: any;
+  withLock<T>(resource: string, fn: () => Promise<T>, options?: LockOptions): Promise<T>;
+}

package/dist/events.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from 'node:events';
+declare class JobEvents extends EventEmitter {
+  readonly private logger: any;
+  readonly private queueName: string;
+  constructor(queueName: string);
+  emitJobAdded(jobId: string, name: string): void;
+  emitJobRemoved(jobId: string): void;
+  emitJobCompleted(jobId: string, result: any): void;
+  emitJobFailed(jobId: string, error: Error): void;
+  emitJobProgress(jobId: string, progress: number): void;
+  emitJobActive(jobId: string): void;
+  emitJobStalled(jobId: string): void;
+  emitJobDelayed(jobId: string, delay: number): void;
+  emitReady(): void;
+  emitError(error: Error): void;
+  emitBatchAdded(batchId: string, jobIds: string[]): void;
+  emitBatchCompleted(batchId: string, results: any[]): void;
+  emitBatchFailed(batchId: string, errors: Error[]): void;
+  emitBatchProgress(batchId: string, progress: number): void;
+  emitGroupCreated(groupName: string): void;
+  emitGroupRemoved(groupName: string): void;
+  emitObservableStarted(observableId: string): void;
+  emitObservableStopped(observableId: string): void;
+  emitJobMovedToDeadLetter(jobId: string, deadLetterQueueName: string, reason: string): void;
+  emitJobRepublishedFromDeadLetter(jobId: string, originalQueueName: string): void;
+}
+export { JobEvents };

package/dist/failed/failed-job-manager.d.ts

@@ -0,0 +1,17 @@
+import type { FailedJob, FailedJobProvider } from './failed-job-provider';
+export declare class FailedJobManager {
+  private provider: FailedJobProvider;
+  private logger: any;
+  constructor(driver?: 'redis' | 'database', options?: any);
+  log(connection: string, queue: string, payload: string, exception: Error): Promise<string>;
+  all(): Promise<FailedJob[]>;
+  find(id: string): Promise<FailedJob | null>;
+  retry(id: string): Promise<boolean>;
+  forget(id: string): Promise<boolean>;
+  flush(hours?: number): Promise<void>;
+  prune(hours?: number): Promise<number>;
+  count(): Promise<number>;
+  retryAll(): Promise<number>;
+  getFailedJobsByQueue(queue: string): Promise<FailedJob[]>;
+  getFailedJobsByConnection(connection: string): Promise<FailedJob[]>;
+}

package/dist/failed/failed-job-provider.d.ts

@@ -0,0 +1,37 @@
+/* eslint-disable no-console */
+export declare interface FailedJob {
+  id: string
+  connection: string
+  queue: string
+  payload: string
+  exception: string
+  failed_at: Date
+}
+export declare interface FailedJobProvider {
+  log: (connection: string, queue: string, payload: string, exception: Error) => Promise<string>
+  all: () => Promise<FailedJob[]>
+  find: (id: string) => Promise<FailedJob | null>
+  forget: (id: string) => Promise<boolean>
+  flush: (hours?: number) => Promise<void>
+  prune: (hours: number) => Promise<number>
+}
+export declare class RedisFailedJobProvider implements FailedJobProvider {
+  private prefix: string;
+  constructor(prefix?: string);
+  log(_connection: string, _queue: string, _payload: string, _exception: Error): Promise<string>;
+  all(): Promise<FailedJob[]>;
+  find(id: string): Promise<FailedJob | null>;
+  forget(id: string): Promise<boolean>;
+  flush(hours?: number): Promise<void>;
+  prune(hours: number): Promise<number>;
+}
+export declare class DatabaseFailedJobProvider implements FailedJobProvider {
+  private table: string;
+  constructor(table?: string);
+  log(_connection: string, _queue: string, _payload: string, _exception: Error): Promise<string>;
+  all(): Promise<FailedJob[]>;
+  find(id: string): Promise<FailedJob | null>;
+  forget(id: string): Promise<boolean>;
+  flush(hours?: number): Promise<void>;
+  prune(hours: number): Promise<number>;
+}

package/dist/failed/index.d.ts

@@ -0,0 +1,7 @@
+export { FailedJobManager } from './failed-job-manager';
+export {
+  DatabaseFailedJobProvider,
+  type FailedJob,
+  type FailedJobProvider,
+  RedisFailedJobProvider,
+} from './failed-job-provider';

package/dist/group.d.ts

@@ -0,0 +1,22 @@
+import type { RedisClient } from 'bun';
+import type { Group, GroupOptions, Job } from './types';
+import type { Queue } from './queue';
+import type { Worker } from './worker';
+export declare class QueueGroup<T = any> {
+  readonly private redisClient: RedisClient;
+  readonly private prefix: string;
+  readonly private queues: Map<string, Queue<T>>;
+  private workers: Map<string, Worker<T>>;
+  readonly private logger: any;
+  constructor(prefix: string, redisClient: RedisClient);
+  addQueue(queue: Queue<T>, options?: GroupOptions): Promise<void>;
+  removeQueue(queueName: string, groupName?: string): Promise<void>;
+  getAllGroups(): Promise<Group[]>;
+  getGroup(groupName: string): Promise<Group | null>;
+  processGroup<R = any>(groupName: string, handler: (job: Job<T>) => Promise<R>): Promise<void>;
+  addJobToGroup(groupName: string, data: T): Promise<Job<T>[]>;
+  closeGroup(groupName: string): Promise<void>;
+  closeAll(): Promise<void>;
+  private getGroupKey(groupName: string): string;
+  private getGroupMetaKey(groupName: string): string;
+}

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+export type { QueueConnectionConfig, QueueManagerConfig } from './types';
+export { BatchProcessor } from './batch';
+export { config } from './config';
+export { DeadLetterQueue } from './dead-letter-queue';
+export {
+  batch,
+  type Batch,
+  type BatchOptions,
+  type BatchResult,
+  chain,
+  dispatch,
+  DispatchableChain,
+  dispatchAfter,
+  dispatchChain,
+  type DispatchChain,
+  dispatchFunction,
+  dispatchIf,
+  dispatchSync,
+  dispatchUnless,
+  JobBatch,
+  type QueuedClosure,
+} from './dispatch';
+export { DistributedLock } from './distributed-lock';
+export { JobEvents } from './events';
+export * from './failed';
+export { QueueGroup } from './group';
+export { Job } from './job';
+export {
+  type Dispatchable,
+  type InteractsWithQueue,
+  JobBase,
+  type JobContract,
+  type JobMiddleware,
+  type ShouldQueue,
+} from './job-base';
+export {
+  createJobProcessor,
+  getGlobalJobProcessor,
+  JobProcessor,
+  type JobProcessorOptions,
+  setGlobalJobProcessor,
+} from './job-processor';
+export * from './jobs';
+export { LeaderElection } from './leader-election';
+export { createLogger } from './logger';
+export {
+  FailureMiddleware,
+  JobMiddlewareStack,
+  middleware,
+  type MiddlewareStack,
+  RateLimitMiddleware,
+  SkipIfMiddleware,
+  ThrottleMiddleware,
+  UniqueJobMiddleware,
+  WithoutOverlappingMiddleware,
+} from './middleware';
+export { QueueObservable } from './observable';
+export { PriorityQueue } from './priority-queue';
+export { Queue } from './queue';
+export {
+  closeQueueManager,
+  getQueueManager as getManager,
+  getQueueManager,
+  type QueueConnection,
+  QueueManager,
+  setQueueManager,
+} from './queue-manager';
+export { RateLimiter } from './rate-limiter';
+export * from './types';
+export { WorkCoordinator } from './work-coordinator';
+export { Worker } from './worker';
+export * from './workers';

package/dist/job-base.d.ts

@@ -0,0 +1,95 @@
+import type { Job } from './job';
+export declare function getQueueManager(): Promise<QueueManager>;
+export declare interface ShouldQueue {
+  handle: (...args: any[]) => Promise<any> | any
+}
+export declare interface ShouldBeUnique {
+  uniqueId: () => string
+}
+export declare interface ShouldBatch {
+  batchId?: string
+}
+export declare interface Queueable {
+  onQueue: (queue: string) => this
+  onConnection: (connection: string) => this
+  withDelay: (delay: number) => this
+  allOnQueue: (queue: string) => this
+  allOnConnection: (connection: string) => this
+}
+export declare interface JobContract extends ShouldQueue {
+  queue?: string
+  connection?: string
+  delay?: number
+  tries?: number
+  timeout?: number
+  backoff?: number[]
+  maxExceptions?: number
+  deleteWhenMissingModels?: boolean
+  middleware?: JobMiddleware[]
+  uniqueId?: () => string | undefined
+  tags?: string[]
+  failOnTimeout?: boolean
+  job?: Job<any>
+  dispatch?: (...args: any[]) => Promise<Job<any>>
+  dispatchSync?: (...args: any[]) => Promise<any>
+  dispatchIf?: (condition: boolean, ...args: any[]) => Promise<Job<any> | null>
+  dispatchUnless?: (condition: boolean, ...args: any[]) => Promise<Job<any> | null>
+  dispatchAfter?: (delay: number, ...args: any[]) => Promise<Job<any>>
+}
+export declare interface JobMiddleware {
+  handle: (job: JobContract, next: () => Promise<void>) => Promise<void>
+}
+export declare interface Dispatchable {
+  dispatch: (...args: any[]) => Promise<Job<any>>
+  dispatchSync: (...args: any[]) => Promise<any>
+  dispatchIf: (condition: boolean, ...args: any[]) => Promise<Job<any> | null>
+  dispatchUnless: (condition: boolean, ...args: any[]) => Promise<Job<any> | null>
+  dispatchAfter: (delay: number, ...args: any[]) => Promise<Job<any>>
+}
+export declare interface InteractsWithQueue {
+  job?: Job<any>
+  fail: (exception?: Error) => Promise<void>
+  release: (delay?: number) => Promise<void>
+  delete: () => Promise<void>
+}
+export declare interface QueueManager {
+  connection: (name?: string) => QueueConnection
+  queue: (name?: string) => any
+}
+export declare interface QueueConnection {
+  queue: (name?: string) => any
+}
+export declare abstract class JobBase implements JobContract, Queueable, Dispatchable, InteractsWithQueue {
+  queue?: string;
+  connection?: string;
+  delay?: number;
+  tries?: number;
+  timeout?: number;
+  backoff?: number[];
+  maxExceptions?: number;
+  deleteWhenMissingModels?: boolean;
+  middleware?: JobMiddleware[];
+  tags?: string[];
+  failOnTimeout?: boolean;
+  job?: Job<any>;
+  abstract handle(args: any[]): Promise<any> | any;
+  dispatch(args: any[]): Promise<Job<any>>;
+  dispatchSync(args: any[]): Promise<any>;
+  dispatchIf(condition: boolean, args: any[]): Promise<Job<any> | null>;
+  dispatchUnless(condition: boolean, args: any[]): Promise<Job<any> | null>;
+  dispatchAfter(delay: number, args: any[]): Promise<Job<any>>;
+  onQueue(queue: string): this;
+  onConnection(connection: string): this;
+  withDelay(delay: number): this;
+  allOnQueue(queue: string): this;
+  allOnConnection(connection: string): this;
+  withTries(tries: number): this;
+  withTimeout(timeout: number): this;
+  withBackoff(backoff: number[]): this;
+  withMiddleware(middleware: JobMiddleware[]): this;
+  withTags(tags: string[]): this;
+  fail(exception?: Error): Promise<void>;
+  release(delay?: number): Promise<void>;
+  delete(): Promise<void>;
+  uniqueId(): string | undefined;
+}

package/dist/job-processor.d.ts

@@ -0,0 +1,21 @@
+import type { Job } from './job';
+import type { JobContract } from './job-base';
+// Utility function to create a processor for job classes
+export declare function createJobProcessor(options?: JobProcessorOptions): JobProcessor;
+export declare function getGlobalJobProcessor(options?: JobProcessorOptions): JobProcessor;
+export declare function setGlobalJobProcessor(processor: JobProcessor): void;
+export declare interface JobProcessorOptions {
+  logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent'
+}
+export declare class JobProcessor {
+  private logger: any;
+  constructor(options?: JobProcessorOptions);
+  process(job: Job<any>): Promise<any>;
+  private isJobClass(data: any): boolean;
+  private processJobClass(job: Job<any>, jobData: any): Promise<any>;
+  private processWithMiddleware(jobInstance: JobContract, args: any[]): Promise<any>;
+  private executeJob(jobInstance: JobContract, args: any[]): Promise<any>;
+  private shouldSkipJob(_jobInstance: JobContract): boolean;
+  private processDataJob(job: Job<any>, data: any): Promise<any>;
+  processWithTimeout(job: Job<any>, timeout?: number): Promise<any>;
+}

package/dist/job.d.ts

@@ -0,0 +1,27 @@
+import type { JobOptions } from './types';
+import type { Queue } from './queue';
+export declare class Job<T = any> {
+  queue: Queue<T>;
+  id: string;
+  data: T;
+  name: string;
+  opts: JobOptions;
+  progress: number;
+  delay: number;
+  timestamp: number;
+  attemptsMade: number;
+  stacktrace: string[];
+  returnvalue: any;
+  finishedOn?: number;
+  processedOn?: number;
+  failedReason?: string;
+  dependencies?: string[];
+  constructor(queue: Queue<T>, jobId: string);
+  refresh(): Promise<void>;
+  updateProgress(progress: number): Promise<void>;
+  moveToCompleted(returnvalue?: any): Promise<void>;
+  moveToFailed(err: Error, failedReason?: string): Promise<void>;
+  retry(): Promise<void>;
+  remove(): Promise<void>;
+  private processDependents(): Promise<void>;
+}

package/dist/jobs/bus.d.ts

@@ -0,0 +1,60 @@
+export declare interface BatchableJob extends Job {
+  batchId?: string
+  allowFailures?: boolean
+}
+export declare interface Batch {
+  id: string
+  name?: string
+  totalJobs: number
+  pendingJobs: number
+  processedJobs: number
+  failedJobs: number
+  createdAt: Date
+  finishedAt?: Date
+  cancelledAt?: Date
+}
+export declare interface PendingBatch {
+  add: (jobs: Job | Job[]) => this
+  before: (callback: (batch: Batch) => void) => this
+  progress: (callback: (batch: Batch) => void) => this
+  then: (callback: (batch: Batch) => void) => this
+  catch: (callback: (batch: Batch, error: Error) => void) => this
+  finally: (callback: (batch: Batch) => void) => this
+  allowFailures: (failures?: number) => this
+  onQueue: (queue: string) => this
+  onConnection: (connection: string) => this
+  dispatch: () => Promise<Batch>
+}
+export declare class JobBatch implements PendingBatch {
+  private jobs: Job[];
+  private beforeCallbacks: Array<(batch: Batch) => void>;
+  private progressCallbacks: Array<(batch: Batch) => void>;
+  private thenCallbacks: Array<(batch: Batch) => void>;
+  private catchCallbacks: Array<(batch: Batch, error: Error) => void>;
+  private finallyCallbacks: Array<(batch: Batch) => void>;
+  private allowedFailures?: number;
+  private queueName?: string;
+  private connectionName?: string;
+  private batchName?: string;
+  constructor(batchName?: string);
+  add(jobs: Job | Job[]): this;
+  before(callback: (batch: Batch) => void): this;
+  progress(callback: (batch: Batch) => void): this;
+  then(callback: (batch: Batch) => void): this;
+  catch(callback: (batch: Batch, error: Error) => void): this;
+  finally(callback: (batch: Batch) => void): this;
+  allowFailures(failures?: number): this;
+  onQueue(queue: string): this;
+  onConnection(connection: string): this;
+  dispatch(): Promise<Batch>;
+  private monitorJob(queueJob: QueueJob<any>, batch: Batch, _jobIndex: number): Promise<void>;
+}
+export declare class Bus {
+  static batch(name?: string): PendingBatch;
+  static dispatch(job: Job, args: any[]): Promise<QueueJob<any>>;
+  static dispatchSync(job: Job, args: any[]): Promise<any>;
+  static dispatchIf(condition: boolean, job: Job, args: any[]): Promise<QueueJob<any> | null>;
+  static dispatchUnless(condition: boolean, job: Job, args: any[]): Promise<QueueJob<any> | null>;
+  static dispatchAfter(delay: number, job: Job, args: any[]): Promise<QueueJob<any>>;
+  static chain(jobs: Job[]): Promise<QueueJob<any>[]>;
+}

package/dist/jobs/index.d.ts

@@ -0,0 +1,14 @@
+export { dispatch, dispatchAfter, dispatchIf, dispatchSync, dispatchUnless } from '../dispatch';
+export {
+  type Dispatchable,
+  type InteractsWithQueue,
+  JobBase as Job,
+  type JobContract,
+  type JobMiddleware,
+  type Queueable,
+  type ShouldBatch,
+  type ShouldBeUnique,
+  type ShouldQueue,
+} from '../job-base';
+export { Bus } from './bus';
+export * from './middleware';