bunqueue 2.8.49 → 2.8.50

package/dist/client/flowJobFactory.d.ts

@@ -1,29 +1,16 @@
 /**
  * Flow Job Factory
- * Creates simple Job objects for FlowProducer results
+ * Creates BullMQ-compatible Job objects backed by FlowProducer transports.
  */
+import type { Job as DomainJob } from '../domain/types/job';
+import type { FlowJobCallbacks } from './flowJobTypes';
 import type { Job } from './types';
-import type { TcpConnectionPool } from './tcpPool';
-/** Callbacks for flow job mutation operations */
-export interface FlowJobCallbacks {
-    /** Execution mode — enables full method wiring when provided */
-    embedded?: boolean;
-    tcp?: TcpConnectionPool | null;
-    updateData?: (id: string, data: unknown) => Promise<void>;
-    updateProgress?: (id: string, progress: number | object) => Promise<void>;
-    log?: (id: string, message: string) => Promise<void>;
-    promote?: (id: string) => Promise<void>;
-    remove?: (id: string) => Promise<void>;
-    changePriority?: (id: string, opts: {
-        priority: number;
-        lifo?: boolean;
-    }) => Promise<void>;
-    changeDelay?: (id: string, delay: number) => Promise<void>;
-    clearLogs?: (id: string) => Promise<void>;
-    retry?: (id: string) => Promise<void>;
-    getState?: (id: string) => Promise<string>;
-}
-/** Extract user data (remove internal fields like __parentId, __childrenIds, name) */
+export type { FlowJobCallbacks } from './flowJobTypes';
+/** Extract user data while removing internal flow metadata and the stored job name. */
 export declare function extractUserDataFromInternal(data: Record<string, unknown>): unknown;
-/** Create a simple Job object for flow results */
-export declare function createFlowJobObject<T>(id: string, name: string, data: T, queueName: string, callbacks?: FlowJobCallbacks): Job<T>;
+interface FlowJobObjectOptions {
+    callbacks?: FlowJobCallbacks;
+    snapshot?: DomainJob;
+}
+/** Create a Job object for a newly committed or fetched flow node. */
+export declare function createFlowJobObject<T>(id: string, name: string, data: T, queueName: string, factoryOptions?: FlowJobObjectOptions): Job<T>;

package/dist/client/flowJobFactory.js

@@ -1,227 +1,45 @@
 /**
  * Flow Job Factory
- * Creates simple Job objects for FlowProducer results
+ * Creates BullMQ-compatible Job objects backed by FlowProducer transports.
  */
-import { getSharedManager } from './manager';
-import { buildFailCommand, failEmbeddedArgs } from './queue/failWire';
 import { jobId } from '../domain/types/job';
-/** Extract user data (remove internal fields like __parentId, __childrenIds, name) */
-export function extractUserDataFromInternal(data) {
-    const result = {};
-    for (const [key, value] of Object.entries(data)) {
-        if (!key.startsWith('__') && key !== 'name') {
-            result[key] = value;
-        }
+import { buildJobProperties, buildSerializationMethods } from './jobConversionHelpers';
+import { buildJobOpts } from './jobHelpers';
+import { buildFlowJobCoreMethods } from './flowJobCoreMethods';
+import { buildFlowJobMoveMethods } from './flowJobMoveMethods';
+import { getSharedManager } from './manager';
+const JOB_STATES = new Set([
+    'waiting',
+    'active',
+    'completed',
+    'failed',
+    'delayed',
+    'prioritized',
+    'waiting-children',
+    'unknown',
+]);
+function stateAsType(state) {
+    return JOB_STATES.has(state) ? state : 'unknown';
+}
+function buildStateResolver(id, callbacks) {
+    if (callbacks?.getState) {
+        return () => callbacks.getState(id).then(stateAsType);
     }
-    return result;
+    if (callbacks?.embedded) {
+        return () => getSharedManager().getJobState(jobId(id)).then(stateAsType);
+    }
+    if (callbacks?.tcp) {
+        return () => callbacks.tcp.send({ cmd: 'GetState', id }).then((response) => {
+            if (response.ok !== true) {
+                throw new Error(typeof response.error === 'string' ? response.error : 'GetState failed');
+            }
+            return stateAsType(typeof response.state === 'string' ? response.state : 'unknown');
+        });
+    }
+    return () => Promise.resolve('unknown');
 }
-/** Create a simple Job object for flow results */
-export function createFlowJobObject(id, name, data, queueName, callbacks) {
-    const ts = Date.now();
-    const embedded = !!callbacks?.embedded;
-    const tcp = callbacks?.tcp ?? null;
-    const stateAsType = (s) => {
-        const valid = [
-            'waiting',
-            'active',
-            'completed',
-            'failed',
-            'delayed',
-            'prioritized',
-            'waiting-children',
-            'unknown',
-        ];
-        return (valid.includes(s) ? s : 'unknown');
-    };
-    const getStateInternal = () => {
-        if (callbacks?.getState)
-            return callbacks.getState(id).then(stateAsType);
-        if (embedded) {
-            return getSharedManager()
-                .getJobState(jobId(id))
-                .then((s) => stateAsType(s));
-        }
-        if (tcp) {
-            return tcp.send({ cmd: 'GetState', id }).then((r) => {
-                const s = r.state ?? 'unknown';
-                return stateAsType(s);
-            });
-        }
-        return Promise.resolve('unknown');
-    };
+function defaultSerialization(id, name, data, queueName, timestamp) {
     return {
-        id,
-        name,
-        data,
-        queueName,
-        attemptsMade: 0,
-        timestamp: ts,
-        progress: 0,
-        delay: 0,
-        processedOn: undefined,
-        finishedOn: undefined,
-        stacktrace: null,
-        stalledCounter: 0,
-        priority: 0,
-        parentKey: undefined,
-        opts: {},
-        token: undefined,
-        processedBy: undefined,
-        deduplicationId: undefined,
-        repeatJobKey: undefined,
-        attemptsStarted: 0,
-        updateProgress: async (progress) => {
-            if (callbacks?.updateProgress) {
-                return callbacks.updateProgress(id, progress);
-            }
-            if (embedded) {
-                await getSharedManager().updateProgress(jobId(id), progress);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'Progress', id, progress: progress });
-        },
-        log: async (message) => {
-            if (callbacks?.log)
-                return callbacks.log(id, message);
-            if (embedded) {
-                getSharedManager().addLog(jobId(id), message);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'AddLog', id, message });
-        },
-        getState: getStateInternal,
-        remove: async () => {
-            if (callbacks?.remove)
-                return callbacks.remove(id);
-            if (embedded) {
-                await getSharedManager().cancel(jobId(id));
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'Cancel', id });
-        },
-        retry: async () => {
-            if (callbacks?.retry)
-                return callbacks.retry(id);
-            if (embedded) {
-                const mgr = getSharedManager();
-                const state = await mgr.getJobState(jobId(id));
-                if (state === 'failed') {
-                    const count = mgr.retryDlq(queueName, jobId(id));
-                    if (count === 0)
-                        throw new Error(`Job ${id} is failed but not present in DLQ`);
-                    return;
-                }
-                if (state === 'active') {
-                    const ok = await mgr.moveActiveToWait(jobId(id));
-                    if (!ok)
-                        throw new Error(`Failed to retry active job ${id}`);
-                    return;
-                }
-                if (state === 'waiting' || state === 'prioritized' || state === 'delayed')
-                    return;
-                throw new Error(`Cannot retry job ${id} from state '${state}'`);
-            }
-            if (!tcp)
-                return;
-            const res = await tcp.send({ cmd: 'MoveToWait', id });
-            if (res.ok !== true) {
-                const err = typeof res.error === 'string' ? res.error : 'retry failed';
-                throw new Error(err);
-            }
-        },
-        getChildrenValues: async () => {
-            if (embedded) {
-                return (await getSharedManager().getChildrenValues(jobId(id)));
-            }
-            if (!tcp)
-                return {};
-            const res = await tcp.send({ cmd: 'GetChildrenValues', id });
-            const vals = res.data?.values ?? {};
-            return vals;
-        },
-        isWaiting: async () => (await getStateInternal()) === 'waiting',
-        isActive: async () => (await getStateInternal()) === 'active',
-        isDelayed: async () => (await getStateInternal()) === 'delayed',
-        isCompleted: async () => (await getStateInternal()) === 'completed',
-        isFailed: async () => (await getStateInternal()) === 'failed',
-        isWaitingChildren: async () => (await getStateInternal()) === 'waiting-children',
-        updateData: async (newData) => {
-            if (callbacks?.updateData)
-                return callbacks.updateData(id, newData);
-            if (embedded) {
-                await getSharedManager().updateJobData(jobId(id), newData);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'Update', id, data: newData });
-        },
-        promote: async () => {
-            if (callbacks?.promote)
-                return callbacks.promote(id);
-            if (embedded) {
-                await getSharedManager().promote(jobId(id));
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'Promote', id });
-        },
-        changeDelay: async (delay) => {
-            if (callbacks?.changeDelay)
-                return callbacks.changeDelay(id, delay);
-            if (embedded) {
-                await getSharedManager().changeDelay(jobId(id), delay);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'ChangeDelay', id, delay });
-        },
-        changePriority: async (opts) => {
-            if (callbacks?.changePriority) {
-                return callbacks.changePriority(id, { priority: opts.priority, lifo: opts.lifo });
-            }
-            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 (callbacks?.clearLogs)
-                return callbacks.clearLogs(id);
-            if (embedded) {
-                getSharedManager().clearLogs(jobId(id), keepLogs);
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'ClearLogs', id, keepLogs });
-        },
-        getDependencies: async () => {
-            const childIds = await fetchChildIds(id, embedded, tcp);
-            return computeDepsFlow(queueName, childIds, embedded, tcp);
-        },
-        getDependenciesCount: async () => {
-            const childIds = await fetchChildIds(id, embedded, tcp);
-            const deps = await computeDepsFlow(queueName, childIds, embedded, tcp);
-            return {
-                processed: Object.keys(deps.processed).length,
-                unprocessed: deps.unprocessed.length,
-            };
-        },
         toJSON: () => ({
             id,
             name,
@@ -229,7 +47,7 @@ export function createFlowJobObject(id, name, data, queueName, callbacks) {
             opts: {},
             progress: 0,
             delay: 0,
-            timestamp: ts,
+            timestamp,
             attemptsMade: 0,
             stacktrace: null,
             queueQualifiedName: `bull:${queueName}`,
@@ -241,153 +59,66 @@ export function createFlowJobObject(id, name, data, queueName, callbacks) {
             opts: '{}',
             progress: '0',
             delay: '0',
-            timestamp: String(ts),
+            timestamp: String(timestamp),
             attemptsMade: '0',
             stacktrace: null,
         }),
-        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)
-                return await getSharedManager().moveActiveToWait(jobId(id));
-            if (!tcp)
-                return false;
-            const res = await tcp.send({ cmd: 'MoveToWait', id });
-            return res.ok === true;
-        },
-        moveToDelayed: async (timestamp) => {
-            const delay = Math.max(0, timestamp - 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));
-            throw new Error('moveToWaitingChildren is not supported in TCP mode — no server command available');
-        },
-        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: () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available')),
-        removeUnprocessedChildren: async () => {
-            if (embedded) {
-                await getSharedManager().removeUnprocessedChildren(jobId(id));
-                return;
-            }
-            if (tcp)
-                await tcp.send({ cmd: 'RemoveUnprocessedChildren', id });
-        },
     };
 }
-async function fetchChildIds(id, embedded, tcp) {
-    if (embedded) {
-        const job = await getSharedManager().getJob(jobId(id));
-        return (job?.childrenIds ?? []).map(String);
+/** Extract user data while removing internal flow metadata and the stored job name. */
+export function extractUserDataFromInternal(data) {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (!key.startsWith('__') && key !== 'name')
+            result[key] = value;
     }
-    if (!tcp)
-        return [];
-    const jobRes = await tcp.send({ cmd: 'GetJob', id });
-    const parent = jobRes.job;
-    return (parent?.childrenIds ?? []).map(String);
+    return result;
 }
-async function computeDepsFlow(queueName, childIds, embedded, tcp) {
-    const processed = {};
-    const unprocessed = [];
-    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 };
+/** Create a Job object for a newly committed or fetched flow node. */
+export function createFlowJobObject(id, name, data, queueName, factoryOptions = {}) {
+    const { callbacks, snapshot } = factoryOptions;
+    const timestamp = Date.now();
+    const runtime = {
+        id,
+        queueName,
+        callbacks,
+        embedded: callbacks?.embedded === true,
+        tcp: callbacks?.tcp ?? null,
+        getState: buildStateResolver(id, callbacks),
+    };
+    const result = {
+        id,
+        name,
+        data,
+        queueName,
+        attemptsMade: 0,
+        timestamp,
+        progress: 0,
+        delay: 0,
+        processedOn: undefined,
+        finishedOn: undefined,
+        stacktrace: null,
+        stalledCounter: 0,
+        priority: 0,
+        parentKey: undefined,
+        opts: {},
+        token: undefined,
+        processedBy: undefined,
+        deduplicationId: undefined,
+        repeatJobKey: undefined,
+        attemptsStarted: 0,
+        ...buildFlowJobCoreMethods(runtime),
+        ...defaultSerialization(id, name, data, queueName, timestamp),
+        ...buildFlowJobMoveMethods(runtime),
+    };
+    if (!snapshot)
+        return result;
+    const options = buildJobOpts(snapshot);
+    Object.assign(result, buildJobProperties(snapshot, name), { data, opts: options });
+    const serialization = buildSerializationMethods(snapshot, id, name, options);
+    Object.assign(result, {
+        toJSON: () => ({ ...serialization.toJSON(), data }),
+        asJSON: () => ({ ...serialization.asJSON(), data: JSON.stringify(data) }),
+    });
+    return result;
 }

package/dist/client/flowJobMoveMethods.d.ts

@@ -0,0 +1,16 @@
+import { type FlowJobRuntime } from './flowJobTypes';
+/** Lifecycle and failure-inspection methods exposed by a FlowProducer Job. */
+export declare function buildFlowJobMoveMethods(runtime: FlowJobRuntime): {
+    moveToCompleted: (returnValue: unknown) => Promise<null>;
+    moveToFailed: (error: Error) => Promise<void>;
+    moveToWait: () => Promise<boolean>;
+    moveToDelayed: (timestamp: number) => Promise<undefined>;
+    moveToWaitingChildren: () => Promise<boolean>;
+    waitUntilFinished: (_queueEvents: unknown, ttl?: number) => Promise<unknown>;
+    discard: () => void;
+    getFailedChildrenValues: () => Promise<Record<string, string>>;
+    getIgnoredChildrenFailures: () => Promise<Record<string, string>>;
+    removeChildDependency: () => Promise<boolean>;
+    removeDeduplicationKey: () => Promise<boolean>;
+    removeUnprocessedChildren: () => Promise<undefined>;
+};

package/dist/client/flowJobMoveMethods.js

@@ -0,0 +1,112 @@
+import { jobId } from '../domain/types/job';
+import { getSharedManager } from './manager';
+import { buildFailCommand, failEmbeddedArgs } from './queue/failWire';
+import { assertFlowTcpOk } from './flowJobTypes';
+/** Lifecycle and failure-inspection methods exposed by a FlowProducer Job. */
+export function buildFlowJobMoveMethods(runtime) {
+    const { id, embedded, tcp } = runtime;
+    return {
+        moveToCompleted: async (returnValue) => {
+            if (embedded) {
+                await getSharedManager().ack(jobId(id), returnValue);
+                return null;
+            }
+            if (tcp)
+                assertFlowTcpOk(await tcp.send({ cmd: 'ACK', id, result: returnValue }), 'ACK');
+            return null;
+        },
+        moveToFailed: async (error) => {
+            if (embedded) {
+                await getSharedManager().fail(jobId(id), ...failEmbeddedArgs(error));
+                return;
+            }
+            if (tcp)
+                assertFlowTcpOk(await tcp.send(buildFailCommand(id, error)), 'FAIL');
+        },
+        moveToWait: async () => {
+            if (embedded)
+                return getSharedManager().moveActiveToWait(jobId(id));
+            if (!tcp)
+                return false;
+            assertFlowTcpOk(await tcp.send({ cmd: 'MoveToWait', id }), 'MoveToWait');
+            return true;
+        },
+        moveToDelayed: async (timestamp) => {
+            const delay = Math.max(0, timestamp - Date.now());
+            if (embedded)
+                return void (await getSharedManager().moveToDelayed(jobId(id), delay));
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'MoveToDelayed', id, delay }), 'MoveToDelayed');
+        },
+        moveToWaitingChildren: async () => {
+            if (embedded)
+                return getSharedManager().moveToWaitingChildren(jobId(id));
+            throw new Error('moveToWaitingChildren is not supported in TCP mode — no server command available');
+        },
+        waitUntilFinished: async (_queueEvents, ttl) => {
+            const timeout = ttl ?? 30_000;
+            if (embedded) {
+                const manager = getSharedManager();
+                const job = await manager.getJob(jobId(id));
+                if (!job)
+                    throw new Error(`Job ${id} not found`);
+                if (job.completedAt)
+                    return manager.getResult(jobId(id));
+                if (!(await manager.waitForJobCompletion(jobId(id), timeout))) {
+                    throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+                }
+                return manager.getResult(jobId(id));
+            }
+            if (!tcp)
+                throw new Error('waitUntilFinished: no connection');
+            const response = await tcp.send({ cmd: 'WaitJob', id, timeout });
+            assertFlowTcpOk(response, 'WaitJob');
+            const typed = response;
+            if (!typed.completed)
+                throw new Error(`waitUntilFinished timed out after ${timeout}ms`);
+            return typed.result;
+        },
+        discard: () => {
+            if (embedded)
+                void getSharedManager().discard(jobId(id));
+            else if (tcp)
+                void tcp.send({ cmd: 'Discard', id });
+        },
+        getFailedChildrenValues: async () => {
+            if (embedded)
+                return getSharedManager().getFailedChildrenValues(jobId(id));
+            if (!tcp)
+                return {};
+            const response = await tcp.send({ cmd: 'GetFailedChildrenValues', id });
+            assertFlowTcpOk(response, 'GetFailedChildrenValues');
+            return response.values ?? {};
+        },
+        getIgnoredChildrenFailures: async () => {
+            if (embedded)
+                return getSharedManager().getIgnoredChildrenFailures(jobId(id));
+            if (!tcp)
+                return {};
+            const response = await tcp.send({ cmd: 'GetIgnoredChildrenFailures', id });
+            assertFlowTcpOk(response, 'GetIgnoredChildrenFailures');
+            return response.values ?? {};
+        },
+        removeChildDependency: async () => {
+            if (embedded)
+                return getSharedManager().removeChildDependency(jobId(id));
+            if (!tcp)
+                return false;
+            const response = await tcp.send({ cmd: 'RemoveChildDependency', id });
+            assertFlowTcpOk(response, 'RemoveChildDependency');
+            return response.removed ?? false;
+        },
+        removeDeduplicationKey: () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available')),
+        removeUnprocessedChildren: async () => {
+            if (embedded)
+                return void (await getSharedManager().removeUnprocessedChildren(jobId(id)));
+            if (!tcp)
+                return;
+            assertFlowTcpOk(await tcp.send({ cmd: 'RemoveUnprocessedChildren', id }), 'RemoveUnprocessedChildren');
+        },
+    };
+}

package/dist/client/flowJobTypes.d.ts

@@ -0,0 +1,29 @@
+import type { JobStateType } from './types';
+import type { TcpConnectionPool } from './tcpPool';
+/** Callbacks used to wire FlowProducer Job mutations to the selected transport. */
+export interface FlowJobCallbacks {
+    embedded?: boolean;
+    tcp?: TcpConnectionPool | null;
+    updateData?: (id: string, data: unknown) => Promise<void>;
+    updateProgress?: (id: string, progress: number | object) => Promise<void>;
+    log?: (id: string, message: string) => Promise<void>;
+    promote?: (id: string) => Promise<void>;
+    remove?: (id: string) => Promise<void>;
+    changePriority?: (id: string, opts: {
+        priority: number;
+        lifo?: boolean;
+    }) => Promise<void>;
+    changeDelay?: (id: string, delay: number) => Promise<void>;
+    clearLogs?: (id: string, keepLogs?: number) => Promise<void>;
+    retry?: (id: string) => Promise<void>;
+    getState?: (id: string) => Promise<string>;
+}
+export interface FlowJobRuntime {
+    id: string;
+    queueName: string;
+    callbacks?: FlowJobCallbacks;
+    embedded: boolean;
+    tcp: TcpConnectionPool | null;
+    getState: () => Promise<JobStateType>;
+}
+export declare function assertFlowTcpOk(response: Record<string, unknown>, operation: string): void;