Map a ``job`` row into the Redis-hash-shaped dict ``Job.fromJSON`` consumes (JSON-string values for the object fields, string values for the r

* Wire up Bun's callback-style events into EventEmitter and auto-reconnect.

Mirror `JobScheduler.transformSchedulerData` from the Node port. If the per-id hash exists, produce the rich record. Otherwise, fall back to

Adds an array of jobs to the queue. This method may be faster than adding one job at a time in a sequence

* Atomically inserts a flow (tree) of jobs that may span multiple queues, * returning one `[error, idOrCode]` tuple per entry, in the same order th

* Registers a job scheduler and enqueues its next delayed iteration. * * Two job-option bags are involved, with deliberately different roles:

* Low-level Redis adapter helper: queues/executes a single job insert on the * provided client or transaction (pipeline/multi). This is the only pl

* Changes the priority (and optionally lifo) of a waiting job.

Close the worker gracefully. Waits for active jobs to complete (up to `timeout` milliseconds).

Close the queue connection.

Drains the queue, removes all jobs that are waiting or delayed, but not active, completed or failed. @param delayed:

Return the LISTEN connection after subscribing to ``bullmq_jobs`` once.

Execute all queued commands.

* Extends the lock of a single active job.

* Extends the lock of several active jobs at once. * @returns The ids of the jobs whose lock could not be extended.

Instantiates a Job from a JobJsonRaw object (coming from a deserialized JSON object) @param queue: the queue where the job belongs t

* Get this jobs children result values if any. * * @returns Object mapping children job keys with their values.

* Returns the stored data for a job, or `undefined` if it is missing.

* Get all Job Schedulers * * @param start - Offset of first scheduler to return. * @param end - Offset of last scheduler to return. * @par

* Returns the number of registered job schedulers.

* Get jobs by their IDs. * * @param array<string> $jobIds The job IDs * @return array<Job> Array of jobs (excluding not found jobs)

* Returns the dedicated client used for `LISTEN`/`NOTIFY`, establishing it on * first use. * * When this connection owns the pool we use a *s

* Get the worker list related to the queue. i.e. all the known * workers that are available to process jobs for this queue. * Note: GCP does not

Return the number of jobs in the `completed` state.

Get a paginated list of job schedulers. Returns schedulers ordered by next execution time.

Return the time-series metrics for the queue. `metric_type` must be `"completed"` or `"failed"`. Metrics are recorded per minute by workers configure

Get the worker list related to the queue. i.e. all the known workers that are available to process jobs for this queue. Note:

Return the list of workers currently connected to this queue. Workers register themselves via `CLIENT SETNAME` on their blocking connection; this met

The worker's unique ID.

The dedicated autocommit connection used for LISTEN/NOTIFY waits.

* Atomically moves the next eligible job from wait/prioritized to active, * returning its data (or the delay/rate-limit signals when none is ready)

* Overrides the rate limit to be active for the next jobs. * * @param expireTimeMs - expire time in ms of this rate limit.

Override the rate limit to be active for the next jobs. Sets the rate limiter key to MAX value with the given TTL, preventing any new jobs from being

Remove global concurrency limit from queue meta.

Resolve `ParentOptions.queue` into a qualified queue key. Accepts either an unqualified queue name (`queue`) or a pre-qualified key using the current

Attempts to retry the job. Only a job that has failed or completed can be retried. Args: state: The state of the job to

Retry a coroutine function if it fails, with delay and max retries. :param fn: Coroutine function to execute. :param opts: Di

Retry all the failed or completed jobs.

* Execute a previously registered Lua script command by name. * * @param name - The command name passed to {@link defineCommand}. * @param ar

* Sets one or more queue metadata fields.

Set global rate limit (stored in queue meta hash).

* Starts the lock manager timers for lock renewal.

Update a job's progress by id, without loading the job first. Mirrors Node.js `Queue.updateJobProgress`: runs the `updateProgress` script which sets

* * Waits until the worker is ready to start processing jobs. * In general only useful when writing tests. *

Wait for the next worker event that matches the predicate, failing on timeout.

* Trim a stream. * * @param key - Stream key * @param strategy - Trim strategy (e.g. `'MAXLEN'`) * @param threshold - Maximum strea

<summary>Rehydrates a job from its raw Redis representation.</summary>

<summary>Builds a <see cref="JobJson"/> from a flat key/value map.</summary>

<summary>Returns the number of failed jobs.</summary>

<summary>Returns true if the queue is currently paused.</summary>

<summary>Removes this job (and optionally its children).</summary>

<summary> Creates or updates a job scheduler (repeatable job factory) and enqueues its next iteration. Returns the job for that iteration, or null. </

Create a Worker whose Redis port is guaranteed to be closed. The Worker is instantiated with ``autorun=False`` so the run loop never starts;

* Create a fresh raw client aimed at the *same* Redis server as `src`. * * Bun's `RedisClient` exposes no public connection info (no `url`, host

* Return the raw client, materializing it first when this adapter is a * lazily-initialized duplicate (created via `duplicate()` with a * `rawFa

Coerce a date-ish input (epoch millis int/float or ISO 8601 string) into integer epoch milliseconds. Returns None for empty input.

Add multiple flows atomically in a single MULTI/EXEC. Matches Node's lenient bulk semantics: per-root errors are not raised;

* addEvent adds an event to the span. * * @param name - event name * @param attributes - event attributes

* Appends a row to a job's log, optionally trimming old entries. * @returns The total number of log entries.

Build the job for ``node`` (and, recursively, its children) and append it to the flat, pre-ordered ``entries`` list that is later ins

* Add a node (job) of a flow to the queue. This method will recursively * add all its children as well. Note that a given job can potentially be

Atomically add a flow, applying per-queue default job options. For every job whose `queue_name` is present in `opts.queues_options`, the correspondin

* Prepares a job to be serialized for storage in Redis. * @returns

* Prepares a job to be serialized for storage in Redis. * @returns

Parses a nullable `bigint`-as-string column into a number, or `undefined`.