<summary>Returns the current state of this job.</summary>

* Moves an active job to the completed state and, optionally, fetches the * next job to process. * @returns The next job data tuple when `fetchN

* Moves an active job to the failed state and, optionally, fetches the next * job to process. * @returns The next job data tuple when `fetchNext

Completely destroys the queue and all of its contents irreversibly. This method will the *pause* the queue and requires that there ar

Retry a completed or failed job by moving it back to the wait queue. `state` should be `"failed"` or `"completed"`.

* Updates a job's progress * * @param progress - number or object to be saved as progress.

Clean jobs from a specific set (completed, failed, etc.). `grace` - Only remove jobs older than this many milliseconds. `limit` - Maximum number of j

Check if an error is a connection-related error that should trigger a retry with backoff rather than being surfaced to the user.

All rows as ``column -> value`` dicts.

* Wraps the code with telemetry and provides a span for configuration. * * @param spanKind - kind of the span: Producer, Consumer, Internal *

Create or update a job scheduler. See JobScheduler.upsertJobScheduler.

<summary>All rows as column -&gt; value maps.</summary>

* Returns the active context

SET one or more hash fields from a field→value map.

* Moves a parent job to the waiting-children state. * @returns `true` if moved, `false` if there are pending dependencies.

* Returns a job's children dependencies (processed/unprocessed/ignored/failed).

Returns the job counts for each type specified or every list/set in the queue by default. @returns: An object, key (type) and value

Return the jobs that are in the given states with pagination. `types` are state names. An empty slice returns jobs from all states.

* Moves a job to the delayed state, scheduling it to run after `delay` ms.

The job's options.

Parse a stream entry's fields into a typed [`QueueEvent`].

Pauses the processing of this queue globally. We use an atomic RENAME operation on the wait queue. Since we have blocking ca

Attach a script execution context (set by the worker before processing).

Serialize a value for a ``$n::jsonb`` parameter. Uses ``allow_nan=False`` so non-JSON-compliant floats raise ``ValueError`` before hitting th

* Adds a single job to the queue, routing it to the correct initial state * (wait / delayed / prioritized / waiting-children) based on its options.

* Creates a new job and adds it to the queue. * * @param queue - the queue where to add the job. * @param name - the name of the job. * @p

Return the total number of jobs across the provided types.

Get the total number of job schedulers.

The queue qualified name (`prefix:queueName`). Only available when the job has a script context (i.e. inside a worker processor).

Remove a job scheduler by its ID. Also removes the next scheduled delayed job if one exists. Returns `true` if the scheduler was found and removed.

Close the flow instance.

The underlying Redis connection.

* Removes waiting (and optionally delayed) jobs from the queue.

* Job counts by type * * Queue#getJobCountByTypes('completed') =\> completed count * Queue#getJobCountByTypes('completed', 'failed') =\> comp

* Get jobs by type/state. * * @param string|array<string> $types Job states (waiting, active, delayed, completed, failed) * @param int

Returns a promise that resolves to the next job in queue. @param token: worker token to be assigned to retrieved job @returns

* 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 un

Get the failure values of children that failed with `ignoreDependencyOnFailure`. Returns a map of `{queue_prefix:queue_name:job_id => failure_reason}

Manually fetch the next job (blocking — waits for a job to become available).

Validate a queue name using the same separator restriction as BullMQ Node.js.

* Blocks (up to `blockTimeout` seconds) until the queue signals that a new * job may be available, returning the next "block-until" timestamp. *

<summary>Creates a job and adds it to the queue via the backend.</summary>

<summary>Returns the number of jobs waiting to be processed.</summary>

<summary>Waits until the queue's connection is ready.</summary>

Add a flow atomically. The whole tree is committed inside a single MULTI/EXEC. Mirrors the Node implementation: - A negative

Number of attempts made so far.

* Block until an element is available in the given sorted set, or the * timeout expires. * * The return shape mirrors ioredis' native `bzpopm

Cancel the token, notifying all waiters.

Execute a Redis command directly.

Return the number of jobs waiting to be processed: this sums `waiting`, `paused`, `delayed`, `prioritized` and `waiting-children`.

Create a duplicate connection with optional overrides.

Convert a [`Duration`] to whole milliseconds, saturating at [`u64::MAX`].

* Fetches a Job from the queue given the passed job id. * * @param queue - the queue where the job belongs to. * @param jobId - the job id.

* Get the underlying Redis client. */

* Returns a page of a job's logs together with the total log count.

* Returns the jobs that are on the given statuses (note that JobType is synonym for job status) * @param types - the statuses of the jobs to return

Get the return values of all completed children. Returns a map of `{queue_prefix:queue_name:job_id => return_value}`. The values are JSON-parsed from

Get a paginated view of this parent job's dependencies. `processed_cursor` / `unprocessed_cursor` are HSCAN/SSCAN cursors (start at 0). `count` is a

Retrieve an existing flow tree from Redis. Reconstructs the parent-child tree by loading jobs and their dependencies.

* Promotes a single delayed job so it can be processed as soon as possible.