bunqueue-client 0.1.9 → 0.2.0

package/dist/types/src/client/flowTypes.d.ts

@@ -0,0 +1,77 @@
+/**
+ * FlowProducer Types
+ * Type definitions for job flows and pipelines
+ */
+import type { Job, JobOptions, ConnectionOptions } from "./types.js";
+/** FlowProducer options */
+export interface FlowProducerOptions {
+    /** Use embedded mode (no server) */
+    embedded?: boolean;
+    /** TCP connection options */
+    connection?: ConnectionOptions;
+}
+/** Step definition in a flow (legacy bunqueue API) */
+export interface FlowStep<T = unknown> {
+    /** Job name */
+    name: string;
+    /** Queue name */
+    queueName: string;
+    /** Job data */
+    data: T;
+    /** Job options */
+    opts?: JobOptions;
+    /** Child steps (for tree structures) */
+    children?: FlowStep<T>[];
+}
+/** Result of adding a flow (legacy bunqueue API) */
+export interface FlowResult {
+    /** Job IDs in order */
+    jobIds: string[];
+}
+/**
+ * FlowJob - BullMQ v5 compatible flow job definition.
+ * Children are processed BEFORE the parent.
+ */
+export interface FlowJob<T = unknown> {
+    /** Job name */
+    name: string;
+    /** Queue name */
+    queueName: string;
+    /** Job data */
+    data?: T;
+    /** Job options */
+    opts?: JobOptions;
+    /** Child jobs (processed BEFORE this job) */
+    children?: FlowJob<T>[];
+}
+/**
+ * JobNode - BullMQ v5 compatible result from adding a flow.
+ * Contains the job and its children nodes.
+ */
+export interface JobNode<T = unknown> {
+    /** The job instance */
+    job: Job<T>;
+    /** Child nodes (if any) */
+    children?: JobNode<T>[];
+}
+/**
+ * Options for getFlow method (BullMQ v5 compatible).
+ */
+export interface GetFlowOpts {
+    /** Job ID to get the flow for */
+    id: string;
+    /** Queue name where the job is located */
+    queueName: string;
+    /** Maximum depth to traverse (default: unlimited) */
+    depth?: number;
+    /** Maximum number of children to fetch per level (default: unlimited) */
+    maxChildren?: number;
+}
+/**
+ * FlowOpts - BullMQ v5 compatible options for flow creation.
+ * Allows setting default job options per queue when adding flows.
+ */
+export interface FlowOpts {
+    /** Default job options per queue name. Set `jobId` on the individual flow node. */
+    queuesOptions?: Record<string, Omit<Partial<JobOptions>, 'jobId'>>;
+}

package/dist/types/src/client/forwarder.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Forwarder — store-and-forward from a local (edge) queue to a remote
+ * bunqueue server.
+ *
+ * The edge pattern: jobs buffer in the local queue (typically embedded
+ * SQLite on a gateway); the Forwarder drains them to a central server over
+ * TCP/TLS. A remote failure makes the local job fail → local retry/backoff →
+ * local DLQ. With a persistent local `dataPath`, queued work survives uplink
+ * outages and process restarts; memory-only sources provide no such guarantee.
+ *
+ * Idempotency: every forwarded job carries the deterministic remote jobId
+ * `fwd:<localQueueKey>:<localJobId>`. The server dedupes custom jobIds while
+ * their ownership is retained; after bounded retention or removal, downstream
+ * effects must still tolerate at-least-once delivery.
+ */
+import { EventEmitter } from 'events';
+import type { ConnectionOptions, QueueOptions } from "./types.js";
+/** Options for queue.forward() */
+export interface ForwardOptions {
+    /** Remote server connection (host/port/tls/token...) */
+    to: ConnectionOptions;
+    /** Remote queue name (default: same as the source queue) */
+    queue?: string;
+    /** Parallel forwards (default: 4) */
+    concurrency?: number;
+    /** Push with durable: true (bypasses SQLite buffering; PostgreSQL is already transactional). */
+    durable?: boolean;
+}
+/** Source queue identity + config, provided by Queue.forward() */
+export interface ForwardSource {
+    /** Logical source queue name */
+    name: string;
+    /** Source queue key (prefixKey + name) — used in the deterministic jobId */
+    queueKey: string;
+    prefixKey?: string;
+    embedded: boolean;
+    dataPath?: string;
+    connection?: ConnectionOptions;
+}
+/** Minimal remote-queue surface the Forwarder needs (avoids a Queue import cycle) */
+interface RemoteQueueLike {
+    add(name: string, data: unknown, opts?: {
+        jobId?: string;
+        priority?: number;
+        durable?: boolean;
+    }): Promise<unknown>;
+    close(): Promise<void> | void;
+}
+/** Constructor for the remote queue, injected by Queue.forward() */
+export type RemoteQueueCtor = new (name: string, opts: QueueOptions) => RemoteQueueLike;
+/** Info emitted with each 'forwarded' event */
+export interface ForwardedInfo {
+    /** Local job id */
+    id: string;
+    /** Deterministic remote job id (fwd:<queueKey>:<id>) */
+    remoteId: string;
+    /** Job name */
+    name: string;
+}
+/**
+ * Drains a local queue into a remote bunqueue server.
+ * Create via `queue.forward(options)`; stop with `close()`.
+ */
+export declare class Forwarder extends EventEmitter {
+    on(event: 'forwarded', listener: (info: ForwardedInfo) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    private readonly remote;
+    private readonly worker;
+    private closed;
+    constructor(source: ForwardSource, options: ForwardOptions, RemoteQueue: RemoteQueueCtor);
+    /** Stop forwarding and release connections. Safe to call more than once. */
+    close(): Promise<void>;
+}
+export {};

package/dist/types/src/client/groupId.d.ts

@@ -0,0 +1 @@
+export { normalizeGroupId } from "../domain/types/group.js";

package/dist/types/src/client/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * bunqueue Client API
+ *
+ * @example
+ * ```typescript
+ * import { Queue, Worker } from 'bunqueue/client';
+ *
+ * const queue = new Queue('emails');
+ * await queue.add('send', { to: 'user@test.com' });
+ *
+ * const worker = new Worker('emails', async (job) => {
+ *   await job.updateProgress(50);
+ *   await job.log('Processing...');
+ *   return { success: true };
+ * });
+ *
+ * worker.on('completed', (job, result) => console.log(result));
+ * worker.on('progress', (job, progress) => console.log(progress));
+ * ```
+ */
+import "../require-bun.js";
+export { defineConfig } from "../config/index.js";
+export type { BunqueueConfig } from "../config/index.js";
+export { Queue } from "./queue.js";
+export { Worker } from "./worker.js";
+export type { ManualJob } from "./worker/types/index.js";
+export { Bunqueue } from "./bunqueue.js";
+export type { BunqueueOptions, BunqueueMiddleware, RetryStrategy, RetryConfig, CircuitBreakerConfig, TriggerRule, PriorityAgingConfig, BatchProcessor, BatchConfig, JobTtlConfig, BunqueueDeduplicationConfig, BunqueueDebounceConfig, BunqueueDlqConfig, } from "./bunqueue.js";
+export { SandboxedWorker } from "./sandboxedWorker.js";
+export { Forwarder } from "./forwarder.js";
+export type { ForwardOptions, ForwardedInfo } from "./forwarder.js";
+export { QueueEvents } from "./events.js";
+export { QueuePro, WorkerPro, QueueEventsPro } from "./pro.js";
+export type { JobPro } from "./pro.js";
+export type { ActiveEvent, CompletedEvent, DelayedEvent, DrainedEvent, DuplicatedEvent, FailedEvent, ProgressEvent, QueueEventsOptions, RemovedEvent, RetriedEvent, StalledEvent, WaitingChildrenEvent, WaitingEvent, } from "./types/events.js";
+export { QueueGroup } from "./queueGroup.js";
+export { FlowProducer } from "./flow.js";
+export { UnrecoverableError, DelayedError, RateLimitError } from "./errors.js";
+export { shutdownManager } from "./manager.js";
+export { closeSharedTcpClient } from "./tcpClient.js";
+export type { ConnectionHealth } from "./tcpClient.js";
+export { TcpConnectionPool, getSharedPool, closeAllSharedPools } from "./tcpPool.js";
+export type { Job, JobOptions, GroupJobOptions, GroupWorkerOptions, BatchWorkerOptions, JobJson, JobJsonRaw, QueueOptions, WorkerOptions, Processor, ProcessorContext, ObservableLike, FlowJobData, StallConfig, DlqConfig, DlqEntry, DlqStats, DlqFilter, FailureReason, ConnectionOptions, ParentOpts, RateLimiterOptions, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount, QueueMetrics, QueueMetricsMeta, QueueMetricType, } from "./types.js";
+export type { FlowStep, FlowResult, FlowJob, JobNode, FlowProducerOptions, FlowOpts } from "./flow.js";
+export type { RepeatOpts, JobTemplate, SchedulerInfo } from "./queue/scheduler.js";
+export type { SandboxedWorkerOptions } from "./sandboxedWorker.js";

package/dist/types/src/client/jobConversion.d.ts

@@ -0,0 +1,10 @@
+import type { DlqEntry as InternalDlqEntry } from "../domain/types/dlq.js";
+import type { Job, DlqEntry } from "./types.js";
+import type { CreatePublicJobOptions, PublicJobMethodContext, ToPublicJobOptions } from "./jobConversionTypes.js";
+export type { CreatePublicJobOptions, PublicJobMethodContext, ToPublicJobOptions, } from "./jobConversionTypes.js";
+/** Convert internal job to public job (with methods) */
+export declare function createPublicJob<T>(opts: CreatePublicJobOptions): Job<T>;
+/** Simple public job without methods (for Queue.getJob) */
+export declare function toPublicJob<T>(opts: ToPublicJobOptions): Job<T>;
+/** Convert internal DLQ entry to public DLQ entry */
+export declare function toDlqEntry<T>(entry: InternalDlqEntry, methods: PublicJobMethodContext): DlqEntry<T>;

package/dist/types/src/client/jobConversionHelpers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Job Conversion Helpers
+ * Builder functions for constructing public job properties
+ */
+import type { Job as InternalJob } from "../domain/types/job.js";
+import type { Job, JobStateType, JobOptions, GetDependenciesOpts, JobDependenciesCount } from "./types.js";
+interface JobPropertyOptions {
+    stacktrace?: string[] | null;
+    token?: string;
+    processedBy?: string;
+    returnvalue?: unknown;
+    failedReason?: string;
+}
+/** Build common job properties from internal job */
+export declare function buildJobProperties<T>(job: InternalJob, name: string, options?: JobPropertyOptions): Pick<Job<T>, 'id' | 'name' | 'data' | 'queueName' | 'attemptsMade' | 'timestamp' | 'progress' | 'parent' | 'delay' | 'processedOn' | 'finishedOn' | 'stacktrace' | 'returnvalue' | 'failedReason' | 'stalledCounter' | 'priority' | 'parentKey' | 'opts' | 'token' | 'processedBy' | 'deduplicationId' | 'repeatJobKey' | 'attemptsStarted'>;
+/** Build state check methods */
+export declare function buildStateCheckMethods(id: string, getState?: (id: string) => Promise<JobStateType>, _getDependenciesCount?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>): Pick<Job, 'isWaiting' | 'isActive' | 'isDelayed' | 'isCompleted' | 'isFailed' | 'isWaitingChildren'>;
+interface JobSerializationOptions {
+    id: string;
+    name: string;
+    jobOpts: JobOptions;
+    stacktrace?: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
+}
+/** Build serialization methods */
+export declare function buildSerializationMethods<T>(job: InternalJob, options: JobSerializationOptions): Pick<Job<T>, 'toJSON' | 'asJSON'>;
+export {};

package/dist/types/src/client/jobConversionTypes.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Job Conversion Types
+ * Interfaces for job conversion options
+ */
+import type { Job as InternalJob } from "../domain/types/job.js";
+import type { JobStateType, ChangePriorityOpts, GetDependenciesOpts, JobDependencies, JobDependenciesCount } from "./types.js";
+/** Options for creating a public job */
+export interface CreatePublicJobOptions {
+    job: InternalJob;
+    name: string;
+    updateProgress: (id: string, progress: number, message?: string) => Promise<void>;
+    log: (id: string, message: string) => Promise<void>;
+    getState?: (id: string) => Promise<JobStateType>;
+    remove?: (id: string) => Promise<void>;
+    retry?: (id: string) => Promise<void>;
+    getChildrenValues?: (id: string) => Promise<Record<string, unknown>>;
+    updateData?: (id: string, data: unknown) => Promise<void>;
+    promote?: (id: string) => Promise<void>;
+    changeDelay?: (id: string, delay: number) => Promise<void>;
+    changePriority?: (id: string, opts: ChangePriorityOpts) => Promise<void>;
+    extendLock?: (id: string, token: string, duration: number) => Promise<number>;
+    clearLogs?: (id: string, keepLogs?: number) => Promise<void>;
+    getDependencies?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
+    getDependenciesCount?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
+    moveToCompleted?: (id: string, returnValue: unknown, token?: string) => Promise<unknown>;
+    moveToFailed?: (id: string, error: Error, token?: string) => Promise<void>;
+    moveToWait?: (id: string, token?: string) => Promise<boolean>;
+    moveToDelayed?: (id: string, timestamp: number, token?: string) => Promise<void>;
+    moveToWaitingChildren?: (id: string, token?: string, opts?: {
+        child?: {
+            id: string;
+            queue: string;
+        };
+    }) => Promise<boolean>;
+    waitUntilFinished?: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
+    discard?: (id: string) => void;
+    getFailedChildrenValues?: (id: string) => Promise<Record<string, string>>;
+    getIgnoredChildrenFailures?: (id: string) => Promise<Record<string, string>>;
+    removeChildDependency?: (id: string) => Promise<boolean>;
+    removeDeduplicationKey?: (id: string) => Promise<boolean>;
+    removeUnprocessedChildren?: (id: string) => Promise<void>;
+    token?: string;
+    processedBy?: string;
+    stacktrace?: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
+}
+/** Complete operation set required when exposing a live job from another view. */
+export type PublicJobMethodContext = Required<Omit<CreatePublicJobOptions, 'job' | 'name' | 'token' | 'processedBy' | 'stacktrace' | 'returnvalue' | 'failedReason'>>;
+/** Options for creating a simple public job */
+export interface ToPublicJobOptions {
+    job: InternalJob;
+    name: string;
+    updateProgress?: (id: string, progress: number, message?: string) => Promise<void>;
+    log?: (id: string, message: string) => Promise<void>;
+    getState?: (id: string) => Promise<JobStateType>;
+    remove?: (id: string) => Promise<void>;
+    retry?: (id: string) => Promise<void>;
+    getChildrenValues?: (id: string) => Promise<Record<string, unknown>>;
+    updateData?: (id: string, data: unknown) => Promise<void>;
+    promote?: (id: string) => Promise<void>;
+    changeDelay?: (id: string, delay: number) => Promise<void>;
+    changePriority?: (id: string, opts: ChangePriorityOpts) => Promise<void>;
+    extendLock?: (id: string, token: string, duration: number) => Promise<number>;
+    clearLogs?: (id: string, keepLogs?: number) => Promise<void>;
+    getDependencies?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
+    getDependenciesCount?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
+    moveToCompleted?: (id: string, returnValue: unknown, token?: string) => Promise<unknown>;
+    moveToFailed?: (id: string, error: Error, token?: string) => Promise<void>;
+    moveToWait?: (id: string, token?: string) => Promise<boolean>;
+    moveToDelayed?: (id: string, timestamp: number, token?: string) => Promise<void>;
+    moveToWaitingChildren?: (id: string, token?: string, opts?: {
+        child?: {
+            id: string;
+            queue: string;
+        };
+    }) => Promise<boolean>;
+    waitUntilFinished?: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
+    discard?: (id: string) => void;
+    getFailedChildrenValues?: (id: string) => Promise<Record<string, string>>;
+    getIgnoredChildrenFailures?: (id: string) => Promise<Record<string, string>>;
+    removeChildDependency?: (id: string) => Promise<boolean>;
+    removeDeduplicationKey?: (id: string) => Promise<boolean>;
+    removeUnprocessedChildren?: (id: string) => Promise<void>;
+    stacktrace?: string[] | null;
+    returnvalue?: unknown;
+    failedReason?: string;
+}

package/dist/types/src/client/jobDeduplication.d.ts

@@ -0,0 +1,6 @@
+interface CommandTransport {
+    send(command: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+/** Remove only the deduplication key currently owned by the given job. */
+export declare function removeJobDeduplicationKey(id: string, embedded: boolean, transport: CommandTransport | null | undefined): Promise<boolean>;
+export {};

package/dist/types/src/client/jobHelpers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Job Helper Functions
+ * Internal utilities for extracting and building job data
+ */
+import { type Job as InternalJob } from "../domain/types/job.js";
+import type { RepeatOptions, JobOptions } from "./types.js";
+/** Decode a bare pre-name-field payload. Modern conversions use normalizeJobPayload(job). */
+export declare function extractUserData(jobData: unknown): unknown;
+/** Resolve legacy names while preserving documented engine-owned flow metadata. */
+export declare function resolvePublicJobPayload(job: InternalJob): {
+    name: string;
+    data: unknown;
+};
+/** Extract parent info from job data if present */
+export declare function extractParent(jobData: unknown): {
+    id: string;
+    queueQualifiedName: string;
+} | undefined;
+/** Build repeat options from internal job repeat config */
+export declare function buildRepeatOpts(repeat: InternalJob['repeat']): RepeatOptions | undefined;
+/** Build parent reference from job data */
+export declare function buildParentOpts(job: InternalJob): {
+    id: string;
+    queue: string;
+} | undefined;
+/** Build JobOptions from internal job */
+export declare function buildJobOpts(job: InternalJob): JobOptions;
+/** Build parent key from job */
+export declare function buildParentKey(job: InternalJob): string | undefined;
+/** Build repeat job key from job */
+export declare function buildRepeatJobKey(job: InternalJob): string | undefined;

package/dist/types/src/client/legacyConnectionOptions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Throw when TCP-mode options carry flat connection keys.
+ * @param owner - Class name shown in the error message.
+ * @param options - Caller-supplied options object.
+ * @param embedded - True when the caller selected embedded mode, where no
+ *   connection is made and the keys are irrelevant.
+ */
+export declare function rejectLegacyConnectionOptions(owner: string, options: object | undefined, embedded: boolean): void;

package/dist/types/src/client/manager.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared QueueManager singleton
+ */
+import { QueueManager } from "../application/queueManager.js";
+/** Shared manager type export */
+export type SharedManager = QueueManager;
+/**
+ * Get the process-wide QueueManager.
+ * A later explicit dataPath must identify the database selected on first use.
+ */
+export declare function getSharedManager(dataPath?: string): QueueManager;
+/** Shutdown shared manager */
+/** Inspect an existing manager without initializing an embedded runtime. */
+export declare function peekSharedManager(): SharedManager | null;
+export declare function shutdownManager(): void;

package/dist/types/src/client/pro.d.ts

@@ -0,0 +1,9 @@
+import { Queue } from "./queue.js";
+import { Worker } from "./worker.js";
+import { QueueEvents } from "./events.js";
+import type { Job } from "./types.js";
+/** BullMQ Pro-compatible import aliases backed by bunqueue's native implementations. */
+export declare const QueuePro: typeof Queue;
+export declare const WorkerPro: typeof Worker;
+export declare const QueueEventsPro: typeof QueueEvents;
+export type JobPro<T = unknown> = Job<T>;

package/dist/types/src/client/queue/addBatcher.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Add Batcher
+ * Batches queue.add() calls for efficient TCP communication via PUSHB
+ *
+ * Strategy: if no flush is in-flight, send immediately (zero overhead for
+ * sequential await). If a flush IS in-flight, buffer and send when it
+ * completes or after maxDelayMs, whichever comes first. This gives both
+ * zero-latency sequential adds AND automatic batching for concurrent adds.
+ */
+import type { Job, JobOptions } from "../types.js";
+/** Add batcher configuration */
+export interface AddBatcherConfig {
+    /** Max items before auto-flush (default: 50) */
+    maxSize: number;
+    /** Max delay in ms before auto-flush (default: 5) */
+    maxDelayMs: number;
+    /** Max pending items before overflow protection (default: 10000) */
+    maxPending?: number;
+}
+/** Flush callback that sends a batch and returns Job objects */
+export type FlushCallback<T> = (jobs: Array<{
+    name: string;
+    data: T;
+    opts?: JobOptions;
+}>) => Promise<Job<T>[]>;
+/**
+ * Batches add() operations into addBulk() calls for efficient TCP throughput.
+ *
+ * - If no flush is in-flight: flushes immediately (no timer delay)
+ * - If a flush IS in-flight: buffers until maxSize or maxDelayMs
+ * - After each flush completes: drains any accumulated buffer immediately
+ */
+export declare class AddBatcher<T> {
+    private readonly maxPending;
+    private readonly pending;
+    private timer;
+    private readonly config;
+    private readonly flushCb;
+    private stopped;
+    private flushing;
+    private readonly inFlightFlushes;
+    constructor(config: AddBatcherConfig, flushCb: FlushCallback<T>);
+    /** Enqueue an add() call, returns Promise<Job<T>> resolved after flush */
+    enqueue(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
+    /** Start a flush and track it */
+    private triggerFlush;
+    /** Flush pending adds, then drain any items that accumulated during flush */
+    private doFlush;
+    /** Flush all pending adds as a single addBulk call */
+    flush(): Promise<void>;
+    /** Send one batch */
+    private flushOnce;
+    /** Stop the batcher - rejects remaining pending entries */
+    stop(): void;
+    /** Wait for all in-flight flush operations to complete */
+    waitForInFlight(): Promise<void>;
+    /** Check if there are pending adds */
+    hasPending(): boolean;
+}

package/dist/types/src/client/queue/bullmqCompat.d.ts

@@ -0,0 +1,57 @@
+/**
+ * BullMQ v5 Compatibility Operations
+ */
+import type { TcpConnectionPool } from "../tcpPool.js";
+import type { Job, JobDependencies, JobDependenciesCount, GetDependenciesOpts } from "../types.js";
+interface CompatibilityContext<T = unknown> {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    getJobState: (id: string) => Promise<'waiting' | 'delayed' | 'active' | 'completed' | 'failed' | 'unknown'>;
+    removeAsync: (id: string) => Promise<void>;
+    retryJob: (id: string) => Promise<void>;
+    getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+    updateJobData: (id: string, data: unknown) => Promise<void>;
+    promoteJob: (id: string) => Promise<void>;
+    changeJobDelay: (id: string, delay: number) => Promise<void>;
+    changeJobPriority: (id: string, opts: {
+        priority: number;
+        lifo?: boolean;
+    }) => Promise<void>;
+    extendJobLock: (id: string, token: string, duration: number) => Promise<number>;
+    clearJobLogs: (id: string, keepLogs?: number) => Promise<void>;
+    getJobDependencies: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependencies>;
+    getJobDependenciesCount: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>;
+    getJobCountsAsync: () => Promise<{
+        prioritized: number;
+        'waiting-children': number;
+    }>;
+    getWaitingAsync: (start?: number, end?: number) => Promise<Job<T>[]>;
+    getPrioritizedAsync: (start?: number, end?: number) => Promise<Job<T>[]>;
+    getJobsAsync: (options: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }) => Promise<Job<T>[]>;
+}
+/** Get jobs in the "prioritized" state (priority > 0, BullMQ v5) */
+export declare function getPrioritized<T>(ctx: CompatibilityContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
+/** Get count of prioritized jobs (priority > 0) */
+export declare function getPrioritizedCount<T>(ctx: CompatibilityContext<T>): Promise<number>;
+/** Get jobs waiting for parent to complete */
+export declare function getWaitingChildren<T>(ctx: CompatibilityContext<T>, start?: number, end?: number): Promise<Job<T>[]>;
+/** Get count of jobs waiting for parent */
+export declare function getWaitingChildrenCount<T>(ctx: CompatibilityContext<T>): Promise<number>;
+/** Get dependencies of a parent job */
+export declare function getDependencies(ctx: CompatibilityContext, parentId: string, type?: 'processed' | 'unprocessed', start?: number, end?: number): Promise<{
+    processed?: Record<string, unknown>;
+    unprocessed?: string[];
+    nextProcessedCursor?: number;
+    nextUnprocessedCursor?: number;
+}>;
+/** Get job dependencies (for Job instance method) */
+export declare function getJobDependencies(ctx: CompatibilityContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependencies>;
+/** Get job dependencies count */
+export declare function getJobDependenciesCount(ctx: CompatibilityContext, id: string, _opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
+export {};

package/dist/types/src/client/queue/deduplication.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deduplication Operations
+ */
+import type { TcpConnectionPool } from "../tcpPool.js";
+interface DeduplicationContext {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+}
+/** Get the job ID associated with a deduplication key */
+export declare function getDeduplicationJobId(ctx: DeduplicationContext, deduplicationId: string): Promise<string | null>;
+/** Remove a deduplication key */
+export declare function removeDeduplicationKey(ctx: DeduplicationContext, deduplicationId: string): Promise<number>;
+export {};

package/dist/types/src/client/queue/dlq.d.ts

@@ -0,0 +1,61 @@
+/**
+ * DLQ Operations Wrapper
+ * Wraps dlqOps for Queue class usage
+ */
+import type { TcpConnectionPool } from "../tcpPool.js";
+import type { Job, DlqConfig, DlqEntry, DlqStats, DlqFilter } from "../types.js";
+import { type DlqJobContext } from "./dlqJobMethods.js";
+interface DlqContext {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+}
+/** Set DLQ configuration */
+export declare function setDlqConfig(ctx: DlqContext, config: Partial<DlqConfig>): void;
+/** Set DLQ configuration and resolve once the server has applied it. */
+export declare function setDlqConfigAsync(ctx: DlqContext, config: Partial<DlqConfig>): Promise<void>;
+/** Get DLQ configuration */
+export declare function getDlqConfig(ctx: DlqContext): DlqConfig;
+/** Get DLQ configuration (async, works in TCP mode) */
+export declare function getDlqConfigAsync(ctx: DlqContext): Promise<DlqConfig>;
+/** Get DLQ entries */
+export declare function getDlq<T>(ctx: DlqQueryContext, filter?: DlqFilter): DlqEntry<T>[];
+type DlqQueryContext = DlqJobContext;
+/** Read full DLQ metadata from the selected broker runtime. */
+export declare function getDlqAsync<T>(ctx: DlqQueryContext, filter?: DlqFilter): Promise<DlqEntry<T>[]>;
+/**
+ * Get only the public jobs from the DLQ. Use getDlqAsync() when the full entry
+ * metadata is needed; both views work over TCP through the same command.
+ */
+export declare function getDlqJobsAsync<T>(ctx: DlqQueryContext, count?: number): Promise<Job<T>[]>;
+/** Get DLQ stats */
+export declare function getDlqStats(ctx: DlqContext): DlqStats;
+/** Read authoritative DLQ statistics from the selected broker runtime. */
+export declare function getDlqStatsAsync(ctx: DlqContext): Promise<DlqStats>;
+/** Retry DLQ entries */
+export declare function retryDlq(ctx: DlqContext, id?: string): number;
+/**
+ * Retry DLQ entries and resolve with the retried count once the server has
+ * processed it. The fire-and-forget retryDlq() always returns 0 over TCP and
+ * discards the server's count.
+ */
+export declare function retryDlqAsync(ctx: DlqContext, id?: string): Promise<number>;
+/** Retry DLQ entries by filter */
+export declare function retryDlqByFilter(ctx: DlqContext, filter: DlqFilter): number;
+/** Retry matching DLQ entries and return the applied count. */
+export declare function retryDlqByFilterAsync(ctx: DlqContext, filter: DlqFilter): Promise<number>;
+/** Purge DLQ */
+export declare function purgeDlq(ctx: DlqContext): number;
+/**
+ * Purge the DLQ and resolve with the purged count once the server has
+ * processed it. The fire-and-forget purgeDlq() always returns 0 over TCP;
+ * purge-then-assert-empty patterns need this variant.
+ */
+export declare function purgeDlqAsync(ctx: DlqContext): Promise<number>;
+/** Remove one DLQ entry without re-enqueuing it. */
+export declare function removeDlqJobAsync(ctx: DlqContext, id: string): Promise<boolean>;
+/** Retry completed job */
+export declare function retryCompleted(ctx: DlqContext, id?: string): number;
+/** Retry completed job (async) */
+export declare function retryCompletedAsync(ctx: DlqContext, id?: string): Promise<number>;
+export {};

package/dist/types/src/client/queue/dlqJobMethods.d.ts

@@ -0,0 +1,9 @@
+import type { PublicJobMethodContext } from "../jobConversionTypes.js";
+import type { TcpConnectionPool } from "../tcpPool.js";
+import type { SimpleJobContext } from "./jobProxy.js";
+export interface DlqJobContext extends Pick<SimpleJobContext, 'getJobState' | 'removeAsync' | 'retryJob' | 'getChildrenValues'> {
+    name: string;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+}
+export declare function createDlqJobMethods(ctx: DlqJobContext): PublicJobMethodContext;

package/dist/types/src/client/queue/dlqOps.d.ts

@@ -0,0 +1,26 @@
+/**
+ * DLQ Operations
+ * Dead Letter Queue management for embedded mode
+ */
+import type { DlqConfig, DlqEntry, DlqStats, DlqFilter, StallConfig } from "../types.js";
+import type { PublicJobMethodContext } from "../jobConversionTypes.js";
+/** Set DLQ configuration (embedded only) */
+export declare function setDlqConfig(queue: string, config: Partial<DlqConfig>): void;
+/** Get DLQ configuration (embedded only) */
+export declare function getDlqConfigEmbedded(queue: string): DlqConfig;
+/** Get DLQ entries (embedded only) */
+export declare function getDlqEntries<T>(queue: string, methods: PublicJobMethodContext, filter?: DlqFilter): DlqEntry<T>[];
+/** Get DLQ statistics (embedded only) */
+export declare function getDlqStatsEmbedded(queue: string): DlqStats;
+/** Retry DLQ jobs by filter (embedded only) */
+export declare function retryDlqByFilterEmbedded(queue: string, filter: DlqFilter): number;
+/** Retry DLQ jobs (embedded) */
+export declare function retryDlqEmbedded(queue: string, id?: string): number;
+/** Purge DLQ (embedded) */
+export declare function purgeDlqEmbedded(queue: string): number;
+/** Remove one DLQ entry in embedded mode. */
+export declare function removeDlqJobEmbedded(queue: string, id: string): boolean;
+/** Set stall config (embedded only) */
+export declare function setStallConfigEmbedded(queue: string, config: Record<string, unknown>): void;
+/** Get stall config (embedded only) */
+export declare function getStallConfigEmbedded(queue: string): StallConfig;

package/dist/types/src/client/queue/dlqStats.d.ts

@@ -0,0 +1,3 @@
+import type { DlqStats } from "../types.js";
+/** Normalize one authoritative DLQ stats shape for both transports. */
+export declare function toPublicDlqStats(stats: Partial<DlqStats> | undefined): DlqStats;