bunqueue 2.8.54 → 2.8.56

package/dist/client/queue/jobProxy.js

@@ -1,516 +1,3 @@
-/**
- * Job Proxy
- * Creates Job objects with methods for TCP and embedded modes
- */
-import { getSharedManager } from '../manager';
-import { jobId } from '../../domain/types/job';
-import { buildFailCommand, failEmbeddedArgs } from './failWire';
-import { removeJobDeduplicationKey } from '../jobDeduplication';
-function reflectFields(id, queueName, meta) {
-    const opts = meta?.opts ?? {};
-    const p = opts.parent;
-    const repeat = opts.repeat;
-    const pattern = repeat?.pattern ?? (repeat?.every ? `every:${repeat.every}` : '');
-    return {
-        delay: meta?.delay ?? 0,
-        priority: meta?.priority ?? 0,
-        opts,
-        deduplicationId: opts.jobId ?? opts.deduplication?.id,
-        parentKey: p ? `${p.queue}:${p.id}` : undefined,
-        parent: p ? { id: p.id, queueQualifiedName: p.queue } : undefined,
-        repeatJobKey: repeat ? `${queueName}:${id}:${pattern}` : undefined,
-        stacktrace: meta?.stacktrace ?? null,
-        failedReason: meta?.failedReason,
-    };
-}
-/** Create a full Job proxy with TCP methods */
-export function createJobProxy(id, name, data, ctx, meta) {
-    const { tcp, queueName } = ctx;
-    const ts = meta?.timestamp ?? Date.now();
-    const r = reflectFields(id, queueName, meta);
-    return {
-        id,
-        name,
-        data,
-        queueName,
-        attemptsMade: 0,
-        timestamp: ts,
-        progress: 0,
-        delay: r.delay,
-        processedOn: undefined,
-        finishedOn: undefined,
-        stacktrace: r.stacktrace,
-        failedReason: r.failedReason,
-        stalledCounter: 0,
-        priority: r.priority,
-        parent: r.parent,
-        parentKey: r.parentKey,
-        opts: r.opts,
-        token: undefined,
-        processedBy: undefined,
-        deduplicationId: r.deduplicationId,
-        repeatJobKey: r.repeatJobKey,
-        attemptsStarted: 0,
-        // Methods
-        updateProgress: async (progress, message) => {
-            await tcp.send({ cmd: 'Progress', id, progress, message });
-        },
-        log: async (message) => {
-            await tcp.send({ cmd: 'AddLog', id, message });
-        },
-        getState: () => ctx.getJobState(id),
-        remove: () => ctx.removeAsync(id),
-        retry: () => ctx.retryJob(id),
-        getChildrenValues: () => ctx.getChildrenValues(id),
-        // State check methods
-        isWaiting: async () => (await ctx.getJobState(id)) === 'waiting',
-        isActive: async () => (await ctx.getJobState(id)) === 'active',
-        isDelayed: async () => (await ctx.getJobState(id)) === 'delayed',
-        isCompleted: async () => (await ctx.getJobState(id)) === 'completed',
-        isFailed: async () => (await ctx.getJobState(id)) === 'failed',
-        isWaitingChildren: async () => (await ctx.getJobState(id)) === 'waiting-children',
-        // Mutation methods
-        updateData: async (newData) => {
-            await tcp.send({ cmd: 'Update', id, data: newData });
-        },
-        promote: async () => {
-            await tcp.send({ cmd: 'Promote', id });
-        },
-        changeDelay: async (delay) => {
-            await tcp.send({ cmd: 'ChangeDelay', id, delay });
-        },
-        changePriority: async (opts) => {
-            await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority, lifo: opts.lifo });
-        },
-        extendLock: async (token, duration) => {
-            const res = await tcp.send({ cmd: 'ExtendLock', id, token, duration });
-            return res.ok === true ? duration : 0;
-        },
-        clearLogs: async () => {
-            await tcp.send({ cmd: 'ClearLogs', id });
-        },
-        // Dependency methods — derive from child state queries since no dedicated API
-        getDependencies: () => computeDependencies(id, queueName, tcp),
-        getDependenciesCount: async () => {
-            const deps = await computeDependencies(id, queueName, tcp);
-            return {
-                processed: Object.keys(deps.processed).length,
-                unprocessed: deps.unprocessed.length,
-            };
-        },
-        // Serialization methods
-        toJSON: () => ({
-            id,
-            name,
-            data,
-            opts: r.opts,
-            progress: 0,
-            delay: r.delay,
-            timestamp: ts,
-            attemptsMade: 0,
-            stacktrace: r.stacktrace,
-            failedReason: r.failedReason,
-            queueQualifiedName: `bull:${queueName}`,
-            parentKey: r.parentKey,
-        }),
-        asJSON: () => ({
-            id,
-            name,
-            data: JSON.stringify(data),
-            opts: JSON.stringify(r.opts),
-            progress: '0',
-            delay: String(r.delay),
-            timestamp: String(ts),
-            attemptsMade: '0',
-            stacktrace: r.stacktrace ? JSON.stringify(r.stacktrace) : null,
-            failedReason: r.failedReason,
-            parentKey: r.parentKey,
-        }),
-        // Move methods
-        moveToCompleted: async (returnValue) => {
-            await tcp.send({ cmd: 'ACK', id, result: returnValue });
-            return null;
-        },
-        moveToFailed: async (error) => {
-            // Forward stacktrace + UnrecoverableError (was dropped; #74/#111-class).
-            await tcp.send(buildFailCommand(id, error));
-        },
-        moveToWait: async () => {
-            const res = await tcp.send({ cmd: 'MoveToWait', id });
-            return res.ok === true;
-        },
-        moveToDelayed: async (timestamp) => {
-            const delay = Math.max(0, timestamp - Date.now());
-            await tcp.send({ cmd: 'MoveToDelayed', id, delay });
-        },
-        moveToWaitingChildren: async () => {
-            const response = await tcp.send({ cmd: 'MoveToWaitingChildren', id });
-            return response.ok === true;
-        },
-        waitUntilFinished: async (_queueEvents, ttl) => {
-            const timeout = ttl ?? 30000;
-            const res = await tcp.send({ cmd: 'WaitJob', id, timeout });
-            const typed = res;
-            if (!typed.completed)
-                throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
-            return typed.result;
-        },
-        // Additional methods
-        discard: () => {
-            void tcp.send({ cmd: 'Discard', id });
-        },
-        getFailedChildrenValues: async () => {
-            const res = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
-            return res.values ?? {};
-        },
-        getIgnoredChildrenFailures: async () => {
-            const res = await tcp.send({ cmd: 'GetIgnoredChildrenFailures', id });
-            return res.values ?? {};
-        },
-        removeChildDependency: async () => {
-            const res = await tcp.send({ cmd: 'RemoveChildDependency', id });
-            return res.removed ?? false;
-        },
-        removeDeduplicationKey: () => removeJobDeduplicationKey(id, false, tcp),
-        removeUnprocessedChildren: async () => {
-            await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
-        },
-    };
-}
-/** Fetch child ids for a job via GetJob, then derive dependency state per child */
-async function computeDependencies(id, queueName, tcp) {
-    const jobRes = await tcp.send({ cmd: 'GetJob', id });
-    const parent = jobRes.job;
-    const childIds = parent?.childrenIds ?? [];
-    const processed = {};
-    const unprocessed = [];
-    for (const cid of childIds) {
-        const stateRes = await tcp.send({ cmd: 'GetState', id: cid });
-        const state = stateRes.state ?? 'unknown';
-        const key = `${queueName}:${cid}`;
-        if (state === 'completed' || state === 'failed') {
-            if (state === 'completed') {
-                const resR = await tcp.send({ cmd: 'GetResult', id: cid });
-                processed[key] = resR.result ?? null;
-            }
-            else {
-                processed[key] = null;
-            }
-        }
-        else {
-            unprocessed.push(key);
-        }
-    }
-    return { processed, unprocessed };
-}
-/**
- * Create a simple Job with all BullMQ v5 methods wired.
- * Used by Queue.getJob / getJobs in both embedded and TCP modes.
- */
-export function createSimpleJob(id, name, data, timestamp, ctx) {
-    const { queueName, embedded, tcp, meta } = ctx;
-    const r = reflectFields(id, queueName, meta);
-    return {
-        id,
-        name,
-        data,
-        queueName,
-        attemptsMade: 0,
-        timestamp,
-        progress: 0,
-        delay: r.delay,
-        processedOn: undefined,
-        finishedOn: undefined,
-        stacktrace: r.stacktrace,
-        failedReason: r.failedReason,
-        stalledCounter: 0,
-        priority: r.priority,
-        parent: r.parent,
-        parentKey: r.parentKey,
-        opts: r.opts,
-        token: undefined,
-        processedBy: undefined,
-        deduplicationId: r.deduplicationId,
-        repeatJobKey: r.repeatJobKey,
-        attemptsStarted: 0,
-        updateProgress: async (progress, message) => {
-            if (embedded) {
-                await getSharedManager().updateProgress(jobId(id), progress, message);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'Progress', id, progress, message });
-        },
-        log: async (message) => {
-            if (embedded) {
-                getSharedManager().addLog(jobId(id), message);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'AddLog', id, message });
-        },
-        getState: () => ctx.getJobState(id),
-        remove: () => ctx.removeAsync(id),
-        retry: () => ctx.retryJob(id),
-        getChildrenValues: () => ctx.getChildrenValues(id),
-        // State check methods
-        isWaiting: async () => (await ctx.getJobState(id)) === 'waiting',
-        isActive: async () => (await ctx.getJobState(id)) === 'active',
-        isDelayed: async () => (await ctx.getJobState(id)) === 'delayed',
-        isCompleted: async () => (await ctx.getJobState(id)) === 'completed',
-        isFailed: async () => (await ctx.getJobState(id)) === 'failed',
-        isWaitingChildren: async () => (await ctx.getJobState(id)) === 'waiting-children',
-        updateData: async (newData) => {
-            if (embedded) {
-                await getSharedManager().updateJobData(jobId(id), newData);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'Update', id, data: newData });
-        },
-        promote: async () => {
-            if (embedded) {
-                await getSharedManager().promote(jobId(id));
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'Promote', id });
-        },
-        changeDelay: async (delay) => {
-            if (embedded) {
-                await getSharedManager().changeDelay(jobId(id), delay);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'ChangeDelay', id, delay });
-        },
-        changePriority: async (opts) => {
-            if (embedded) {
-                await getSharedManager().changePriority(jobId(id), opts.priority, opts.lifo);
-                return;
-            }
-            if (tcp) {
-                await tcp.send({ cmd: 'ChangePriority', id, priority: opts.priority, lifo: opts.lifo });
-            }
-        },
-        extendLock: async (token, duration) => {
-            if (embedded) {
-                const ok = await getSharedManager().extendLock(jobId(id), token, duration);
-                return ok ? duration : 0;
-            }
-            if (!tcp)
-                return 0;
-            const res = await tcp.send({ cmd: 'ExtendLock', id, token, duration });
-            return res.ok === true ? duration : 0;
-        },
-        clearLogs: async (keepLogs) => {
-            if (embedded) {
-                getSharedManager().clearLogs(jobId(id), keepLogs);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'ClearLogs', id, keepLogs });
-        },
-        getDependencies: () => computeDepsSimple(id, queueName, embedded, tcp),
-        getDependenciesCount: async () => {
-            const deps = await computeDepsSimple(id, queueName, embedded, tcp);
-            return {
-                processed: Object.keys(deps.processed).length,
-                unprocessed: deps.unprocessed.length,
-            };
-        },
-        toJSON: () => ({
-            id,
-            name,
-            data,
-            opts: r.opts,
-            progress: 0,
-            delay: r.delay,
-            timestamp,
-            attemptsMade: 0,
-            stacktrace: r.stacktrace,
-            failedReason: r.failedReason,
-            queueQualifiedName: `bull:${queueName}`,
-            parentKey: r.parentKey,
-        }),
-        asJSON: () => ({
-            id,
-            name,
-            data: JSON.stringify(data),
-            opts: JSON.stringify(r.opts),
-            progress: '0',
-            delay: String(r.delay),
-            timestamp: String(timestamp),
-            attemptsMade: '0',
-            stacktrace: r.stacktrace ? JSON.stringify(r.stacktrace) : null,
-            failedReason: r.failedReason,
-            parentKey: r.parentKey,
-        }),
-        moveToCompleted: async (returnValue) => {
-            if (embedded) {
-                await getSharedManager().ack(jobId(id), returnValue);
-                return null;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'ACK', id, result: returnValue });
-            return null;
-        },
-        moveToFailed: async (error) => {
-            // Forward stacktrace + UnrecoverableError (was dropped; #74/#111-class).
-            if (embedded) {
-                await getSharedManager().fail(jobId(id), ...failEmbeddedArgs(error));
-                return;
-            }
-            if (tcp)
-                await tcp.send(buildFailCommand(id, error));
-        },
-        moveToWait: async () => {
-            if (embedded) {
-                const mgr = getSharedManager();
-                const state = await mgr.getJobState(jobId(id));
-                if (state === 'active')
-                    return await mgr.moveActiveToWait(jobId(id));
-                if (state === 'delayed')
-                    return await mgr.promote(jobId(id));
-                if (state === 'failed') {
-                    const job = await mgr.getJob(jobId(id));
-                    if (!job)
-                        return false;
-                    return mgr.retryDlq(job.queue, jobId(id)) > 0;
-                }
-                if (state === 'waiting' || state === 'prioritized')
-                    return true;
-                return false;
-            }
-            if (!tcp)
-                return false;
-            const res = await tcp.send({ cmd: 'MoveToWait', id });
-            return res.ok === true;
-        },
-        moveToDelayed: async (ts) => {
-            const delay = Math.max(0, ts - Date.now());
-            if (embedded) {
-                await getSharedManager().moveToDelayed(jobId(id), delay);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'MoveToDelayed', id, delay });
-        },
-        moveToWaitingChildren: async () => {
-            if (embedded) {
-                return await getSharedManager().moveToWaitingChildren(jobId(id));
-            }
-            if (!tcp)
-                return false;
-            const response = await tcp.send({ cmd: 'MoveToWaitingChildren', id });
-            return response.ok === true;
-        },
-        waitUntilFinished: async (_qe, ttl) => {
-            const timeout = ttl ?? 30000;
-            if (embedded) {
-                const mgr = getSharedManager();
-                const job = await mgr.getJob(jobId(id));
-                if (!job)
-                    throw new Error(`Job ${id} not found`);
-                if (job.completedAt)
-                    return mgr.getResult(jobId(id));
-                const ok = await mgr.waitForJobCompletion(jobId(id), timeout);
-                if (!ok)
-                    throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
-                return mgr.getResult(jobId(id));
-            }
-            if (!tcp)
-                throw new Error('waitUntilFinished: no connection');
-            const res = await tcp.send({ cmd: 'WaitJob', id, timeout });
-            const typed = res;
-            if (!typed.completed)
-                throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
-            return typed.result;
-        },
-        discard: () => {
-            if (embedded) {
-                void getSharedManager().discard(jobId(id));
-                return;
-            }
-            if (tcp)
-                void tcp.send({ cmd: 'Discard', id });
-        },
-        getFailedChildrenValues: async () => {
-            if (embedded) {
-                return await getSharedManager().getFailedChildrenValues(jobId(id));
-            }
-            if (!tcp)
-                return {};
-            const res = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
-            return res.values ?? {};
-        },
-        getIgnoredChildrenFailures: async () => {
-            if (embedded) {
-                return await getSharedManager().getIgnoredChildrenFailures(jobId(id));
-            }
-            if (!tcp)
-                return {};
-            const res = await tcp.send({ cmd: 'GetIgnoredChildrenFailures', id });
-            return res.values ?? {};
-        },
-        removeChildDependency: async () => {
-            if (embedded) {
-                return await getSharedManager().removeChildDependency(jobId(id));
-            }
-            if (!tcp)
-                return false;
-            const res = await tcp.send({ cmd: 'RemoveChildDependency', id });
-            return res.removed ?? false;
-        },
-        removeDeduplicationKey: () => removeJobDeduplicationKey(id, embedded ?? false, tcp),
-        removeUnprocessedChildren: async () => {
-            if (embedded) {
-                await getSharedManager().removeUnprocessedChildren(jobId(id));
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
-        },
-    };
-}
-/** Shared dependency computation for both embedded and TCP modes */
-async function computeDepsSimple(id, queueName, embedded, tcp) {
-    const processed = {};
-    const unprocessed = [];
-    let childIds = [];
-    if (embedded) {
-        const job = await getSharedManager().getJob(jobId(id));
-        childIds = (job?.childrenIds ?? []).map(String);
-    }
-    else if (tcp) {
-        const jobRes = await tcp.send({ cmd: 'GetJob', id });
-        const parent = jobRes.job;
-        childIds = (parent?.childrenIds ?? []).map(String);
-    }
-    for (const cid of childIds) {
-        let state = 'unknown';
-        let result;
-        if (embedded) {
-            const mgr = getSharedManager();
-            state = await mgr.getJobState(jobId(cid));
-            if (state === 'completed')
-                result = mgr.getResult(jobId(cid));
-        }
-        else if (tcp) {
-            const r = await tcp.send({ cmd: 'GetState', id: cid });
-            state = r.state ?? 'unknown';
-            if (state === 'completed') {
-                const rr = await tcp.send({ cmd: 'GetResult', id: cid });
-                result = rr.result;
-            }
-        }
-        const key = `${queueName}:${cid}`;
-        if (state === 'completed' || state === 'failed') {
-            processed[key] = result ?? null;
-        }
-        else {
-            unprocessed.push(key);
-        }
-    }
-    return { processed, unprocessed };
-}
+/** Stable Job proxy import surface. */
+export { createSimpleJob } from './job-proxy/simple';
+export { createJobProxy } from './job-proxy/tcp';

package/dist/client/queue/operations/add/bulk.d.ts

@@ -0,0 +1,7 @@
+import type { Job, JobOptions } from '../../../types';
+import type { AddContext } from '../../types/add';
+export declare function addBulk<T>(context: AddContext, jobs: Array<{
+    name: string;
+    data: T;
+    opts?: JobOptions;
+}>): Promise<Job<T>[]>;

package/dist/client/queue/operations/add/bulk.js

@@ -0,0 +1,129 @@
+import { getSharedManager } from '../../../manager';
+import { jobId } from '../../../../domain/types/job';
+import { createJobProxy, createSimpleJob } from '../../jobProxy';
+import { buildJobData, buildRepeatOptions, compact, reflectionMeta } from './payload';
+export async function addBulk(context, jobs) {
+    if (jobs.length === 0)
+        return [];
+    const now = Date.now();
+    const merged = jobs.map(({ opts }) => ({
+        ...context.opts.defaultJobOptions,
+        ...opts,
+    }));
+    if (context.embedded) {
+        const manager = getSharedManager();
+        const inputs = jobs.map(({ name, data }, index) => {
+            const options = merged[index];
+            const removeOnComplete = typeof options.removeOnComplete === 'boolean' ? options.removeOnComplete : false;
+            const removeOnFail = typeof options.removeOnFail === 'boolean' ? options.removeOnFail : false;
+            return {
+                name,
+                data: buildJobData(data, options),
+                priority: options.priority,
+                delay: options.delay,
+                maxAttempts: options.attempts,
+                backoff: options.backoff,
+                timeout: options.timeout,
+                ttl: options.ttl,
+                customId: options.jobId,
+                uniqueKey: options.deduplication?.id,
+                dependsOn: options.dependsOn?.map((id) => jobId(id)),
+                parentId: options.parent ? jobId(options.parent.id) : undefined,
+                tags: options.tags,
+                groupId: options.groupId,
+                stallTimeout: options.stallTimeout,
+                timestamp: options.timestamp,
+                removeOnComplete,
+                removeOnFail,
+                repeat: options.repeat ? buildRepeatOptions(options.repeat) : undefined,
+                durable: options.durable,
+                lifo: options.lifo,
+                stackTraceLimit: options.stackTraceLimit,
+                keepLogs: options.keepLogs,
+                sizeLimit: options.sizeLimit,
+                failParentOnFailure: options.failParentOnFailure,
+                removeDependencyOnFailure: options.removeDependencyOnFailure,
+                continueParentOnFailure: options.continueParentOnFailure,
+                ignoreDependencyOnFailure: options.ignoreDependencyOnFailure,
+                dedup: options.deduplication
+                    ? {
+                        ttl: options.deduplication.ttl,
+                        extend: options.deduplication.extend,
+                        replace: options.deduplication.replace,
+                    }
+                    : undefined,
+                debounceId: options.debounce?.id,
+                debounceTtl: options.debounce?.ttl,
+            };
+        });
+        const ids = await manager.pushBatch(context.name, inputs);
+        return ids.map((id, index) => createSimpleJob(String(id), jobs[index].name, jobs[index].data, now, {
+            queueName: context.name,
+            embedded: context.embedded,
+            tcp: context.tcp,
+            getJobState: context.getJobState,
+            removeAsync: context.removeAsync,
+            retryJob: context.retryJob,
+            getChildrenValues: context.getChildrenValues,
+            meta: reflectionMeta(merged[index]),
+        }));
+    }
+    const tcp = context.tcp;
+    const batchJobs = jobs.map(({ name, data }, index) => {
+        const options = merged[index];
+        const removeOnComplete = typeof options.removeOnComplete === 'boolean' ? options.removeOnComplete : false;
+        const removeOnFail = typeof options.removeOnFail === 'boolean' ? options.removeOnFail : false;
+        return compact({
+            name,
+            data: buildJobData(data, options),
+            priority: options.priority,
+            delay: options.delay,
+            maxAttempts: options.attempts,
+            backoff: options.backoff,
+            timeout: options.timeout,
+            ttl: options.ttl,
+            customId: options.jobId,
+            tags: options.tags,
+            groupId: options.groupId,
+            dependsOn: options.dependsOn?.map((id) => jobId(id)),
+            parentId: options.parent ? jobId(options.parent.id) : undefined,
+            uniqueKey: options.deduplication?.id,
+            dedup: options.deduplication
+                ? {
+                    ttl: options.deduplication.ttl,
+                    extend: options.deduplication.extend,
+                    replace: options.deduplication.replace,
+                }
+                : undefined,
+            lifo: options.lifo,
+            stallTimeout: options.stallTimeout,
+            timestamp: options.timestamp,
+            removeOnComplete,
+            removeOnFail,
+            repeat: options.repeat,
+            durable: options.durable,
+            stackTraceLimit: options.stackTraceLimit,
+            keepLogs: options.keepLogs,
+            sizeLimit: options.sizeLimit,
+            failParentOnFailure: options.failParentOnFailure,
+            removeDependencyOnFailure: options.removeDependencyOnFailure,
+            continueParentOnFailure: options.continueParentOnFailure,
+            ignoreDependencyOnFailure: options.ignoreDependencyOnFailure,
+            debounceId: options.debounce?.id,
+            debounceTtl: options.debounce?.ttl,
+        });
+    });
+    const response = await tcp.send({ cmd: 'PUSHB', queue: context.name, jobs: batchJobs });
+    if (!response.ok) {
+        throw new Error(response.error ?? 'Failed to add jobs');
+    }
+    const ids = (response.ids ?? []);
+    return ids.map((id, index) => createJobProxy(id, jobs[index].name, jobs[index].data, {
+        queueName: context.name,
+        tcp,
+        getJobState: context.getJobState,
+        removeAsync: context.removeAsync,
+        retryJob: context.retryJob,
+        getChildrenValues: context.getChildrenValues,
+    }, reflectionMeta(merged[index])));
+}

package/dist/client/queue/operations/add/payload.d.ts

@@ -0,0 +1,24 @@
+import type { JobOptions } from '../../../types';
+import type { ExtendedJobOptions } from '../../types/add';
+export declare function compact<T extends Record<string, unknown>>(object: T): T;
+export declare function parseDate(date: Date | string | number | undefined): number | undefined;
+export declare function buildRepeatOptions(repeat: NonNullable<JobOptions['repeat']>): {
+    every: number | undefined;
+    limit: number | undefined;
+    pattern: string | undefined;
+    count: number | undefined;
+    startDate: number | undefined;
+    endDate: number | undefined;
+    tz: string | undefined;
+    immediately: boolean | undefined;
+    prevMillis: number | undefined;
+    offset: number | undefined;
+    jobId: string | undefined;
+};
+export declare function buildPushPayload(queue: string, name: string, data: unknown, options: ExtendedJobOptions): Record<string, unknown>;
+export declare function buildJobData(data: unknown, options: ExtendedJobOptions): unknown;
+export declare function reflectionMeta(options: ExtendedJobOptions): {
+    priority?: number;
+    delay?: number;
+    opts: JobOptions;
+};