bunqueue 2.8.53 → 2.8.56

package/dist/client/queue/runtime/configuration.d.ts

@@ -0,0 +1,42 @@
+import type { DlqConfig, DlqEntry, DlqFilter, DlqStats, StallConfig } from '../../types';
+import { QueueControl } from './control';
+/** Stall, DLQ, concurrency, and rate-limit configuration. */
+export declare class QueueConfiguration<T> extends QueueControl<T> {
+    setStallConfig(config: Partial<StallConfig>): void;
+    setStallConfigAsync(config: Partial<StallConfig>): Promise<void>;
+    getStallConfig(): StallConfig;
+    getStallConfigAsync(): Promise<StallConfig>;
+    setDlqConfig(config: Partial<DlqConfig>): void;
+    setDlqConfigAsync(config: Partial<DlqConfig>): Promise<void>;
+    getDlqConfig(): DlqConfig;
+    getDlqConfigAsync(): Promise<DlqConfig>;
+    getDlq(filter?: DlqFilter): DlqEntry<T>[];
+    getDlqAsync(filter?: DlqFilter): Promise<DlqEntry<T>[]>;
+    getDlqJobsAsync(count?: number): Promise<import("../..").Job<T>[]>;
+    getDlqStats(): DlqStats;
+    getDlqStatsAsync(): Promise<DlqStats>;
+    retryDlq(id?: string): number;
+    retryDlqAsync(id?: string): Promise<number>;
+    retryDlqByFilter(filter: DlqFilter): number;
+    retryDlqByFilterAsync(filter: DlqFilter): Promise<number>;
+    purgeDlq(): number;
+    purgeDlqAsync(): Promise<number>;
+    retryCompleted(id?: string): number;
+    retryCompletedAsync(id?: string): Promise<number>;
+    setGlobalConcurrency(concurrency: number): void;
+    setGlobalConcurrencyAsync(concurrency: number): Promise<void>;
+    removeGlobalConcurrency(): void;
+    removeGlobalConcurrencyAsync(): Promise<void>;
+    getGlobalConcurrency(): Promise<number | null>;
+    setGlobalRateLimit(max: number, duration?: number): void;
+    setGlobalRateLimitAsync(max: number, duration?: number): Promise<void>;
+    removeGlobalRateLimit(): void;
+    removeGlobalRateLimitAsync(): Promise<void>;
+    getGlobalRateLimit(): Promise<{
+        max: number;
+        duration: number;
+    } | null>;
+    rateLimit(expireTimeMs: number): Promise<void>;
+    getRateLimitTtl(maxJobs?: number): Promise<number>;
+    isMaxed(): Promise<boolean>;
+}

package/dist/client/queue/runtime/configuration.js

@@ -0,0 +1,109 @@
+import * as dlqOps from '../dlq';
+import * as rateLimitOps from '../rateLimit';
+import * as stallOps from '../stall';
+import { QueueControl } from './control';
+/** Stall, DLQ, concurrency, and rate-limit configuration. */
+export class QueueConfiguration extends QueueControl {
+    setStallConfig(config) {
+        stallOps.setStallConfig(this.ctx, config);
+    }
+    setStallConfigAsync(config) {
+        return stallOps.setStallConfigAsync(this.ctx, config);
+    }
+    getStallConfig() {
+        return stallOps.getStallConfig(this.ctx);
+    }
+    getStallConfigAsync() {
+        return stallOps.getStallConfigAsync(this.ctx);
+    }
+    setDlqConfig(config) {
+        dlqOps.setDlqConfig(this.ctx, config);
+    }
+    setDlqConfigAsync(config) {
+        return dlqOps.setDlqConfigAsync(this.ctx, config);
+    }
+    getDlqConfig() {
+        return dlqOps.getDlqConfig(this.ctx);
+    }
+    getDlqConfigAsync() {
+        return dlqOps.getDlqConfigAsync(this.ctx);
+    }
+    getDlq(filter) {
+        return dlqOps.getDlq(this.queryCtx, filter);
+    }
+    getDlqAsync(filter) {
+        return dlqOps.getDlqAsync(this.queryCtx, filter);
+    }
+    getDlqJobsAsync(count) {
+        return dlqOps.getDlqJobsAsync(this.queryCtx, count);
+    }
+    getDlqStats() {
+        return dlqOps.getDlqStats(this.ctx);
+    }
+    getDlqStatsAsync() {
+        return dlqOps.getDlqStatsAsync(this.ctx);
+    }
+    retryDlq(id) {
+        return dlqOps.retryDlq(this.ctx, id);
+    }
+    retryDlqAsync(id) {
+        return dlqOps.retryDlqAsync(this.ctx, id);
+    }
+    retryDlqByFilter(filter) {
+        return dlqOps.retryDlqByFilter(this.ctx, filter);
+    }
+    retryDlqByFilterAsync(filter) {
+        return dlqOps.retryDlqByFilterAsync(this.ctx, filter);
+    }
+    purgeDlq() {
+        return dlqOps.purgeDlq(this.ctx);
+    }
+    purgeDlqAsync() {
+        return dlqOps.purgeDlqAsync(this.ctx);
+    }
+    retryCompleted(id) {
+        return dlqOps.retryCompleted(this.ctx, id);
+    }
+    retryCompletedAsync(id) {
+        return dlqOps.retryCompletedAsync(this.ctx, id);
+    }
+    setGlobalConcurrency(concurrency) {
+        rateLimitOps.setGlobalConcurrency(this.ctx, concurrency);
+    }
+    setGlobalConcurrencyAsync(concurrency) {
+        return rateLimitOps.setGlobalConcurrencyAsync(this.ctx, concurrency);
+    }
+    removeGlobalConcurrency() {
+        rateLimitOps.removeGlobalConcurrency(this.ctx);
+    }
+    removeGlobalConcurrencyAsync() {
+        return rateLimitOps.removeGlobalConcurrencyAsync(this.ctx);
+    }
+    getGlobalConcurrency() {
+        return rateLimitOps.getGlobalConcurrency(this.ctx);
+    }
+    setGlobalRateLimit(max, duration) {
+        rateLimitOps.setGlobalRateLimit(this.ctx, max, duration);
+    }
+    setGlobalRateLimitAsync(max, duration) {
+        return rateLimitOps.setGlobalRateLimitAsync(this.ctx, max, duration);
+    }
+    removeGlobalRateLimit() {
+        rateLimitOps.removeGlobalRateLimit(this.ctx);
+    }
+    removeGlobalRateLimitAsync() {
+        return rateLimitOps.removeGlobalRateLimitAsync(this.ctx);
+    }
+    getGlobalRateLimit() {
+        return rateLimitOps.getGlobalRateLimit(this.ctx);
+    }
+    rateLimit(expireTimeMs) {
+        return rateLimitOps.rateLimit(this.ctx, expireTimeMs);
+    }
+    getRateLimitTtl(maxJobs) {
+        return rateLimitOps.getRateLimitTtl(this.ctx, maxJobs);
+    }
+    isMaxed() {
+        return rateLimitOps.isMaxed(this.ctx);
+    }
+}

package/dist/client/queue/runtime/connection.d.ts

@@ -0,0 +1,6 @@
+import { QueueCompatibility } from './compatibility';
+/** Queue batching shutdown and transport cleanup. */
+export declare class QueueConnection<T> extends QueueCompatibility<T> {
+    disconnect(): Promise<void>;
+    close(): void;
+}

package/dist/client/queue/runtime/connection.js

@@ -0,0 +1,16 @@
+import { QueueCompatibility } from './compatibility';
+/** Queue batching shutdown and transport cleanup. */
+export class QueueConnection extends QueueCompatibility {
+    async disconnect() {
+        if (this.addBatcher) {
+            await this.addBatcher.flush();
+            await this.addBatcher.waitForInFlight();
+            this.addBatcher.stop();
+        }
+        this.close();
+    }
+    close() {
+        this.addBatcher?.stop();
+        this.releaseConnection();
+    }
+}

package/dist/client/queue/runtime/control.d.ts

@@ -0,0 +1,41 @@
+import type { ChangePriorityOpts } from '../../types';
+import { QueueQueries } from './queries';
+/** Queue lifecycle controls and individual job management operations. */
+export declare class QueueControl<T> extends QueueQueries<T> {
+    pause(): void;
+    pauseAsync(): Promise<void>;
+    resume(): void;
+    resumeAsync(): Promise<void>;
+    drain(): void;
+    drainAsync(): Promise<number>;
+    obliterate(): void;
+    obliterateAsync(): Promise<void>;
+    isPaused(): boolean;
+    isPausedAsync(): Promise<boolean>;
+    waitUntilReady(): Promise<void>;
+    remove(id: string): void;
+    removeAsync(id: string): Promise<void>;
+    retryJob(id: string): Promise<void>;
+    retryJobs(opts?: {
+        state?: 'failed' | 'completed';
+        count?: number;
+        timestamp?: number;
+    }): Promise<void>;
+    clean(grace: number, limit: number, type?: string): string[];
+    cleanAsync(grace: number, limit: number, type?: string): Promise<string[]>;
+    promoteJobs(opts?: {
+        count?: number;
+    }): Promise<number>;
+    promoteJob(id: string): Promise<void>;
+    updateJobProgress(id: string, progress: number | object): Promise<void>;
+    getJobLogs(id: string, start?: number, end?: number, _asc?: boolean): Promise<{
+        logs: string[];
+        count: number;
+    }>;
+    addJobLog(id: string, logRow: string, _keepLogs?: number): Promise<number>;
+    clearJobLogs(id: string, keepLogs?: number): Promise<void>;
+    updateJobData(id: string, data: unknown): Promise<void>;
+    changeJobDelay(id: string, delay: number): Promise<void>;
+    changeJobPriority(id: string, opts: ChangePriorityOpts): Promise<void>;
+    extendJobLock(id: string, token: string, duration: number): Promise<number>;
+}

package/dist/client/queue/runtime/control.js

@@ -0,0 +1,87 @@
+import * as controlOps from '../operations/control';
+import * as managementOps from '../operations/management';
+import { QueueQueries } from './queries';
+/** Queue lifecycle controls and individual job management operations. */
+export class QueueControl extends QueueQueries {
+    pause() {
+        controlOps.pause(this.ctx);
+    }
+    pauseAsync() {
+        return controlOps.pauseAsync(this.ctx);
+    }
+    resume() {
+        controlOps.resume(this.ctx);
+    }
+    resumeAsync() {
+        return controlOps.resumeAsync(this.ctx);
+    }
+    drain() {
+        controlOps.drain(this.ctx);
+    }
+    drainAsync() {
+        return controlOps.drainAsync(this.ctx);
+    }
+    obliterate() {
+        controlOps.obliterate(this.ctx);
+    }
+    obliterateAsync() {
+        return controlOps.obliterateAsync(this.ctx);
+    }
+    isPaused() {
+        return controlOps.isPaused(this.ctx);
+    }
+    isPausedAsync() {
+        return controlOps.isPausedAsync(this.ctx);
+    }
+    waitUntilReady() {
+        return controlOps.waitUntilReady(this.ctx);
+    }
+    remove(id) {
+        managementOps.remove(this.ctx, id);
+    }
+    removeAsync(id) {
+        return managementOps.removeAsync(this.ctx, id);
+    }
+    retryJob(id) {
+        return managementOps.retryJob(this.ctx, id);
+    }
+    retryJobs(opts) {
+        return managementOps.retryJobs(this.ctx, opts);
+    }
+    clean(grace, limit, type) {
+        return managementOps.clean(this.ctx, grace, limit, type);
+    }
+    cleanAsync(grace, limit, type) {
+        return managementOps.cleanAsync(this.ctx, grace, limit, type);
+    }
+    promoteJobs(opts) {
+        return managementOps.promoteJobs(this.ctx, opts);
+    }
+    promoteJob(id) {
+        return managementOps.promoteJob(this.ctx, id);
+    }
+    updateJobProgress(id, progress) {
+        return managementOps.updateJobProgress(this.ctx, id, progress);
+    }
+    getJobLogs(id, start, end, _asc) {
+        return managementOps.getJobLogs(this.ctx, id, start, end);
+    }
+    addJobLog(id, logRow, _keepLogs) {
+        return managementOps.addJobLog(this.ctx, id, logRow);
+    }
+    clearJobLogs(id, keepLogs) {
+        return managementOps.clearJobLogs(this.ctx, id, keepLogs);
+    }
+    updateJobData(id, data) {
+        return managementOps.updateJobData(this.ctx, id, data);
+    }
+    changeJobDelay(id, delay) {
+        return managementOps.changeJobDelay(this.ctx, id, delay);
+    }
+    changeJobPriority(id, opts) {
+        return managementOps.changeJobPriority(this.ctx, id, opts);
+    }
+    extendJobLock(id, token, duration) {
+        return managementOps.extendJobLock(this.ctx, id, token, duration);
+    }
+}

package/dist/client/queue/runtime/queries.d.ts

@@ -0,0 +1,48 @@
+import type { Job, JobOptions, JobStateType } from '../../types';
+import * as countsOps from '../operations/counts';
+import { QueueState } from './state';
+/** Job creation, lookup, state-listing, and count operations. */
+export declare class QueueQueries<T> extends QueueState<T> {
+    add(name: string, data: T, opts?: JobOptions): Promise<Job<T>>;
+    addBulk(jobs: Array<{
+        name: string;
+        data: T;
+        opts?: JobOptions;
+    }>): Promise<Job<T>[]>;
+    getJob(id: string): Promise<Job<T> | null>;
+    getJobState(id: string): Promise<JobStateType>;
+    getChildrenValues(id: string): Promise<Record<string, unknown>>;
+    getJobs(opts?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Job<T>[];
+    getJobsAsync(opts?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Promise<Job<unknown>[]>;
+    getWaiting(start?: number, end?: number): Job<T>[];
+    getWaitingAsync(start?: number, end?: number): Promise<Job<T>[]>;
+    getDelayed(start?: number, end?: number): Job<T>[];
+    getDelayedAsync(start?: number, end?: number): Promise<Job<T>[]>;
+    getActive(start?: number, end?: number): Job<T>[];
+    getActiveAsync(start?: number, end?: number): Promise<Job<T>[]>;
+    getCompleted(start?: number, end?: number): Job<T>[];
+    getCompletedAsync(start?: number, end?: number): Promise<Job<T>[]>;
+    getFailed(start?: number, end?: number): Job<T>[];
+    getFailedAsync(start?: number, end?: number): Promise<Job<T>[]>;
+    getJobCounts(): countsOps.JobCounts | Promise<countsOps.JobCounts>;
+    getJobCountsAsync(): Promise<countsOps.JobCounts>;
+    getWaitingCount(): Promise<number>;
+    getActiveCount(): Promise<number>;
+    getCompletedCount(): Promise<number>;
+    getFailedCount(): Promise<number>;
+    getDelayedCount(): Promise<number>;
+    count(): number;
+    countAsync(): Promise<number>;
+    getCountsPerPriority(): Record<number, number>;
+    getCountsPerPriorityAsync(): Promise<Record<number, number>>;
+}

package/dist/client/queue/runtime/queries.js

@@ -0,0 +1,95 @@
+import * as countsOps from '../operations/counts';
+import * as addOps from '../operations/add';
+import * as queryOps from '../operations/query';
+import * as queryStateOps from '../operations/queryStates';
+import { QueueState } from './state';
+/** Job creation, lookup, state-listing, and count operations. */
+export class QueueQueries extends QueueState {
+    add(name, data, opts) {
+        if (this.addBatcher && !opts?.durable) {
+            return this.addBatcher.enqueue(name, data, opts);
+        }
+        return addOps.add(this.addCtx, name, data, opts);
+    }
+    addBulk(jobs) {
+        return addOps.addBulk(this.addCtx, jobs);
+    }
+    getJob(id) {
+        return queryOps.getJob(this.queryCtx, id);
+    }
+    getJobState(id) {
+        return queryOps.getJobState(this.queryCtx, id);
+    }
+    getChildrenValues(id) {
+        return queryOps.getChildrenValues(this.queryCtx, id);
+    }
+    getJobs(opts) {
+        return queryOps.getJobs(this.queryCtx, opts);
+    }
+    getJobsAsync(opts) {
+        return queryOps.getJobsAsync(this.queryCtx, opts);
+    }
+    getWaiting(start, end) {
+        return queryStateOps.getWaiting(this.queryCtx, start, end);
+    }
+    getWaitingAsync(start, end) {
+        return queryStateOps.getWaitingAsync(this.queryCtx, start, end);
+    }
+    getDelayed(start, end) {
+        return queryStateOps.getDelayed(this.queryCtx, start, end);
+    }
+    getDelayedAsync(start, end) {
+        return queryStateOps.getDelayedAsync(this.queryCtx, start, end);
+    }
+    getActive(start, end) {
+        return queryStateOps.getActive(this.queryCtx, start, end);
+    }
+    getActiveAsync(start, end) {
+        return queryStateOps.getActiveAsync(this.queryCtx, start, end);
+    }
+    getCompleted(start, end) {
+        return queryStateOps.getCompleted(this.queryCtx, start, end);
+    }
+    getCompletedAsync(start, end) {
+        return queryStateOps.getCompletedAsync(this.queryCtx, start, end);
+    }
+    getFailed(start, end) {
+        return queryStateOps.getFailed(this.queryCtx, start, end);
+    }
+    getFailedAsync(start, end) {
+        return queryStateOps.getFailedAsync(this.queryCtx, start, end);
+    }
+    getJobCounts() {
+        return countsOps.getJobCounts(this.ctx);
+    }
+    getJobCountsAsync() {
+        return countsOps.getJobCountsAsync(this.ctx);
+    }
+    getWaitingCount() {
+        return countsOps.getWaitingCount(this.ctx);
+    }
+    getActiveCount() {
+        return countsOps.getActiveCount(this.ctx);
+    }
+    getCompletedCount() {
+        return countsOps.getCompletedCount(this.ctx);
+    }
+    getFailedCount() {
+        return countsOps.getFailedCount(this.ctx);
+    }
+    getDelayedCount() {
+        return countsOps.getDelayedCount(this.ctx);
+    }
+    count() {
+        return countsOps.count(this.ctx);
+    }
+    countAsync() {
+        return countsOps.countAsync(this.ctx);
+    }
+    getCountsPerPriority() {
+        return countsOps.getCountsPerPriority(this.ctx);
+    }
+    getCountsPerPriorityAsync() {
+        return countsOps.getCountsPerPriorityAsync(this.ctx);
+    }
+}

package/dist/client/queue/runtime/scheduling.d.ts

@@ -0,0 +1,33 @@
+import type { GetDependenciesOpts, JobDependencies, JobDependenciesCount } from '../../types';
+import * as schedulerOps from '../scheduler';
+import type { JobTemplate, RepeatOpts, SchedulerInfo } from '../scheduler';
+import { QueueConfiguration } from './configuration';
+/** Scheduler, deduplication, job-transition, and dependency operations. */
+export declare class QueueScheduling<T> extends QueueConfiguration<T> {
+    upsertJobScheduler(schedulerId: string, repeatOpts: RepeatOpts, jobTemplate?: JobTemplate<T>): Promise<SchedulerInfo | null>;
+    removeJobScheduler(schedulerId: string): Promise<boolean>;
+    getJobScheduler(schedulerId: string): Promise<schedulerOps.SchedulerInfo | null>;
+    getJobSchedulers(start?: number, end?: number, asc?: boolean): Promise<schedulerOps.SchedulerInfo[]>;
+    getJobSchedulersCount(): Promise<number>;
+    getDeduplicationJobId(deduplicationId: string): Promise<string | null>;
+    removeDeduplicationKey(deduplicationId: string): Promise<number>;
+    moveJobToCompleted(id: string, returnValue: unknown, token?: string): Promise<unknown>;
+    moveJobToFailed(id: string, error: Error, token?: string): Promise<void>;
+    moveJobToWait(id: string, token?: string): Promise<boolean>;
+    moveJobToDelayed(id: string, timestamp: number, token?: string): Promise<void>;
+    moveJobToWaitingChildren(id: string, token?: string, opts?: {
+        child?: {
+            id: string;
+            queue: string;
+        };
+    }): Promise<boolean>;
+    waitJobUntilFinished(id: string, queueEvents: unknown, ttl?: number): Promise<unknown>;
+    getJobDependencies(id: string, opts?: GetDependenciesOpts): Promise<JobDependencies>;
+    getJobDependenciesCount(id: string, opts?: GetDependenciesOpts): Promise<JobDependenciesCount>;
+    getDependencies(parentId: string, type?: 'processed' | 'unprocessed', start?: number, end?: number): Promise<{
+        processed?: Record<string, unknown>;
+        unprocessed?: string[];
+        nextProcessedCursor?: number;
+        nextUnprocessedCursor?: number;
+    }>;
+}

package/dist/client/queue/runtime/scheduling.js

@@ -0,0 +1,56 @@
+import * as bullmqCompatOps from '../bullmqCompat';
+import * as deduplicationOps from '../deduplication';
+import * as jobMoveOps from '../jobMove';
+import * as schedulerOps from '../scheduler';
+import { QueueConfiguration } from './configuration';
+/** Scheduler, deduplication, job-transition, and dependency operations. */
+export class QueueScheduling extends QueueConfiguration {
+    upsertJobScheduler(schedulerId, repeatOpts, jobTemplate) {
+        return schedulerOps.upsertJobScheduler({ ...this.ctx, defaultJobOptions: this.opts.defaultJobOptions }, schedulerId, repeatOpts, jobTemplate);
+    }
+    removeJobScheduler(schedulerId) {
+        return schedulerOps.removeJobScheduler(this.ctx, schedulerId);
+    }
+    getJobScheduler(schedulerId) {
+        return schedulerOps.getJobScheduler(this.ctx, schedulerId);
+    }
+    getJobSchedulers(start, end, asc) {
+        return schedulerOps.getJobSchedulers(this.ctx, start, end, asc);
+    }
+    getJobSchedulersCount() {
+        return schedulerOps.getJobSchedulersCount(this.ctx);
+    }
+    getDeduplicationJobId(deduplicationId) {
+        return deduplicationOps.getDeduplicationJobId(this.ctx, deduplicationId);
+    }
+    removeDeduplicationKey(deduplicationId) {
+        return deduplicationOps.removeDeduplicationKey(this.ctx, deduplicationId);
+    }
+    moveJobToCompleted(id, returnValue, token) {
+        return jobMoveOps.moveJobToCompleted(this.moveCtx, id, returnValue, token);
+    }
+    moveJobToFailed(id, error, token) {
+        return jobMoveOps.moveJobToFailed(this.moveCtx, id, error, token);
+    }
+    moveJobToWait(id, token) {
+        return jobMoveOps.moveJobToWait(this.moveCtx, id, token);
+    }
+    moveJobToDelayed(id, timestamp, token) {
+        return jobMoveOps.moveJobToDelayed(this.moveCtx, id, timestamp, token);
+    }
+    moveJobToWaitingChildren(id, token, opts) {
+        return jobMoveOps.moveJobToWaitingChildren(this.moveCtx, id, token, opts);
+    }
+    waitJobUntilFinished(id, queueEvents, ttl) {
+        return jobMoveOps.waitJobUntilFinished(this.moveCtx, id, queueEvents, ttl);
+    }
+    getJobDependencies(id, opts) {
+        return bullmqCompatOps.getJobDependencies(this.addCtx, id, opts);
+    }
+    getJobDependenciesCount(id, opts) {
+        return bullmqCompatOps.getJobDependenciesCount(this.addCtx, id, opts);
+    }
+    getDependencies(parentId, type, start, end) {
+        return bullmqCompatOps.getDependencies(this.addCtx, parentId, type, start, end);
+    }
+}

package/dist/client/queue/runtime/state.d.ts

@@ -0,0 +1,96 @@
+import type { ChangePriorityOpts, GetDependenciesOpts, QueueOptions } from '../../types';
+import { TcpConnectionPool } from '../../tcpPool';
+import { AddBatcher } from '../addBatcher';
+/** Owns Queue connection state and builds the shared operation contexts. */
+export declare class QueueState<T> {
+    readonly name: string;
+    protected readonly queueKey: string;
+    protected readonly prefixKey: string;
+    protected readonly opts: QueueOptions;
+    protected readonly embedded: boolean;
+    protected readonly tcpPool: TcpConnectionPool | null;
+    protected readonly useSharedPool: boolean;
+    protected readonly addBatcher: AddBatcher<unknown> | null;
+    constructor(name: string, opts?: QueueOptions);
+    protected get ctx(): {
+        name: string;
+        embedded: boolean;
+        tcp: TcpConnectionPool | null;
+        prefixKey: string;
+    };
+    protected get addCtx(): {
+        opts: QueueOptions;
+        getJobState: (id: string) => Promise<import("../../types").JobStateType>;
+        removeAsync: (id: string) => Promise<void>;
+        retryJob: (id: string) => Promise<void>;
+        getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+        updateJobData: (id: string, data: unknown) => Promise<void>;
+        promoteJob: (id: string) => Promise<void>;
+        changeJobDelay: (id: string, delay: number) => Promise<void>;
+        changeJobPriority: (id: string, options: ChangePriorityOpts) => Promise<void>;
+        extendJobLock: (id: string, token: string, duration: number) => Promise<number>;
+        clearJobLogs: (id: string, keep?: number) => Promise<void>;
+        getJobDependencies: (id: string, options?: GetDependenciesOpts) => Promise<import("../..").JobDependencies>;
+        getJobDependenciesCount: (id: string, options?: GetDependenciesOpts) => Promise<import("../..").JobDependenciesCount>;
+        getJobCountsAsync: () => Promise<unknown>;
+        getJobsAsync: (options: {
+            state?: string | string[];
+            start?: number;
+            end?: number;
+            asc?: boolean;
+        }) => Promise<import("../..").Job<T>[]>;
+        moveJobToCompleted: (id: string, result: unknown, token?: string) => Promise<unknown>;
+        moveJobToFailed: (id: string, error: Error, token?: string) => Promise<void>;
+        moveJobToWait: (id: string, token?: string) => Promise<boolean>;
+        moveJobToDelayed: (id: string, timestamp: number, token?: string) => Promise<void>;
+        moveJobToWaitingChildren: (id: string, token?: string, options?: {
+            child?: {
+                id: string;
+                queue: string;
+            };
+        }) => Promise<boolean>;
+        waitJobUntilFinished: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
+        name: string;
+        embedded: boolean;
+        tcp: TcpConnectionPool | null;
+        prefixKey: string;
+    };
+    protected get queryCtx(): {
+        getJobState: (id: string) => Promise<import("../../types").JobStateType>;
+        removeAsync: (id: string) => Promise<void>;
+        retryJob: (id: string) => Promise<void>;
+        getChildrenValues: (id: string) => Promise<Record<string, unknown>>;
+        updateJobData: (id: string, data: unknown) => Promise<void>;
+        promoteJob: (id: string) => Promise<void>;
+        changeJobDelay: (id: string, delay: number) => Promise<void>;
+        changeJobPriority: (id: string, options: ChangePriorityOpts) => Promise<void>;
+        extendJobLock: (id: string, token: string, duration: number) => Promise<number>;
+        clearJobLogs: (id: string, keep?: number) => Promise<void>;
+        getJobDependencies: (id: string, options?: GetDependenciesOpts) => Promise<import("../..").JobDependencies>;
+        getJobDependenciesCount: (id: string, options?: GetDependenciesOpts) => Promise<import("../..").JobDependenciesCount>;
+        moveJobToCompleted: (id: string, result: unknown, token?: string) => Promise<unknown>;
+        moveJobToFailed: (id: string, error: Error, token?: string) => Promise<void>;
+        moveJobToWait: (id: string, token?: string) => Promise<boolean>;
+        moveJobToDelayed: (id: string, timestamp: number, token?: string) => Promise<void>;
+        moveJobToWaitingChildren: (id: string, token?: string, options?: {
+            child?: {
+                id: string;
+                queue: string;
+            };
+        }) => Promise<boolean>;
+        waitJobUntilFinished: (id: string, queueEvents: unknown, ttl?: number) => Promise<unknown>;
+        name: string;
+        embedded: boolean;
+        tcp: TcpConnectionPool | null;
+        prefixKey: string;
+    };
+    protected get moveCtx(): {
+        getJobState: (id: string) => Promise<import("../../types").JobStateType>;
+        getJobDependencies: (id: string) => Promise<import("../..").JobDependencies>;
+        name: string;
+        embedded: boolean;
+        tcp: TcpConnectionPool | null;
+        prefixKey: string;
+    };
+    protected releaseConnection(): void;
+}