bunqueue 2.8.60 → 2.9.2

package/dist/application/postgres-queue-manager/queries.d.ts

@@ -0,0 +1,142 @@
+import { type DlqEntry, type DlqFilter, type DlqStats } from '../../domain/types/dlq';
+import type { Job, JobId } from '../../domain/types/job';
+import { PostgresQueueManagerGroupQueries } from './groupQueries';
+export declare class PostgresQueueManagerQueries extends PostgresQueueManagerGroupQueries {
+    getJobIndex(): Map<JobId, import("../../domain/types").JobLocation>;
+    getCompletedJobs(): Set<JobId>;
+    getDepCompletions(): Set<JobId>;
+    getJob(jobId: JobId): Promise<Job | null>;
+    getJobState(jobId: JobId): Promise<string>;
+    getResult(jobId: JobId): unknown;
+    getCompletionAsync(jobId: JobId): Promise<{
+        found: boolean;
+        result: unknown;
+    }>;
+    getResultAsync(jobId: JobId): Promise<unknown>;
+    waitForJobCompletion(jobId: JobId, timeoutMs: number): Promise<boolean>;
+    getChildrenValues(parentJobId: JobId): Promise<Record<string, unknown>>;
+    getJobByCustomId(customId: string): Job | null;
+    getProgress(jobId: JobId): {
+        progress: number;
+        message: string | null;
+    } | null;
+    getJobs(queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Job[];
+    count(queue: string): number;
+    listQueues(): string[];
+    getCountsPerPriority(queue: string): Record<number, number>;
+    getDlq(queue: string, count?: number): Job[];
+    getDlqEntries(queue: string, filter?: DlqFilter): DlqEntry[];
+    getDlqCount(queue: string): number;
+    getDlqStats(queue: string): DlqStats;
+    isPaused(queue: string): boolean;
+    isPausedDurable(queue: string): Promise<boolean>;
+    getQueueLimits(queue: string): {
+        rateLimit: number | null;
+        concurrencyLimit: number | null;
+    };
+    getQueueLimitStatus(queue: string, _maxJobs?: number): {
+        rateLimit: {
+            max: number;
+            duration: number;
+        } | null;
+        rateLimitTtl: number;
+        concurrencyLimit: number | null;
+        maxed: boolean;
+    };
+    getQueueJobCounts(queueName: string): {
+        waiting: number;
+        prioritized: number;
+        delayed: number;
+        active: number;
+        completed: number;
+        failed: number;
+        'waiting-children': number;
+        totalCompleted: number;
+        totalFailed: number;
+    };
+    getQueueJobCountsBatch(queueNames: Iterable<string>): Map<string, {
+        waiting: number;
+        prioritized: number;
+        delayed: number;
+        active: number;
+        completed: number;
+        failed: number;
+        'waiting-children': number;
+        totalCompleted: number;
+        totalFailed: number;
+    }>;
+    getAllQueueJobCounts(): Map<string, {
+        waiting: number;
+        prioritized: number;
+        delayed: number;
+        active: number;
+        completed: number;
+        failed: number;
+        'waiting-children': number;
+        totalCompleted: number;
+        totalFailed: number;
+    }>;
+    getPerQueueStats(): Map<string, {
+        waiting: number;
+        prioritized: number;
+        delayed: number;
+        active: number;
+        dlq: number;
+    }>;
+    getStats(): {
+        waiting: number;
+        prioritized: number;
+        delayed: number;
+        active: number;
+        dlq: number;
+        completed: number;
+        'waiting-children': number;
+        totalPushed: bigint;
+        totalPulled: bigint;
+        totalCompleted: bigint;
+        totalFailed: bigint;
+        uptime: number;
+        cronJobs: number;
+        cronPending: number;
+    };
+    getQueuesSummary(): {
+        name: string;
+        paused: boolean;
+        counts: {
+            waiting: number;
+            prioritized: number;
+            active: number;
+            completed: number;
+            failed: number;
+            delayed: number;
+        };
+    }[];
+    getStorageStatus(): {
+        diskFull: boolean;
+        error: string | null;
+        since: number | null;
+    };
+    getMemoryStats(): {
+        jobIndex: number;
+        completedJobs: number;
+        jobResults: number;
+        jobLogs: number;
+        customIdMap: number;
+        jobLocks: number;
+        clientJobs: number;
+        clientJobsTotal: number;
+        pendingDepChecks: number;
+        stalledCandidates: number;
+        processingTotal: number;
+        queuedTotal: number;
+        waitingDepsTotal: number;
+        temporalIndexTotal: number;
+        delayedHeapTotal: number;
+    };
+    flushPersistence(): number;
+}

package/dist/application/postgres-queue-manager/queries.js

@@ -0,0 +1,231 @@
+import { PostgresQueueManagerGroupQueries } from './groupQueries';
+function jobCounts(counts, totals) {
+    return {
+        waiting: counts.waiting,
+        prioritized: counts.prioritized,
+        delayed: counts.delayed,
+        active: counts.active,
+        completed: counts.completed,
+        failed: counts.failed,
+        'waiting-children': counts.waitingChildren,
+        totalCompleted: Number(totals?.totalCompleted ?? 0n),
+        totalFailed: Number(totals?.totalFailed ?? 0n),
+    };
+}
+export class PostgresQueueManagerQueries extends PostgresQueueManagerGroupQueries {
+    getJobIndex() {
+        return this.postgresSnapshot.locations();
+    }
+    getCompletedJobs() {
+        return this.postgresSnapshot.completedIds();
+    }
+    getDepCompletions() {
+        return this.postgresSnapshot.completionIds();
+    }
+    async getJob(jobId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const row = await this.fetchPostgresJob(jobId);
+            return row?.job ?? null;
+        });
+    }
+    async getJobState(jobId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const row = await this.fetchPostgresJob(jobId);
+            return row?.state ?? 'unknown';
+        });
+    }
+    getResult(jobId) {
+        return this.postgresSnapshot.getResult(jobId);
+    }
+    async getCompletionAsync(jobId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.getResult(jobId);
+        });
+    }
+    async getResultAsync(jobId) {
+        return (await this.getCompletionAsync(jobId)).result;
+    }
+    async waitForJobCompletion(jobId, timeoutMs) {
+        const controller = new AbortController();
+        const waiting = super.waitForJobCompletion(jobId, timeoutMs, controller.signal);
+        try {
+            const completed = (await this.getCompletionAsync(jobId)).found;
+            return completed || (await waiting);
+        }
+        finally {
+            controller.abort();
+        }
+    }
+    async getChildrenValues(parentJobId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.getChildrenValues(parentJobId);
+        });
+    }
+    getJobByCustomId(customId) {
+        return this.postgresSnapshot.getByCustomId(customId);
+    }
+    getProgress(jobId) {
+        const row = this.postgresSnapshot.get(jobId);
+        if (row?.state !== 'active')
+            return null;
+        return { progress: row.job.progress, message: row.job.progressMessage };
+    }
+    getJobs(queue, options = {}) {
+        return this.postgresSnapshot.list(queue, options);
+    }
+    count(queue) {
+        const counts = this.postgresSnapshot.counts(queue);
+        return counts.waiting + counts.prioritized + counts.delayed;
+    }
+    listQueues() {
+        return this.postgresSnapshot.queueNames();
+    }
+    getCountsPerPriority(queue) {
+        return this.postgresSnapshot.priorities(queue);
+    }
+    getDlq(queue, count) {
+        return this.postgresSnapshot
+            .dlq(queue, count === undefined ? undefined : { limit: count })
+            .map((entry) => entry.job);
+    }
+    getDlqEntries(queue, filter) {
+        return this.postgresSnapshot.dlq(queue, filter);
+    }
+    getDlqCount(queue) {
+        return this.postgresSnapshot.counts(queue).failed;
+    }
+    getDlqStats(queue) {
+        const entries = this.postgresSnapshot.dlq(queue);
+        const now = Date.now();
+        const byReason = {
+            ["explicit_fail" /* FailureReason.ExplicitFail */]: 0,
+            ["max_attempts_exceeded" /* FailureReason.MaxAttemptsExceeded */]: 0,
+            ["timeout" /* FailureReason.Timeout */]: 0,
+            ["stalled" /* FailureReason.Stalled */]: 0,
+            ["ttl_expired" /* FailureReason.TtlExpired */]: 0,
+            ["worker_lost" /* FailureReason.WorkerLost */]: 0,
+            ["unknown" /* FailureReason.Unknown */]: 0,
+        };
+        for (const entry of entries)
+            byReason[entry.reason]++;
+        return {
+            total: entries.length,
+            byReason,
+            byQueue: { [queue]: entries.length },
+            pendingRetry: entries.filter((entry) => entry.nextRetryAt !== null && entry.nextRetryAt <= now).length,
+            expired: entries.filter((entry) => entry.expiresAt !== null && entry.expiresAt <= now).length,
+            oldestEntry: entries.length === 0 ? null : Math.min(...entries.map((entry) => entry.enteredAt)),
+            newestEntry: entries.length === 0 ? null : Math.max(...entries.map((entry) => entry.enteredAt)),
+        };
+    }
+    isPaused(queue) {
+        return this.postgresSnapshot.queueState(queue)?.paused ?? false;
+    }
+    async isPausedDurable(queue) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return (await this.postgresStore.getQueueState(queue)).paused;
+        });
+    }
+    getQueueLimits(queue) {
+        const state = this.postgresSnapshot.queueState(queue);
+        const rateExpired = state?.rateExpiresAt !== null && (state?.rateExpiresAt ?? 0) <= Date.now();
+        return {
+            rateLimit: rateExpired ? null : (state?.rateLimit ?? null),
+            concurrencyLimit: state?.concurrencyLimit ?? null,
+        };
+    }
+    getQueueLimitStatus(queue, _maxJobs) {
+        const state = this.postgresSnapshot.queueState(queue);
+        const active = this.postgresSnapshot.counts(queue).active;
+        const concurrencyLimit = state?.concurrencyLimit ?? null;
+        const duration = state?.rateDurationMs ?? 1000;
+        const rateExpired = state?.rateExpiresAt !== null && (state?.rateExpiresAt ?? 0) <= Date.now();
+        const rateLimitTtl = state?.rateWindowStartedAt
+            ? Math.max(0, state.rateWindowStartedAt + duration - Date.now())
+            : 0;
+        return {
+            rateLimit: rateExpired || state?.rateLimit === null || state?.rateLimit === undefined
+                ? null
+                : { max: state.rateLimit, duration },
+            rateLimitTtl,
+            concurrencyLimit,
+            maxed: concurrencyLimit !== null && active >= concurrencyLimit,
+        };
+    }
+    getQueueJobCounts(queueName) {
+        return jobCounts(this.postgresSnapshot.counts(queueName), this.perQueueMetrics.get(queueName));
+    }
+    getQueueJobCountsBatch(queueNames) {
+        return new Map([...queueNames].map((queue) => [queue, this.getQueueJobCounts(queue)]));
+    }
+    getAllQueueJobCounts() {
+        return this.getQueueJobCountsBatch(this.listQueues());
+    }
+    getPerQueueStats() {
+        return new Map(this.listQueues().map((queue) => {
+            const counts = this.postgresSnapshot.counts(queue);
+            return [
+                queue,
+                {
+                    waiting: counts.waiting,
+                    prioritized: counts.prioritized,
+                    delayed: counts.delayed,
+                    active: counts.active,
+                    dlq: counts.failed,
+                },
+            ];
+        }));
+    }
+    getStats() {
+        const counts = this.postgresSnapshot.counts();
+        const cron = this.cronScheduler.getStats();
+        return {
+            waiting: counts.waiting,
+            prioritized: counts.prioritized,
+            delayed: counts.delayed,
+            active: counts.active,
+            dlq: counts.failed,
+            completed: counts.completed,
+            'waiting-children': counts.waitingChildren,
+            totalPushed: this.metrics.totalPushed.value,
+            totalPulled: this.metrics.totalPulled.value,
+            totalCompleted: this.metrics.totalCompleted.value,
+            totalFailed: this.metrics.totalFailed.value,
+            uptime: Date.now() - this.startTime,
+            cronJobs: cron.total,
+            cronPending: cron.pending,
+        };
+    }
+    getQueuesSummary() {
+        return this.listQueues().map((name) => {
+            const counts = this.postgresSnapshot.counts(name);
+            return {
+                name,
+                paused: this.isPaused(name),
+                counts: {
+                    waiting: counts.waiting,
+                    prioritized: counts.prioritized,
+                    active: counts.active,
+                    completed: counts.completed,
+                    failed: counts.failed,
+                    delayed: counts.delayed,
+                },
+            };
+        });
+    }
+    getStorageStatus() {
+        const health = this.postgresStore.health();
+        return { diskFull: false, error: health.error, since: health.since };
+    }
+    getMemoryStats() {
+        return { ...super.getMemoryStats(), jobIndex: this.postgresSnapshot.size() };
+    }
+    flushPersistence() {
+        return 0;
+    }
+}

package/dist/application/postgres-queue-manager/relationships.d.ts

@@ -0,0 +1,10 @@
+import type { JobId } from '../../domain/types/job';
+import { PostgresQueueManagerLease } from './lease';
+/** PostgreSQL-backed parent/child relationship mutations. */
+export declare class PostgresQueueManagerRelationships extends PostgresQueueManagerLease {
+    getFailedChildrenValues(parentId: JobId): Promise<Record<string, string>>;
+    getIgnoredChildrenFailures(parentId: JobId): Promise<Record<string, string>>;
+    updateJobParent(childId: JobId, parentId: JobId): Promise<void>;
+    removeChildDependency(childId: JobId): Promise<boolean>;
+    removeUnprocessedChildren(parentId: JobId): Promise<void>;
+}

package/dist/application/postgres-queue-manager/relationships.js

@@ -0,0 +1,45 @@
+import { PostgresQueueManagerLease } from './lease';
+/** PostgreSQL-backed parent/child relationship mutations. */
+export class PostgresQueueManagerRelationships extends PostgresQueueManagerLease {
+    async getFailedChildrenValues(parentId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.getFailedChildrenValues(parentId);
+        });
+    }
+    async getIgnoredChildrenFailures(parentId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.getIgnoredChildrenFailures(parentId);
+        });
+    }
+    async updateJobParent(childId, parentId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            await this.postgresStore.updateParent(childId, parentId);
+            await Promise.all([this.refreshJob(childId), this.refreshJob(parentId)]);
+        });
+    }
+    async removeChildDependency(childId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const child = await this.postgresStore.getJob(childId);
+            const parentId = child?.job.parentId ?? null;
+            const removed = await this.postgresStore.removeDependency(childId);
+            if (removed) {
+                await this.refreshJob(childId);
+                if (parentId)
+                    await this.refreshJob(parentId);
+            }
+            return removed;
+        });
+    }
+    async removeUnprocessedChildren(parentId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const removed = await this.postgresStore.removeUnprocessedChildren(parentId);
+            if (removed.length > 0)
+                await this.refreshJobs([parentId, ...removed]);
+        });
+    }
+}

package/dist/application/postgres-queue-manager/services.d.ts

@@ -0,0 +1,31 @@
+import type { CronJob, CronJobInput } from '../../domain/types/cron';
+import type { JobId } from '../../domain/types/job';
+import type { QueueMetrics, QueueMetricType } from '../../domain/types/metrics';
+import type { CreateWorkerOptions, Worker } from '../../domain/types/worker';
+import { PostgresQueueManagerControl } from './control';
+/** Durable PostgreSQL-backed broker services shared across every broker instance. */
+export declare class PostgresQueueManagerServices extends PostgresQueueManagerControl {
+    registerWorker(name: string, queues: string[], concurrency?: number, options?: CreateWorkerOptions): Worker;
+    registerWorkerDurable(name: string, queues: string[], concurrency?: number, options?: CreateWorkerOptions): Promise<Worker>;
+    unregisterWorker(id: string): boolean;
+    unregisterWorkerDurable(id: string, clientId?: string): Promise<boolean>;
+    unregisterWorkersByClientId(clientId: string): number;
+    heartbeatWorkerDurable(id: string, stats?: {
+        activeJobs?: number;
+        processed?: number;
+        failed?: number;
+    }, clientId?: string): Promise<boolean>;
+    listWorkersDurable(): Promise<Worker[]>;
+    findMissingDependenciesDurable(ids: readonly JobId[]): Promise<JobId[]>;
+    addCron(input: CronJobInput): CronJob;
+    addCronDurable(input: CronJobInput): Promise<CronJob>;
+    removeCron(name: string): boolean;
+    removeCronDurable(name: string): Promise<boolean>;
+    getCronDurable(name: string): Promise<CronJob | undefined>;
+    listCronsDurable(): Promise<CronJob[]>;
+    addLogDurable(id: JobId, message: string, level?: 'info' | 'warn' | 'error'): Promise<boolean>;
+    getLogsDurable(id: JobId): Promise<import("../../domain/types/worker").JobLogEntry[]>;
+    clearLogsDurable(id: JobId, keepLogs?: number): Promise<void>;
+    getQueueMetricsDurable(queue: string, type: QueueMetricType, start?: number, end?: number): Promise<QueueMetrics>;
+    trimQueueEventsDurable(queue: string, maxLength: number): Promise<number>;
+}

package/dist/application/postgres-queue-manager/services.js

@@ -0,0 +1,149 @@
+import { PostgresQueueManagerControl } from './control';
+/** Durable PostgreSQL-backed broker services shared across every broker instance. */
+export class PostgresQueueManagerServices extends PostgresQueueManagerControl {
+    registerWorker(name, queues, concurrency, options) {
+        return this.operations.runSync(() => {
+            const worker = super.registerWorker(name, queues, concurrency, options);
+            this.enqueueWrite(() => this.postgresStore.saveWorker(worker));
+            return worker;
+        });
+    }
+    async registerWorkerDurable(name, queues, concurrency, options) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const worker = super.registerWorker(name, queues, concurrency, options);
+            try {
+                await this.postgresStore.saveWorker(worker);
+                return worker;
+            }
+            catch (error) {
+                super.unregisterWorker(worker.id);
+                throw error;
+            }
+        });
+    }
+    unregisterWorker(id) {
+        const admitted = this.operations.tryRunSync(() => {
+            const removed = super.unregisterWorker(id);
+            this.enqueueWrite(() => this.postgresStore.removeWorker(id).then(() => undefined));
+            return removed;
+        });
+        return admitted.accepted ? admitted.value : super.unregisterWorker(id);
+    }
+    async unregisterWorkerDurable(id, clientId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const removed = await this.postgresStore.removeWorker(id, clientId);
+            super.unregisterWorker(id);
+            return removed;
+        });
+    }
+    unregisterWorkersByClientId(clientId) {
+        const admitted = this.operations.tryRunSync(() => {
+            const removed = super.unregisterWorkersByClientId(clientId);
+            this.enqueueWrite(() => this.postgresStore.removeClientWorkers(clientId).then(() => undefined));
+            return removed;
+        });
+        return admitted.accepted ? admitted.value : super.unregisterWorkersByClientId(clientId);
+    }
+    async heartbeatWorkerDurable(id, stats, clientId) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const updated = await this.postgresStore.heartbeatWorker(id, stats, clientId);
+            if (updated)
+                this.workerManager.heartbeat(id, stats);
+            return updated;
+        });
+    }
+    async listWorkersDurable() {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.listWorkers();
+        });
+    }
+    async findMissingDependenciesDurable(ids) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.findMissingDependencies(ids);
+        });
+    }
+    addCron(input) {
+        return this.operations.runSync(() => {
+            const cron = this.cronScheduler.add(input);
+            this.enqueueWrite(async () => {
+                const stored = await this.postgresStore.addCron(input);
+                cron.executions = stored.executions;
+                cron.nextRun = stored.nextRun;
+            });
+            return cron;
+        });
+    }
+    async addCronDurable(input) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const stored = await this.postgresStore.addCron(input);
+            const local = this.cronScheduler.add(input);
+            local.executions = stored.executions;
+            local.nextRun = stored.nextRun;
+            return stored;
+        });
+    }
+    removeCron(name) {
+        return this.operations.runSync(() => {
+            const removed = this.cronScheduler.remove(name);
+            this.enqueueWrite(() => this.postgresStore.removeCron(name).then(() => undefined));
+            return removed;
+        });
+    }
+    async removeCronDurable(name) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            const removed = await this.postgresStore.removeCron(name);
+            if (removed)
+                this.cronScheduler.remove(name);
+            return removed;
+        });
+    }
+    async getCronDurable(name) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.getCron(name);
+        });
+    }
+    async listCronsDurable() {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.listCrons();
+        });
+    }
+    async addLogDurable(id, message, level = 'info') {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.addLog(id, message, level);
+        });
+    }
+    async getLogsDurable(id) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.getLogs(id);
+        });
+    }
+    async clearLogsDurable(id, keepLogs) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            await this.postgresStore.clearLogs(id, keepLogs);
+        });
+    }
+    async getQueueMetricsDurable(queue, type, start = 0, end = -1) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.getQueueMetrics(queue, type, start, end);
+        });
+    }
+    async trimQueueEventsDurable(queue, maxLength) {
+        return await this.runPostgresOperation(async () => {
+            await this.postgresReady;
+            return await this.postgresStore.trimQueueEvents(queue, maxLength);
+        });
+    }
+}

package/dist/application/postgres-queue-manager/snapshot.d.ts

@@ -0,0 +1,51 @@
+import type { DlqEntry, DlqFilter } from '../../domain/types/dlq';
+import type { Job, JobId } from '../../domain/types/job';
+import type { JobLocation } from '../../domain/types/queue';
+import type { ClaimedPostgresJob, PostgresCompletionResult, PostgresCounts, PostgresJobState, PostgresQueueState, PostgresStoredJob, PostgresStoreEvent } from '../../infrastructure/persistence/postgres';
+/** Eventually-consistent read model; PostgreSQL remains authoritative for every transition. */
+export declare class PostgresQueueSnapshot {
+    private readonly maxCompletedJobs;
+    private readonly maxJobResults;
+    private readonly jobs;
+    private readonly results;
+    private readonly queues;
+    private readonly knownQueues;
+    private readonly completedOrder;
+    constructor(maxCompletedJobs: number, maxJobResults: number);
+    hydrate(rows: readonly PostgresStoredJob[]): void;
+    replaceQueue(queue: string, rows: readonly PostgresStoredJob[], state: PostgresQueueState, completions?: readonly PostgresCompletionResult[]): void;
+    removeQueue(queue: string): JobId[];
+    hydrateResults(entries: readonly PostgresCompletionResult[]): void;
+    put(row: PostgresStoredJob): void;
+    claim(claimed: ClaimedPostgresJob): void;
+    remove(id: JobId): void;
+    reconcile(id: JobId, row: PostgresStoredJob | null, completion: PostgresCompletionResult | null): void;
+    setQueueState(state: PostgresQueueState): void;
+    apply(event: PostgresStoreEvent): void;
+    get(id: JobId): PostgresStoredJob | null;
+    getResult(id: JobId): unknown;
+    hasResult(id: JobId): boolean;
+    locations(): Map<JobId, JobLocation>;
+    completedIds(): Set<JobId>;
+    completionIds(): Set<JobId>;
+    private putCompletion;
+    private putResult;
+    private removeQueueResults;
+    private trimCompletedJobs;
+    getByCustomId(customId: string): Job | null;
+    getByUniqueKey(queue: string, key: string): Job | null;
+    ids(queue: string, states?: readonly PostgresJobState[]): JobId[];
+    removeStates(queue: string, states: readonly PostgresJobState[]): number;
+    queueState(queue: string): PostgresQueueState | null;
+    queueNames(): string[];
+    list(queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Job[];
+    counts(queue?: string): PostgresCounts;
+    priorities(queue: string): Record<number, number>;
+    dlq(queue: string, filter?: DlqFilter): DlqEntry[];
+    size(): number;
+}