bullmq 3.6.0 → 3.6.2

package/dist/esm/classes/repeat.d.ts

@@ -1,25 +0,0 @@
-import { RepeatBaseOptions, RepeatOptions } from '../interfaces';
-import { JobsOptions } from '../types';
-import { Job } from './job';
-import { QueueBase } from './queue-base';
-import { RedisConnection } from './redis-connection';
-export declare class Repeat extends QueueBase {
-    private repeatStrategy;
-    constructor(name: string, opts?: RepeatBaseOptions, Connection?: typeof RedisConnection);
-    addNextRepeatableJob<T = any, R = any, N extends string = string>(name: N, data: T, opts: JobsOptions, skipCheckExists?: boolean): Promise<Job<T, R, N>>;
-    private createNextJob;
-    removeRepeatable(name: string, repeat: RepeatOptions, jobId?: string): Promise<number>;
-    removeRepeatableByKey(repeatJobKey: string): Promise<number>;
-    private keyToData;
-    getRepeatableJobs(start?: number, end?: number, asc?: boolean): Promise<{
-        key: string;
-        name: string;
-        id: string;
-        endDate: number;
-        tz: string;
-        pattern: string;
-        next: number;
-    }[]>;
-    getRepeatableCount(): Promise<number>;
-}
-export declare const getNextMillis: (millis: number, opts: RepeatOptions) => number;

package/dist/esm/classes/sandbox.d.ts

@@ -1,4 +0,0 @@
-import { ChildPool } from './child-pool';
-import { Job } from './job';
-declare const sandbox: <T, R, N extends string>(processFile: any, childPool: ChildPool) => (job: Job<T, R, N>) => Promise<R>;
-export default sandbox;

package/dist/esm/classes/scripts.d.ts

@@ -1,101 +0,0 @@
-/**
- * Includes all the scripts needed by the queue and jobs.
- */
-/// <reference types="node" />
-import { JobJson, JobJsonRaw, MinimalJob, MoveToWaitingChildrenOpts, ParentOpts, RedisClient, KeepJobs } from '../interfaces';
-import { JobState, JobType, FinishedStatus, FinishedPropValAttribute, MinimalQueue, RedisJobOptions } from '../types';
-import { ChainableCommander } from 'ioredis';
-export type JobData = [JobJsonRaw | number, string?];
-export declare class Scripts {
-    protected queue: MinimalQueue;
-    constructor(queue: MinimalQueue);
-    isJobInList(listKey: string, jobId: string): Promise<boolean>;
-    addJob(client: RedisClient, job: JobJson, opts: RedisJobOptions, jobId: string, parentOpts?: ParentOpts): Promise<string>;
-    pause(pause: boolean): Promise<void>;
-    private removeRepeatableArgs;
-    removeRepeatable(repeatJobId: string, repeatJobKey: string): Promise<number>;
-    remove(jobId: string): Promise<number>;
-    extendLock(jobId: string, token: string, duration: number): Promise<number>;
-    updateData<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, data: T): Promise<void>;
-    updateProgress<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, progress: number | object): Promise<void>;
-    protected moveToFinishedArgs<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, val: any, propVal: FinishedPropValAttribute, shouldRemove: boolean | number | KeepJobs, target: FinishedStatus, token: string, timestamp: number, fetchNext?: boolean): (string | number | boolean | Buffer)[];
-    protected moveToFinished<DataType = any, ReturnType = any, NameType extends string = string>(job: MinimalJob<DataType, ReturnType, NameType>, val: any, propVal: FinishedPropValAttribute, shouldRemove: boolean | number | KeepJobs, target: FinishedStatus, token: string, fetchNext: boolean): Promise<any[]>;
-    finishedErrors(code: number, jobId: string, command: string, state?: string): Error;
-    private drainArgs;
-    drain(delayed: boolean): Promise<void>;
-    private getRangesArgs;
-    getRanges(types: JobType[], start?: number, end?: number, asc?: boolean): Promise<[string][]>;
-    private getCountsArgs;
-    getCounts(types: JobType[]): Promise<number[]>;
-    moveToCompleted<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, returnvalue: R, removeOnComplete: boolean | number | KeepJobs, token: string, fetchNext: boolean): Promise<any[]>;
-    moveToFailedArgs<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, failedReason: string, removeOnFailed: boolean | number | KeepJobs, token: string, fetchNext?: boolean): (string | number | boolean | Buffer)[];
-    isFinished(jobId: string, returnValue?: boolean): Promise<number | [number, string]>;
-    getState(jobId: string): Promise<JobState | 'unknown'>;
-    changeDelay(jobId: string, delay: number): Promise<void>;
-    private changeDelayArgs;
-    moveToDelayedArgs(jobId: string, timestamp: number, token: string): (string | number)[];
-    moveToWaitingChildrenArgs(jobId: string, token: string, opts?: MoveToWaitingChildrenOpts): string[];
-    moveToDelayed(jobId: string, timestamp: number, token?: string): Promise<void>;
-    /**
-     * Move parent job to waiting-children state.
-     *
-     * @returns true if job is successfully moved, false if there are pending dependencies.
-     * @throws JobNotExist
-     * This exception is thrown if jobId is missing.
-     * @throws JobLockNotExist
-     * This exception is thrown if job lock is missing.
-     * @throws JobNotInState
-     * This exception is thrown if job is not in active state.
-     */
-    moveToWaitingChildren(jobId: string, token: string, opts?: MoveToWaitingChildrenOpts): Promise<boolean>;
-    /**
-     * Remove jobs in a specific state.
-     *
-     * @returns Id jobs from the deleted records.
-     */
-    cleanJobsInSet(set: string, timestamp: number, limit?: number): Promise<string[]>;
-    retryJobArgs(jobId: string, lifo: boolean, token: string): (string | number)[];
-    protected retryJobsArgs(state: FinishedStatus, count: number, timestamp: number): (string | number)[];
-    retryJobs(state?: FinishedStatus, count?: number, timestamp?: number): Promise<number>;
-    /**
-     * Attempts to reprocess a job
-     *
-     * @param job -
-     * @param state - The expected job state. If the job is not found
-     * on the provided state, then it's not reprocessed. Supported states: 'failed', 'completed'
-     *
-     * @returns Returns a promise that evaluates to a return code:
-     * 1 means the operation was a success
-     * 0 means the job does not exist
-     * -1 means the job is currently locked and can't be retried.
-     * -2 means the job was not found in the expected set
-     */
-    reprocessJob<T = any, R = any, N extends string = string>(job: MinimalJob<T, R, N>, state: 'failed' | 'completed'): Promise<void>;
-    moveToActive(token: string, jobId?: string): Promise<any[]>;
-    promote(jobId: string): Promise<number>;
-    /**
-     * Looks for unlocked jobs in the active queue.
-     *
-     * The job was being worked on, but the worker process died and it failed to renew the lock.
-     * We call these jobs 'stalled'. This is the most common case. We resolve these by moving them
-     * back to wait to be re-processed. To prevent jobs from cycling endlessly between active and wait,
-     * (e.g. if the job handler keeps crashing),
-     * we limit the number stalled job recoveries to settings.maxStalledCount.
-     */
-    moveStalledJobsToWait(): Promise<[string[], string[]]>;
-    /**
-     * Moves a job back from Active to Wait.
-     * This script is used when a job has been manually rate limited and needs
-     * to be moved back to wait from active status.
-     *
-     * @param client - Redis client
-     * @param jobId - Job id
-     * @returns
-     */
-    moveJobFromActiveToWait(client: ChainableCommander, jobId: string, token: string): any;
-    obliterate(opts: {
-        force: boolean;
-        count: number;
-    }): Promise<number>;
-}
-export declare function raw2NextJobData(raw: any[]): any[];

package/dist/esm/classes/timer-manager.d.ts

@@ -1,17 +0,0 @@
-/**
- * Keeps track on timers created with setTimeout to help clearTimeout
- * for all timers when no more delayed actions needed
- */
-export declare class TimerManager {
-    private readonly timers;
-    /**
-     * Creates a new timer and returns its ID.
-     *
-     * @param name - Readable name for the timer
-     * @param delay - Delay in milliseconds
-     * @param fn - Callback function that is executed after the timer expires
-     */
-    setTimer(name: string, delay: number, fn: Function): string;
-    clearTimer(id: string): void;
-    clearAllTimers(): void;
-}

package/dist/esm/classes/unrecoverable-error.d.ts

@@ -1,10 +0,0 @@
-/**
- * UnrecoverableError
- *
- * Error to move a job to failed even if the attemptsMade
- * are lower than the expected limit.
- *
- */
-export declare class UnrecoverableError extends Error {
-    constructor(message?: string);
-}

package/dist/esm/classes/worker.d.ts

@@ -1,196 +0,0 @@
-import { GetNextJobOptions, IoredisListener, JobJsonRaw, Processor, RedisClient, WorkerOptions } from '../interfaces';
-import { QueueBase } from './queue-base';
-import { Repeat } from './repeat';
-import { Job } from './job';
-import { RedisConnection } from './redis-connection';
-import { TimerManager } from './timer-manager';
-export interface WorkerListener<DataType = any, ResultType = any, NameType extends string = string> extends IoredisListener {
-    /**
-     * Listen to 'active' event.
-     *
-     * This event is triggered when a job enters the 'active' state.
-     */
-    active: (job: Job<DataType, ResultType, NameType>, prev: string) => void;
-    /**
-     * Listen to 'closing' event.
-     *
-     * This event is triggered when the worker is closed.
-     */
-    closed: () => void;
-    /**
-     * Listen to 'closing' event.
-     *
-     * This event is triggered when the worker is closing.
-     */
-    closing: (msg: string) => void;
-    /**
-     * Listen to 'completed' event.
-     *
-     * This event is triggered when a job has successfully completed.
-     */
-    completed: (job: Job<DataType, ResultType, NameType>, result: ResultType, prev: string) => void;
-    /**
-     * Listen to 'drained' event.
-     *
-     * This event is triggered when the queue has drained the waiting list.
-     * Note that there could still be delayed jobs waiting their timers to expire
-     * and this event will still be triggered as long as the waiting list has emptied.
-     */
-    drained: () => void;
-    /**
-     * Listen to 'error' event.
-     *
-     * This event is triggered when an error is throw.
-     */
-    error: (failedReason: Error) => void;
-    /**
-     * Listen to 'failed' event.
-     *
-     * This event is triggered when a job has thrown an exception.
-     */
-    failed: (job: Job<DataType, ResultType, NameType> | undefined, error: Error, prev: string) => void;
-    /**
-     * Listen to 'paused' event.
-     *
-     * This event is triggered when the queue is paused.
-     */
-    paused: () => void;
-    /**
-     * Listen to 'progress' event.
-     *
-     * This event is triggered when a job updates it progress, i.e. the
-     * Job##updateProgress() method is called. This is useful to notify
-     * progress or any other data from within a processor to the rest of the
-     * world.
-     */
-    progress: (job: Job<DataType, ResultType, NameType>, progress: number | object) => void;
-    /**
-     * Listen to 'ready' event.
-     *
-     * This event is triggered when blockingConnection is ready.
-     */
-    ready: () => void;
-    /**
-     * Listen to 'resumed' event.
-     *
-     * This event is triggered when the queue is resumed.
-     */
-    resumed: () => void;
-    /**
-     * Listen to 'stalled' event.
-     *
-     * This event is triggered when a job has stalled and
-     * has been moved back to the wait list.
-     */
-    stalled: (jobId: string, prev: string) => void;
-}
-/**
- *
- * This class represents a worker that is able to process jobs from the queue.
- * As soon as the class is instantiated and a connection to Redis is established
- * it will start processing jobs.
- *
- */
-export declare class Worker<DataType = any, ResultType = any, NameType extends string = string> extends QueueBase {
-    readonly opts: WorkerOptions;
-    readonly id: string;
-    private drained;
-    private waiting;
-    private running;
-    private blockUntil;
-    private limitUntil;
-    protected processFn: Processor<DataType, ResultType, NameType>;
-    private resumeWorker;
-    protected paused: Promise<void>;
-    private _repeat;
-    private childPool;
-    protected timerManager: TimerManager;
-    private blockingConnection;
-    private processing;
-    static RateLimitError(): Error;
-    constructor(name: string, processor?: string | Processor<DataType, ResultType, NameType>, opts?: WorkerOptions, Connection?: typeof RedisConnection);
-    emit<U extends keyof WorkerListener<DataType, ResultType, NameType>>(event: U, ...args: Parameters<WorkerListener<DataType, ResultType, NameType>[U]>): boolean;
-    off<U extends keyof WorkerListener<DataType, ResultType, NameType>>(eventName: U, listener: WorkerListener<DataType, ResultType, NameType>[U]): this;
-    on<U extends keyof WorkerListener<DataType, ResultType, NameType>>(event: U, listener: WorkerListener<DataType, ResultType, NameType>[U]): this;
-    once<U extends keyof WorkerListener<DataType, ResultType, NameType>>(event: U, listener: WorkerListener<DataType, ResultType, NameType>[U]): this;
-    protected callProcessJob(job: Job<DataType, ResultType, NameType>, token: string): Promise<ResultType>;
-    protected createJob(data: JobJsonRaw, jobId: string): Job<DataType, ResultType, NameType>;
-    /**
-     *
-     * Waits until the worker is ready to start processing jobs.
-     * In general only useful when writing tests.
-     *
-     */
-    waitUntilReady(): Promise<RedisClient>;
-    set concurrency(concurrency: number);
-    get repeat(): Promise<Repeat>;
-    run(): Promise<any[]>;
-    /**
-     * Returns a promise that resolves to the next job in queue.
-     * @param token - worker token to be assigned to retrieved job
-     * @returns a Job or undefined if no job was available in the queue.
-     */
-    getNextJob(token: string, { block }?: GetNextJobOptions): Promise<Job<DataType, ResultType, NameType>>;
-    /**
-     * Overrides the rate limit to be active for the next jobs.
-     *
-     * @param expireTimeMs - expire time in ms of this rate limit.
-     */
-    rateLimit(expireTimeMs: number): Promise<void>;
-    protected moveToActive(token: string, jobId?: string): Promise<Job<DataType, ResultType, NameType>>;
-    private waitForJob;
-    /**
-     *
-     * This function is exposed only for testing purposes.
-     */
-    delay(milliseconds?: number): Promise<void>;
-    protected nextJobFromJobData(jobData?: JobJsonRaw, jobId?: string, limitUntil?: number, delayUntil?: number): Promise<Job<DataType, ResultType, NameType>>;
-    processJob(job: Job<DataType, ResultType, NameType>, token: string, fetchNextCallback?: () => boolean): Promise<void | Job<DataType, ResultType, NameType>>;
-    /**
-     *
-     * Pauses the processing of this queue only for this worker.
-     */
-    pause(doNotWaitActive?: boolean): Promise<void>;
-    /**
-     *
-     * Resumes processing of this worker (if paused).
-     */
-    resume(): void;
-    /**
-     *
-     * Checks if worker is paused.
-     *
-     * @returns true if worker is paused, false otherwise.
-     */
-    isPaused(): boolean;
-    /**
-     *
-     * Checks if worker is currently running.
-     *
-     * @returns true if worker is running, false otherwise.
-     */
-    isRunning(): boolean;
-    /**
-     *
-     * Closes the worker and related redis connections.
-     *
-     * This method waits for current jobs to finalize before returning.
-     *
-     * @param force - Use force boolean parameter if you do not want to wait for
-     * current jobs to be processed.
-     *
-     * @returns Promise that resolves when the worker has been closed.
-     */
-    close(force?: boolean): Promise<void>;
-    /**
-     * Returns a promise that resolves when active jobs are cleared
-     *
-     * @returns
-     */
-    private whenCurrentJobsFinished;
-    private retryIfFailed;
-    private runStalledJobsCheck;
-    private moveStalledJobsToWait;
-    private notifyFailedJobs;
-    private moveLimitedBackToWait;
-}

package/dist/esm/commands/index.d.ts

@@ -1,4 +0,0 @@
-import { ScriptLoader } from './script-loader';
-export { ScriptMetadata, Command, ScriptLoaderError } from './script-loader';
-declare const scriptLoader: ScriptLoader;
-export { ScriptLoader, scriptLoader };

package/dist/esm/commands/script-loader.d.ts

@@ -1,120 +0,0 @@
-import { RedisClient } from '../interfaces';
-export interface Command {
-    name: string;
-    options: {
-        numberOfKeys: number;
-        lua: string;
-    };
-}
-/**
- * Script metadata
- */
-export interface ScriptMetadata {
-    /**
-     * Name of the script
-     */
-    name: string;
-    numberOfKeys?: number;
-    /**
-     * The path to the script. For includes, this is the normalized path,
-     * whereas it may not be normalized for the top-level parent
-     */
-    path: string;
-    /**
-     * The raw script content
-     */
-    content: string;
-    /**
-     * A hash of the normalized path for easy replacement in the parent
-     */
-    token: string;
-    /**
-     * Metadata on the scripts that this script includes
-     */
-    includes: ScriptMetadata[];
-}
-export declare class ScriptLoaderError extends Error {
-    readonly path: string;
-    /**
-     * The include stack
-     */
-    readonly includes: string[];
-    readonly line: number;
-    readonly position: number;
-    constructor(message: string, path: string, stack?: string[], line?: number, position?: number);
-}
-/**
- * Lua script loader with include support
- */
-export declare class ScriptLoader {
-    /**
-     * Map an alias to a path
-     */
-    private pathMapper;
-    private clientScripts;
-    /**
-     * Cache commands by dir
-     */
-    private commandCache;
-    private rootPath;
-    constructor();
-    /**
-     * Add a script path mapping. Allows includes of the form "<includes>/utils.lua" where `includes` is a user
-     * defined path
-     * @param name - the name of the mapping. Note: do not include angle brackets
-     * @param mappedPath - if a relative path is passed, it's relative to the *caller* of this function.
-     * Mapped paths are also accepted, e.g. "~/server/scripts/lua" or "<base>/includes"
-     */
-    addPathMapping(name: string, mappedPath: string): void;
-    /**
-     * Resolve the script path considering path mappings
-     * @param scriptName - the name of the script
-     * @param stack - the include stack, for nicer errors
-     */
-    resolvePath(scriptName: string, stack?: string[]): string;
-    /**
-     * Recursively collect all scripts included in a file
-     * @param file - the parent file
-     * @param cache - a cache for file metadata to increase efficiency. Since a file can be included
-     * multiple times, we make sure to load it only once.
-     * @param stack - internal stack to prevent circular references
-     */
-    private resolveDependencies;
-    /**
-     * Parse a (top-level) lua script
-     * @param filename - the full path to the script
-     * @param content - the content of the script
-     * @param cache - cache
-     */
-    parseScript(filename: string, content: string, cache?: Map<string, ScriptMetadata>): Promise<ScriptMetadata>;
-    /**
-     * Construct the final version of a file by interpolating its includes in dependency order.
-     * @param file - the file whose content we want to construct
-     * @param processed - a cache to keep track of which includes have already been processed
-     */
-    interpolate(file: ScriptMetadata, processed?: Set<string>): string;
-    loadCommand(filename: string, cache?: Map<string, ScriptMetadata>): Promise<Command>;
-    /**
-     * Load redis lua scripts.
-     * The name of the script must have the following format:
-     *
-     * cmdName-numKeys.lua
-     *
-     * cmdName must be in camel case format.
-     *
-     * For example:
-     * moveToFinish-3.lua
-     *
-     */
-    loadScripts(dir?: string, cache?: Map<string, ScriptMetadata>): Promise<Command[]>;
-    /**
-     * Attach all lua scripts in a given directory to a client instance
-     * @param client - redis client to attach script to
-     * @param pathname - the path to the directory containing the scripts
-     */
-    load(client: RedisClient, pathname: string, cache?: Map<string, ScriptMetadata>): Promise<void>;
-    /**
-     * Clears the command cache
-     */
-    clearCache(): void;
-}

package/dist/esm/enums/error-code.enum.d.ts

@@ -1,8 +0,0 @@
-export declare enum ErrorCode {
-    JobNotExist = -1,
-    JobLockNotExist = -2,
-    JobNotInState = -3,
-    JobPendingDependencies = -4,
-    ParentJobNotExist = -5,
-    JobLockMismatch = -6
-}

package/dist/esm/enums/index.d.ts

@@ -1,2 +0,0 @@
-export * from './error-code.enum';
-export * from './metrics-time';

package/dist/esm/enums/metrics-time.d.ts

@@ -1,10 +0,0 @@
-export declare enum MetricsTime {
-    ONE_MINUTE = 1,
-    FIVE_MINUTES = 5,
-    FIFTEEN_MINUTES = 15,
-    THIRTY_MINUTES = 30,
-    ONE_HOUR = 60,
-    ONE_WEEK = 10080,
-    TWO_WEEKS = 20160,
-    ONE_MONTH = 80640
-}

package/dist/esm/index.d.ts

@@ -1,6 +0,0 @@
-export * from './classes';
-export * from './commands';
-export * from './enums';
-export * from './interfaces';
-export * from './types';
-export * from './utils';

package/dist/esm/interfaces/advanced-options.d.ts

@@ -1,13 +0,0 @@
-import { BackoffStrategy, RepeatStrategy } from '../types';
-export interface AdvancedRepeatOptions {
-    /**
-     * A custom cron strategy.
-     */
-    repeatStrategy?: RepeatStrategy;
-}
-export interface AdvancedOptions extends AdvancedRepeatOptions {
-    /**
-     * A custom backoff strategy.
-     */
-    backoffStrategy?: BackoffStrategy;
-}

package/dist/esm/interfaces/backoff-options.d.ts

@@ -1,15 +0,0 @@
-/**
- * Settings for backing off failed jobs.
- *
- * @see {@link https://docs.bullmq.io/guide/retrying-failing-jobs}
- */
-export interface BackoffOptions {
-    /**
-     * Name of the backoff strategy.
-     */
-    type: 'fixed' | 'exponential' | (string & {});
-    /**
-     * Delay in milliseconds.
-     */
-    delay?: number;
-}

package/dist/esm/interfaces/base-job-options.d.ts

@@ -1,92 +0,0 @@
-import { RepeatOptions, KeepJobs, BackoffOptions } from './';
-export interface DefaultJobOptions {
-    /**
-     * Timestamp when the job was created.
-     * @defaultValue Date.now()
-     */
-    timestamp?: number;
-    /**
-     * Ranges from 1 (highest priority) to MAX_INT (lowest priority). Note that
-     * using priorities has a slight impact on performance,
-     * so do not use it if not required.
-     */
-    priority?: number;
-    /**
-     * An amount of milliseconds to wait until this job can be processed.
-     * Note that for accurate delays, worker and producers
-     * should have their clocks synchronized.
-     * @defaultValue 0
-     */
-    delay?: number;
-    /**
-     * The total number of attempts to try the job until it completes.
-     * @defaultValue 0
-     */
-    attempts?: number;
-    /**
-     * Backoff setting for automatic retries if the job fails
-     */
-    backoff?: number | BackoffOptions;
-    /**
-     * If true, adds the job to the right of the queue instead of the left (default false)
-     *
-     * @see {@link https://docs.bullmq.io/guide/jobs/lifo}
-     */
-    lifo?: boolean;
-    /**
-     * If true, removes the job when it successfully completes
-     * When given a number, it specifies the maximum amount of
-     * jobs to keep, or you can provide an object specifying max
-     * age and/or count to keep.
-     * Default behavior is to keep the job in the completed set.
-     */
-    removeOnComplete?: boolean | number | KeepJobs;
-    /**
-     * If true, removes the job when it fails after all attempts.
-     * When given a number, it specifies the maximum amount of
-     * jobs to keep, or you can provide an object specifying max
-     * age and/or count to keep.
-     */
-    removeOnFail?: boolean | number | KeepJobs;
-    /**
-     * Maximum amount of log entries that will be preserved
-     */
-    keepLogs?: number;
-    /**
-     * Limits the amount of stack trace lines that will be recorded in the stacktrace.
-     */
-    stackTraceLimit?: number;
-    /**
-     * Limits the size in bytes of the job's data payload (as a JSON serialized string).
-     */
-    sizeLimit?: number;
-}
-export interface BaseJobOptions extends DefaultJobOptions {
-    /**
-     * Repeat this job, for example based on a `cron` schedule.
-     */
-    repeat?: RepeatOptions;
-    /**
-     * Internal property used by repeatable jobs to save base repeat job key.
-     */
-    repeatJobKey?: string;
-    /**
-     * Override the job ID - by default, the job ID is a unique
-     * integer, but you can use this setting to override it.
-     * If you use this option, it is up to you to ensure the
-     * jobId is unique. If you attempt to add a job with an id that
-     * already exists, it will not be added.
-     */
-    jobId?: string;
-    /**
-     *
-     */
-    parent?: {
-        id: string;
-        queue: string;
-    };
-    /**
-     * Internal property used by repeatable jobs.
-     */
-    prevMillis?: number;
-}

package/dist/esm/interfaces/child-command.d.ts

@@ -1,5 +0,0 @@
-export declare enum ChildCommand {
-    Init = 0,
-    Start = 1,
-    Stop = 2
-}

package/dist/esm/interfaces/child-message.d.ts

@@ -1,6 +0,0 @@
-import { ParentCommand } from './parent-command';
-export interface ChildMessage {
-    cmd: ParentCommand;
-    value?: any;
-    err?: Record<string, any>;
-}

package/dist/esm/interfaces/connection.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { Cluster, Redis } from 'ioredis';
-export type RedisClient = Redis | Cluster;
-export interface IConnection extends EventEmitter {
-    waitUntilReady(): Promise<boolean>;
-    client: Promise<RedisClient>;
-}