bunqueue 2.8.60 → 2.9.2

package/dist/infrastructure/cloud/commands/jobs.js

@@ -1,16 +1,21 @@
 import { jobId } from '../../../domain/types/job';
 import { mapCloudCommandJob } from './jobMapper';
+function pageInteger(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value)));
+}
 export const JOB_COMMANDS = {
-    'job:cancel': async (queueManager, command) => {
-        const ok = await queueManager.cancel(jobId(command.jobId ?? ''));
+    'job:cancel': async (adapter, command) => {
+        const ok = await adapter.cancel(jobId(command.jobId ?? ''));
         return { cancelled: ok };
     },
-    'job:promote': async (queueManager, command) => {
-        const ok = await queueManager.promote(jobId(command.jobId ?? ''));
+    'job:promote': async (adapter, command) => {
+        const ok = await adapter.promote(jobId(command.jobId ?? ''));
         return { promoted: ok };
     },
-    'job:push': async (queueManager, command) => {
-        const job = await queueManager.push(command.queue ?? '', {
+    'job:push': async (adapter, command) => {
+        const job = await adapter.push(command.queue ?? '', {
             name: command.name ?? 'default',
             data: command.data ?? {},
             priority: command.priority,
@@ -18,80 +23,83 @@ export const JOB_COMMANDS = {
         });
         return { jobId: String(job.id), queue: command.queue };
     },
-    'job:priority': async (queueManager, command) => {
-        const ok = await queueManager.changePriority(jobId(command.jobId ?? ''), command.priority ?? 0);
+    'job:priority': async (adapter, command) => {
+        const ok = await adapter.changePriority(jobId(command.jobId ?? ''), command.priority ?? 0);
         return { changed: ok };
     },
-    'job:discard': async (queueManager, command) => {
-        const ok = await queueManager.discard(jobId(command.jobId ?? ''));
+    'job:discard': async (adapter, command) => {
+        const ok = await adapter.discard(jobId(command.jobId ?? ''));
         return { discarded: ok };
     },
-    'job:delay': async (queueManager, command) => {
-        await queueManager.changeDelay(jobId(command.jobId ?? ''), command.delay ?? 0);
+    'job:delay': async (adapter, command) => {
+        await adapter.changeDelay(jobId(command.jobId ?? ''), command.delay ?? 0);
         return { delayed: true };
     },
-    'job:updateData': async (queueManager, command) => {
-        const ok = await queueManager.updateJobData(jobId(command.jobId ?? ''), command.data);
+    'job:updateData': async (adapter, command) => {
+        const ok = await adapter.updateData(jobId(command.jobId ?? ''), command.data);
         return { updated: ok };
     },
-    'job:clearLogs': (queueManager, command) => {
-        queueManager.clearLogs(jobId(command.jobId ?? ''), command.keepLogs);
+    'job:clearLogs': async (adapter, command) => {
+        await adapter.clearLogs(jobId(command.jobId ?? ''), command.keepLogs);
         return { cleared: true };
     },
-    'job:retry': (queueManager, command) => {
+    'job:retry': async (adapter, command) => {
         if (command.queue) {
-            const count = queueManager.retryDlq(command.queue, command.jobId ? jobId(command.jobId) : undefined);
+            const count = await adapter.retryDlq(command.queue, command.jobId ? jobId(command.jobId) : undefined);
             return { retried: count };
         }
         return { retried: 0 };
     },
-    'job:logs': (queueManager, command) => ({
-        logs: queueManager.getLogs(jobId(command.jobId ?? '')),
+    'job:logs': async (adapter, command) => ({
+        logs: await adapter.getLogs(jobId(command.jobId ?? '')),
     }),
-    'job:result': (queueManager, command) => ({
-        result: queueManager.getResult(jobId(command.jobId ?? '')) ?? null,
+    'job:result': async (adapter, command) => ({
+        result: await adapter.getResult(jobId(command.jobId ?? '')),
     }),
-    'job:list': (queueManager, command) => {
-        const limit = command.limit ?? 50;
-        const offset = command.offset ?? 0;
+    'job:list': async (adapter, command) => {
+        const limit = pageInteger(command.limit, 50);
+        const offset = pageInteger(command.offset, 0);
+        const end = Math.min(Number.MAX_SAFE_INTEGER, offset + limit);
         const states = command.state
             ? command.state.split(',')
             : ['waiting', 'active', 'delayed', 'completed', 'failed'];
-        const jobs = queueManager.getJobs(command.queue ?? '', {
+        const jobs = await adapter.listJobs(command.queue ?? '', {
             state: states,
             start: offset,
-            end: offset + limit - 1,
+            end,
         });
+        const source = await adapter.readSnapshotSource();
+        const counts = source.queues.find(({ name }) => name === (command.queue ?? ''))?.counts;
         return {
             jobs: jobs.map(mapCloudCommandJob),
-            total: queueManager.count(command.queue ?? ''),
+            total: (counts?.waiting ?? 0) + (counts?.prioritized ?? 0) + (counts?.delayed ?? 0),
             offset,
             limit,
         };
     },
-    'job:get': async (queueManager, command) => {
+    'job:get': async (adapter, command) => {
         const id = jobId(command.jobId ?? '');
-        const job = await queueManager.getJob(id);
+        const job = await adapter.getJob(id);
         if (!job)
             return { job: null };
         return {
             job: {
                 ...mapCloudCommandJob(job),
-                logs: queueManager.getLogs(id),
-                result: queueManager.getResult(id) ?? null,
+                logs: await adapter.getLogs(id),
+                result: await adapter.getResult(id),
             },
         };
     },
-    'job:listAll': (queueManager, command) => {
+    'job:listAll': async (adapter, command) => {
         const limit = command.limit ?? 50;
         const offset = command.offset ?? 0;
         const states = command.state
             ? command.state.split(',')
             : ['waiting', 'active', 'delayed', 'completed', 'failed'];
         const allJobs = [];
-        for (const name of queueManager.listQueues()) {
-            const jobs = queueManager.getJobs(name, { state: states, start: 0, end: 999 });
-            for (const job of jobs)
+        const source = await adapter.readSnapshotSource();
+        for (const { job, state } of source.jobs) {
+            if (states.includes(state))
                 allJobs.push(mapCloudCommandJob(job));
         }
         allJobs.sort((a, b) => b.timestamp - a.timestamp);
@@ -102,10 +110,10 @@ export const JOB_COMMANDS = {
             limit,
         };
     },
-    'dlq:retry': (queueManager, command) => ({
-        retried: queueManager.retryDlq(command.queue ?? '', command.jobId ? jobId(command.jobId) : undefined),
+    'dlq:retry': async (adapter, command) => ({
+        retried: await adapter.retryDlq(command.queue ?? '', command.jobId ? jobId(command.jobId) : undefined),
     }),
-    'dlq:purge': (queueManager, command) => ({
-        purged: queueManager.purgeDlq(command.queue ?? ''),
+    'dlq:purge': async (adapter, command) => ({
+        purged: await adapter.purgeDlq(command.queue ?? ''),
     }),
 };

package/dist/infrastructure/cloud/commands/queues.js

@@ -1,94 +1,94 @@
+import { DEFAULT_DLQ_CONFIG } from '../../../domain/types/dlq';
+import { DEFAULT_STALL_CONFIG } from '../../../domain/types/stall';
 import { mapCloudCommandJob } from './jobMapper';
 export const QUEUE_COMMANDS = {
-    'queue:pause': (queueManager, command) => {
-        queueManager.pause(command.queue ?? '');
+    'queue:pause': async (adapter, command) => {
+        await adapter.pause(command.queue ?? '', true);
         return { queue: command.queue, paused: true };
     },
-    'queue:resume': (queueManager, command) => {
-        queueManager.resume(command.queue ?? '');
+    'queue:resume': async (adapter, command) => {
+        await adapter.pause(command.queue ?? '', false);
         return { queue: command.queue, paused: false };
     },
-    'queue:drain': (queueManager, command) => {
-        const count = queueManager.drain(command.queue ?? '');
+    'queue:drain': async (adapter, command) => {
+        const count = await adapter.drain(command.queue ?? '');
         return { queue: command.queue, drained: count };
     },
-    'queue:clean': (queueManager, command) => {
-        const ids = queueManager.clean(command.queue ?? '', command.graceMs ?? 0, command.state, command.limit);
+    'queue:clean': async (adapter, command) => {
+        const ids = await adapter.clean(command.queue ?? '', command.graceMs ?? 0, command.state, command.limit);
         return { queue: command.queue, cleaned: ids.length, ids };
     },
-    'queue:obliterate': (queueManager, command) => {
-        queueManager.obliterate(command.queue ?? '');
+    'queue:obliterate': async (adapter, command) => {
+        await adapter.obliterate(command.queue ?? '');
         return { queue: command.queue, obliterated: true };
     },
-    'queue:promoteAll': async (queueManager, command) => {
+    'queue:promoteAll': async (adapter, command) => {
         const limit = command.limit ?? 1000;
-        const jobs = queueManager.getJobs(command.queue ?? '', {
-            state: ['delayed'],
-            start: 0,
-            end: limit - 1,
-        });
-        let promoted = 0;
-        for (const job of jobs) {
-            try {
-                await queueManager.promote(job.id);
-                promoted++;
-            }
-            catch {
-                // Skip jobs that can no longer be promoted.
-            }
-        }
+        const promoted = await adapter.promoteAll(command.queue ?? '', limit);
         return { queue: command.queue, promoted };
     },
-    'queue:retryCompleted': (queueManager, command) => {
-        const count = queueManager.retryCompleted(command.queue ?? '');
+    'queue:retryCompleted': async (adapter, command) => {
+        const count = await adapter.retryCompleted(command.queue ?? '');
         return { queue: command.queue, retried: count };
     },
-    'queue:rateLimit': (queueManager, command) => {
-        queueManager.setRateLimit(command.queue ?? '', command.max ?? 100);
+    'queue:rateLimit': async (adapter, command) => {
+        await adapter.setRateLimit(command.queue ?? '', command.max ?? 100);
         return { queue: command.queue, rateLimit: command.max ?? 100 };
     },
-    'queue:clearRateLimit': (queueManager, command) => {
-        queueManager.clearRateLimit(command.queue ?? '');
+    'queue:clearRateLimit': async (adapter, command) => {
+        await adapter.setRateLimit(command.queue ?? '', null);
         return { queue: command.queue, rateLimit: null };
     },
-    'queue:concurrency': (queueManager, command) => {
-        queueManager.setConcurrency(command.queue ?? '', command.concurrency ?? 10);
+    'queue:concurrency': async (adapter, command) => {
+        await adapter.setConcurrency(command.queue ?? '', command.concurrency ?? 10);
         return { queue: command.queue, concurrency: command.concurrency ?? 10 };
     },
-    'queue:clearConcurrency': (queueManager, command) => {
-        queueManager.clearConcurrency(command.queue ?? '');
+    'queue:clearConcurrency': async (adapter, command) => {
+        await adapter.setConcurrency(command.queue ?? '', null);
         return { queue: command.queue, concurrency: null };
     },
-    'queue:stallConfig': (queueManager, command) => {
-        queueManager.setStallConfig(command.queue ?? '', command.config ?? {});
+    'queue:stallConfig': async (adapter, command) => {
+        await adapter.setStallConfig(command.queue ?? '', command.config ?? {});
         return { queue: command.queue, stallConfig: command.config };
     },
-    'queue:dlqConfig': (queueManager, command) => {
-        queueManager.setDlqConfig(command.queue ?? '', command.config ?? {});
+    'queue:dlqConfig': async (adapter, command) => {
+        await adapter.setDlqConfig(command.queue ?? '', command.config ?? {});
         return { queue: command.queue, dlqConfig: command.config };
     },
-    'queue:detail': (queueManager, command) => {
+    'queue:detail': async (adapter, command) => {
         const queue = command.queue ?? '';
-        const counts = queueManager.getQueueJobCounts(queue);
-        const paused = queueManager.isPaused(queue);
-        const stallConfig = queueManager.getStallConfig(queue);
-        const dlqConfig = queueManager.getDlqConfig(queue);
-        const dlqEntries = queueManager.getDlqEntries(queue).slice(0, 50);
-        const jobs = queueManager.getJobs(queue, {
+        const source = await adapter.readSnapshotSource([queue]);
+        const view = source.queues.find(({ name }) => name === queue);
+        const counts = view?.counts ?? {
+            waiting: 0,
+            prioritized: 0,
+            delayed: 0,
+            active: 0,
+            completed: 0,
+            failed: 0,
+            'waiting-children': 0,
+            totalCompleted: 0,
+            totalFailed: 0,
+        };
+        const dlqEntries = source.dlqEntries.filter((entry) => entry.job.queue === queue).slice(0, 50);
+        const jobs = await adapter.listJobs(queue, {
             state: ['waiting', 'active', 'delayed', 'completed', 'failed'],
             start: 0,
-            end: 49,
+            end: 50,
         });
         return {
             queue,
-            paused,
+            paused: view?.paused ?? false,
             counts,
             stallConfig: {
-                enabled: stallConfig.enabled,
-                stallInterval: stallConfig.stallInterval,
-                maxStalls: stallConfig.maxStalls,
+                enabled: view?.stallConfig.enabled ?? DEFAULT_STALL_CONFIG.enabled,
+                stallInterval: view?.stallConfig.stallInterval ?? DEFAULT_STALL_CONFIG.stallInterval,
+                maxStalls: view?.stallConfig.maxStalls ?? DEFAULT_STALL_CONFIG.maxStalls,
+            },
+            dlqConfig: {
+                maxRetries: view?.dlqConfig.maxAutoRetries ?? DEFAULT_DLQ_CONFIG.maxAutoRetries,
+                maxAge: view?.dlqConfig.maxAge ?? DEFAULT_DLQ_CONFIG.maxAge ?? 0,
             },
-            dlqConfig: { maxRetries: dlqConfig.maxAutoRetries, maxAge: dlqConfig.maxAge ?? 0 },
             dlqEntries: dlqEntries.map((entry) => ({
                 jobId: String(entry.job.id),
                 reason: entry.reason,
@@ -99,28 +99,14 @@ export const QUEUE_COMMANDS = {
             jobs: jobs.map(mapCloudCommandJob),
         };
     },
-    'queue:list': (queueManager) => {
-        const queueNames = queueManager.listQueues();
-        const countsByQueue = queueManager.getAllQueueJobCounts();
-        const queues = queueNames.flatMap((name) => {
-            const counts = countsByQueue.get(name);
-            if (!counts)
-                return [];
-            return {
-                name,
-                waiting: counts.waiting,
-                prioritized: counts.prioritized,
-                delayed: counts.delayed,
-                active: counts.active,
-                completed: counts.completed,
-                failed: counts.failed,
-                'waiting-children': counts['waiting-children'],
-                paused: queueManager.isPaused(name),
-                totalCompleted: counts.totalCompleted,
-                totalFailed: counts.totalFailed,
-            };
-        });
+    'queue:list': async (adapter) => {
+        const source = await adapter.readSnapshotSource();
+        const queues = source.queues.map(({ name, counts, paused }) => ({
+            name,
+            ...counts,
+            paused,
+        }));
         return { queues };
     },
-    'stats:refresh': (queueManager) => queueManager.getStats(),
+    'stats:refresh': async (adapter) => (await adapter.readSnapshotSource()).stats,
 };

package/dist/infrastructure/cloud/queueAdapter/local.d.ts

@@ -0,0 +1,41 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CronJobInput } from '../../../domain/types/cron';
+import type { JobId } from '../../../domain/types/job';
+import type { CloudQueueAdapter, CloudSnapshotSource } from './types';
+/** SQLite/local Cloud strategy; delegates to the existing synchronous semantics. */
+export declare class LocalCloudQueueAdapter implements CloudQueueAdapter {
+    readonly manager: QueueManager;
+    constructor(manager: QueueManager);
+    pause(queue: string, paused: boolean): Promise<void>;
+    drain(queue: string): Promise<number>;
+    clean(queue: string, graceMs: number, state?: string, limit?: number): Promise<JobId[]>;
+    obliterate(queue: string): Promise<void>;
+    promoteAll(queue: string, limit: number): Promise<number>;
+    retryCompleted(queue: string): Promise<number>;
+    setRateLimit(queue: string, limit: number | null): Promise<void>;
+    setConcurrency(queue: string, limit: number | null): Promise<void>;
+    setStallConfig(queue: string, patch: Record<string, unknown>): Promise<void>;
+    setDlqConfig(queue: string, patch: Record<string, unknown>): Promise<void>;
+    listJobs(queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Promise<import("../../../domain/types").Job[]>;
+    getJob(id: JobId): Promise<import("../../../domain/types").Job | null>;
+    getLogs(id: JobId): Promise<import("../../../domain/types/worker").JobLogEntry[]>;
+    getResult(id: JobId): Promise<unknown>;
+    clearLogs(id: JobId, keepLogs?: number): Promise<void>;
+    retryDlq(queue: string, id?: JobId): Promise<number>;
+    purgeDlq(queue: string): Promise<number>;
+    push(queue: string, input: Parameters<QueueManager['push']>[1]): Promise<import("../../../domain/types").Job>;
+    cancel(id: JobId): Promise<boolean>;
+    promote(id: JobId): Promise<boolean>;
+    changePriority(id: JobId, priority: number): Promise<boolean>;
+    discard(id: JobId): Promise<boolean>;
+    changeDelay(id: JobId, delay: number): Promise<boolean>;
+    updateData(id: JobId, data: unknown): Promise<boolean>;
+    addCron(input: CronJobInput): Promise<import("../../../domain/types").CronJob>;
+    removeCron(name: string): Promise<boolean>;
+    readSnapshotSource(requestedQueues?: readonly string[]): Promise<CloudSnapshotSource>;
+}

package/dist/infrastructure/cloud/queueAdapter/local.js

@@ -0,0 +1,187 @@
+const SNAPSHOT_STATES = [
+    'waiting',
+    'active',
+    'delayed',
+    'failed',
+    'completed',
+    'prioritized',
+    'paused',
+    'waiting-children',
+];
+/** SQLite/local Cloud strategy; delegates to the existing synchronous semantics. */
+export class LocalCloudQueueAdapter {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    pause(queue, paused) {
+        if (paused)
+            this.manager.pause(queue);
+        else
+            this.manager.resume(queue);
+        return Promise.resolve();
+    }
+    drain(queue) {
+        return Promise.resolve(this.manager.drain(queue));
+    }
+    clean(queue, graceMs, state, limit) {
+        return Promise.resolve(this.manager.clean(queue, graceMs, state, limit));
+    }
+    obliterate(queue) {
+        this.manager.obliterate(queue);
+        return Promise.resolve();
+    }
+    async promoteAll(queue, limit) {
+        const jobs = this.manager.getJobs(queue, { state: ['delayed'], start: 0, end: limit });
+        let promoted = 0;
+        for (const job of jobs) {
+            try {
+                if (await this.manager.promote(job.id))
+                    promoted++;
+            }
+            catch {
+                // The job may have moved since the command selected it.
+            }
+        }
+        return promoted;
+    }
+    retryCompleted(queue) {
+        return Promise.resolve(this.manager.retryCompleted(queue));
+    }
+    setRateLimit(queue, limit) {
+        if (limit === null)
+            this.manager.clearRateLimit(queue);
+        else
+            this.manager.setRateLimit(queue, limit);
+        return Promise.resolve();
+    }
+    setConcurrency(queue, limit) {
+        if (limit === null)
+            this.manager.clearConcurrency(queue);
+        else
+            this.manager.setConcurrency(queue, limit);
+        return Promise.resolve();
+    }
+    setStallConfig(queue, patch) {
+        this.manager.setStallConfig(queue, patch);
+        return Promise.resolve();
+    }
+    setDlqConfig(queue, patch) {
+        this.manager.setDlqConfig(queue, patch);
+        return Promise.resolve();
+    }
+    listJobs(queue, options = {}) {
+        return Promise.resolve(this.manager.getJobs(queue, options));
+    }
+    async getJob(id) {
+        return await this.manager.getJob(id);
+    }
+    getLogs(id) {
+        return Promise.resolve(this.manager.getLogs(id));
+    }
+    getResult(id) {
+        return Promise.resolve(this.manager.getResult(id) ?? null);
+    }
+    clearLogs(id, keepLogs) {
+        this.manager.clearLogs(id, keepLogs);
+        return Promise.resolve();
+    }
+    retryDlq(queue, id) {
+        return Promise.resolve(this.manager.retryDlq(queue, id));
+    }
+    purgeDlq(queue) {
+        return Promise.resolve(this.manager.purgeDlq(queue));
+    }
+    async push(queue, input) {
+        return await this.manager.push(queue, input);
+    }
+    async cancel(id) {
+        return await this.manager.cancel(id);
+    }
+    async promote(id) {
+        return await this.manager.promote(id);
+    }
+    async changePriority(id, priority) {
+        return await this.manager.changePriority(id, priority);
+    }
+    async discard(id) {
+        return await this.manager.discard(id);
+    }
+    async changeDelay(id, delay) {
+        return await this.manager.changeDelay(id, delay);
+    }
+    async updateData(id, data) {
+        return await this.manager.updateJobData(id, data);
+    }
+    addCron(input) {
+        return Promise.resolve(this.manager.addCron(input));
+    }
+    removeCron(name) {
+        return Promise.resolve(this.manager.removeCron(name));
+    }
+    readSnapshotSource(requestedQueues = []) {
+        const queueNames = new Set([...this.manager.listQueues(), ...requestedQueues]);
+        const counts = this.manager.getQueueJobCountsBatch(queueNames);
+        const queues = [];
+        const jobs = [];
+        const dlqEntries = [];
+        for (const name of queueNames) {
+            try {
+                const queueCounts = counts.get(name);
+                if (!queueCounts)
+                    continue;
+                const limits = this.manager.getQueueLimits(name);
+                queues.push({
+                    name,
+                    counts: queueCounts,
+                    paused: this.manager.isPaused(name),
+                    rateLimit: limits.rateLimit,
+                    concurrencyLimit: limits.concurrencyLimit,
+                    stallConfig: this.manager.getStallConfig(name),
+                    dlqConfig: this.manager.getDlqConfig(name),
+                });
+            }
+            catch {
+                // Preserve the local collector's per-queue best-effort behavior.
+            }
+            for (const state of SNAPSHOT_STATES) {
+                try {
+                    for (const job of this.manager.getJobs(name, { state: [state], start: 0, end: 1000 })) {
+                        jobs.push({ job, state });
+                    }
+                }
+                catch {
+                    // Preserve the local collector's per-state best-effort behavior.
+                }
+            }
+            try {
+                dlqEntries.push(...this.manager.getDlqEntries(name));
+            }
+            catch {
+                // Preserve the local collector's per-queue best-effort behavior.
+            }
+        }
+        const jobResults = new Map();
+        for (const [id, result] of this.manager.getAllJobResults()) {
+            jobResults.set(String(id), result);
+        }
+        const jobLogs = new Map();
+        for (const [id, logs] of this.manager.getAllJobLogs())
+            jobLogs.set(String(id), logs);
+        return Promise.resolve({
+            stats: this.manager.getStats(),
+            queues,
+            jobs,
+            dlqEntries,
+            workers: this.manager.workerManager.list(),
+            workerStats: this.manager.workerManager.getStats(),
+            crons: this.manager.listCrons(),
+            jobResults,
+            jobLogs,
+            activeLocks: [...this.manager.getAllJobLocks().values()].map((lock) => ({
+                ...lock,
+                jobId: String(lock.jobId),
+            })),
+        });
+    }
+}

package/dist/infrastructure/cloud/queueAdapter/postgres.d.ts

@@ -0,0 +1,42 @@
+import { PostgresQueueManager } from '../../../application/postgresQueueManager';
+import type { CronJobInput } from '../../../domain/types/cron';
+import type { JobId } from '../../../domain/types/job';
+import type { CloudQueueAdapter, CloudSnapshotSource } from './types';
+/** PostgreSQL Cloud strategy; every shared surface goes through durable APIs. */
+export declare class PostgresCloudQueueAdapter implements CloudQueueAdapter {
+    readonly manager: PostgresQueueManager;
+    constructor(manager: PostgresQueueManager);
+    pause: (queue: string, paused: boolean) => Promise<void>;
+    drain: (queue: string) => Promise<number>;
+    clean: (queue: string, graceMs: number, state?: string, limit?: number) => Promise<JobId[]>;
+    obliterate: (queue: string) => Promise<void>;
+    promoteAll: (queue: string, limit: number) => Promise<number>;
+    retryCompleted: (queue: string) => Promise<number>;
+    setRateLimit: (queue: string, limit: number | null) => Promise<void>;
+    setConcurrency: (queue: string, limit: number | null) => Promise<void>;
+    setStallConfig: (queue: string, patch: Record<string, unknown>) => Promise<void>;
+    setDlqConfig: (queue: string, patch: Record<string, unknown>) => Promise<void>;
+    listJobs: (queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }) => Promise<import("../../../domain/types").Job[]>;
+    getJob: (id: JobId) => Promise<import("../../../domain/types").Job | null>;
+    getLogs: (id: JobId) => Promise<import("../../../domain/types/worker").JobLogEntry[]>;
+    getResult: (id: JobId) => Promise<unknown>;
+    clearLogs: (id: JobId, keepLogs?: number) => Promise<void>;
+    retryDlq: (queue: string, id?: JobId) => Promise<number>;
+    purgeDlq: (queue: string) => Promise<number>;
+    push: (queue: string, input: Parameters<PostgresQueueManager["push"]>[1]) => Promise<import("../../../domain/types").Job>;
+    cancel: (id: JobId) => Promise<boolean>;
+    promote: (id: JobId) => Promise<boolean>;
+    changePriority: (id: JobId, priority: number) => Promise<boolean>;
+    discard: (id: JobId) => Promise<boolean>;
+    changeDelay: (id: JobId, delay: number) => Promise<boolean>;
+    updateData: (id: JobId, data: unknown) => Promise<boolean>;
+    addCron: (input: CronJobInput) => Promise<import("../../../domain/types").CronJob>;
+    removeCron: (name: string) => Promise<boolean>;
+    readSnapshotSource(requestedQueues?: readonly string[]): Promise<CloudSnapshotSource>;
+    private toSnapshotSource;
+}