<summary>Returns a job scheduler by id, or null when absent.</summary>

<summary>Returns the number of registered job schedulers.</summary>

<summary>The queue's fully-qualified name (<c>"&lt;prefix&gt;:&lt;name&gt;"</c>).</summary>

<summary> Moves this active job to delayed until <paramref name="timestamp"/> (ms since Unix epoch). Commonly used by manual processors right before t

<summary> Moves the job to the failed state, optionally fetching the next job to process. Retries are handled by the shared scripts based on the job's

<summary>Promotes this delayed job so it can be processed as soon as possible.</summary>

<summary>Updates this job's progress and notifies listeners.</summary>

Translate a root command's result into either an exception (strict path) or an id reconciliation (lenient path). - `strict=T

Build the exception matching the Redis backend's error for ``code``.

Normalize ``removeOnComplete``/``removeOnFail`` into ``(remove_all, keep_age, keep_count)``.

Queue one flow (root + children) onto `entries` and return the resulting `JobNode`-shaped dict together with the number of ba

Safe lookup into a pipeline result list.

* Schedule a reconnection attempt with exponential backoff.

Map a ``scheduler`` row into the Redis-hash-shaped ``(fields, next)`` pair that :func:`bullmq.job_scheduler._transform_scheduler_data` consumes.

Add a job to the queue. Returns an [`AddJob`] builder that can be awaited directly, or customized fluently before awaiting: ```no_run # async fn dem

* addJobLog * * @param queue - A minimal queue instance * @param jobId - Job id * @param logRow - String with a row of log data to be logg

* Adds many jobs to the queue in a single, efficient operation. * * How the insert is batched (a Redis pipeline, a single multi-row SQL * `IN

Build KEYS array for addStandardJob/addDelayedJob/addPrioritizedJob.

Recursively add a node (job) to the pipeline. If the node has children, it's added as a parent job (waiting-children state). If it has no children, i

Recursively merge per-queue `default_job_options` into every node of a flow. Job-level options always win; defaults only fill in fields left unset.

* Cancels all jobs currently being processed by this worker. * All active job processor functions will receive abort signals. * * @param reas

Abort the signals of every tracked job that has a controller. Called from `Worker.cancelAllJobs` and from `Worker.close(force=True)`

* Changes the delay of a delayed job.

* Clean jobs from a set by state. * * @param int $grace Grace period in milliseconds * @param int $limit Maximum number of jobs to clea

* Clears a job's logs, optionally keeping the most recent `keepLogs` rows.

Clear this job's logs. When `keep_logs` is `Some(n)`, the most recent `n` log entries are kept; otherwise all logs are removed.

* Records one finished job into the per-minute metrics for the given `kind`, * when the worker was created with a `metrics.maxDataPoints`. Mirrors

Compute SHA1 hash of a string (for EVALSHA).

* Creates a new Counter metric instrument. * * @param name - the name of the counter * @param options - optional configuration for the counte

* Creates a new Gauge metric instrument. * * A gauge is a metric that represents a single numerical value that can * arbitrarily go up and do

* Creates a new Histogram metric instrument. * * @param name - the name of the histogram * @param options - optional configuration for the hi

The delay before this job becomes available.

Delay before the job becomes available for processing.

* Unconditionally deletes a deduplication key. * @returns The number of keys removed.

* Emits an event. Normally used by subclasses to emit events. * * @param event - The emitted event. * @param args - The arguments to pass to

* Forwards an underlying pool / LISTEN-client error as this connection's * `'error'` event, but only when a listener is attached. `EventEmitter.emi

* Fetches the next resolved item from the queue in FIFO order. If no * items are currently resolved but pending promises exist, it waits * until

* Returns a sibling backend bound to a different queue (by name) that shares * this backend's underlying connection(s). * * This is used by {

* Instantiates a Job from a {@link JobJson} object (the public, decoded * representation of a stored job). * * @param queue - the queue where

* Create a job from raw Redis data. * * @param Queue $queue * @param array<string, mixed> $rawData * @param string $jobId * @

* Generate a unique job ID. */

* Get active jobs. * * @param int $start Start index * @param int $end End index * @return array<Job> */

* Returns the raw worker/client list(s) for the queue's datastore. For the * Redis adapter this is `CLIENT LIST` (one string per cluster node, or a

* Get the Redis connection. */

Returns the number of jobs per priority. @returns: An object, key (priority) and value (count)

Returns the configured global concurrency value, or None if not set.

* Get prioritized jobs. * * @param int $start Start index * @param int $end End index * @return array<Job> */

* Returns the raw processed-children map (child key → serialized value).

* Get the qualified name of the queue. */

* Get queue events list related to the queue. * Note: GCP does not support SETNAME, so this call will not work * * @deprecated do not use thi

* Reads several queue metadata fields at once, in order.

* Get the fully qualified queue name. * * @param string $name Queue name */

Returns the time to live for a rate limited key in milliseconds.