poolifier 4.2.2 → 4.2.4

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import { EventEmitter, EventEmitterAsyncResource } from 'node:events';
 import { TransferListItem, MessagePort, WorkerOptions as WorkerOptions$1, MessageChannel, Worker as Worker$1 } from 'node:worker_threads';
+import { EventEmitter, EventEmitterAsyncResource } from 'node:events';
 import { AsyncResource } from 'node:async_hooks';
 import { EventLoopUtilization } from 'node:perf_hooks';
 import { ClusterSettings, Worker } from 'node:cluster';
@@ -9,16 +9,21 @@ import { ClusterSettings, Worker } from 'node:cluster';
  * @internal
  */
 declare class CircularBuffer {
-    private readIdx;
-    private writeIdx;
     private readonly items;
     private readonly maxArrayIdx;
+    private readIdx;
+    private writeIdx;
     size: number;
     /**
      * @param size - Buffer size. @defaultValue defaultBufferSize
      * @returns CircularBuffer.
      */
     constructor(size?: number);
+    /**
+     * Checks the buffer size.
+     * @param size - Buffer size.
+     */
+    private checkSize;
     /**
      * Checks whether the buffer is empty.
      * @returns Whether the buffer is empty.
@@ -29,39 +34,34 @@ declare class CircularBuffer {
      * @returns Whether the buffer is full.
      */
     full(): boolean;
-    /**
-     * Puts number into buffer.
-     * @param number - Number to put into buffer.
-     */
-    put(number: number): void;
     /**
      * Gets number from buffer.
      * @returns Number from buffer.
      */
     get(): number | undefined;
+    /**
+     * Puts number into buffer.
+     * @param number - Number to put into buffer.
+     */
+    put(number: number): void;
     /**
      * Returns buffer as numbers' array.
      * @returns Numbers' array.
      */
     toArray(): number[];
-    /**
-     * Checks the buffer size.
-     * @param size - Buffer size.
-     */
-    private checkSize;
 }
 
 /**
  * Enumeration of worker choice strategies.
  */
 declare const WorkerChoiceStrategies: Readonly<{
-    ROUND_ROBIN: 'ROUND_ROBIN';
-    LEAST_USED: 'LEAST_USED';
+    FAIR_SHARE: 'FAIR_SHARE';
+    INTERLEAVED_WEIGHTED_ROUND_ROBIN: 'INTERLEAVED_WEIGHTED_ROUND_ROBIN';
     LEAST_BUSY: 'LEAST_BUSY';
     LEAST_ELU: 'LEAST_ELU';
-    FAIR_SHARE: 'FAIR_SHARE';
+    LEAST_USED: 'LEAST_USED';
+    ROUND_ROBIN: 'ROUND_ROBIN';
     WEIGHTED_ROUND_ROBIN: 'WEIGHTED_ROUND_ROBIN';
-    INTERLEAVED_WEIGHTED_ROUND_ROBIN: 'INTERLEAVED_WEIGHTED_ROUND_ROBIN';
 }>;
 /**
  * Worker choice strategy.
@@ -71,9 +71,9 @@ type WorkerChoiceStrategy = keyof typeof WorkerChoiceStrategies;
  * Enumeration of measurements.
  */
 declare const Measurements: Readonly<{
+    elu: 'elu';
     runTime: 'runTime';
     waitTime: 'waitTime';
-    elu: 'elu';
 }>;
 /**
  * Measurement.
@@ -92,6 +92,11 @@ interface MeasurementOptions {
  * Worker choice strategy options.
  */
 interface WorkerChoiceStrategyOptions {
+    /**
+     * Event loop utilization options.
+     * @defaultValue \{ median: false \}
+     */
+    readonly elu?: MeasurementOptions;
     /**
      * Measurement to use in worker choice strategy supporting it.
      */
@@ -106,11 +111,6 @@ interface WorkerChoiceStrategyOptions {
      * @defaultValue \{ median: false \}
      */
     readonly waitTime?: MeasurementOptions;
-    /**
-     * Event loop utilization options.
-     * @defaultValue \{ median: false \}
-     */
-    readonly elu?: MeasurementOptions;
     /**
      * Worker weights to use for weighted round robin worker selection strategies.
      * A weight is tasks maximum execution time in milliseconds for a worker node.
@@ -141,6 +141,10 @@ interface MeasurementStatisticsRequirements {
  * @internal
  */
 interface TaskStatisticsRequirements {
+    /**
+     * Tasks event loop utilization requirements.
+     */
+    readonly elu: MeasurementStatisticsRequirements;
     /**
      * Tasks runtime requirements.
      */
@@ -149,49 +153,26 @@ interface TaskStatisticsRequirements {
      * Tasks wait time requirements.
      */
     readonly waitTime: MeasurementStatisticsRequirements;
-    /**
-     * Tasks event loop utilization requirements.
-     */
-    readonly elu: MeasurementStatisticsRequirements;
 }
 /**
  * Strategy policy.
  * @internal
  */
 interface StrategyPolicy {
-    /**
-     * Expects tasks execution on the newly created dynamic worker.
-     */
-    readonly dynamicWorkerUsage: boolean;
     /**
      * Expects the newly created dynamic worker to be flagged as ready.
      */
     readonly dynamicWorkerReady: boolean;
+    /**
+     * Expects tasks execution on the newly created dynamic worker.
+     */
+    readonly dynamicWorkerUsage: boolean;
 }
 /**
  * Worker choice strategy interface.
  * @internal
  */
 interface IWorkerChoiceStrategy {
-    /**
-     * Strategy policy.
-     */
-    readonly strategyPolicy: StrategyPolicy;
-    /**
-     * Tasks statistics requirements.
-     */
-    readonly taskStatisticsRequirements: TaskStatisticsRequirements;
-    /**
-     * Resets strategy internals.
-     * @returns `true` if the reset is successful, `false` otherwise.
-     */
-    readonly reset: () => boolean;
-    /**
-     * Updates the worker node key strategy internals.
-     * This is called after a task has been executed on a worker node.
-     * @returns `true` if the update is successful, `false` otherwise.
-     */
-    readonly update: (workerNodeKey: number) => boolean;
     /**
      * Chooses a worker node in the pool and returns its key.
      * If no worker nodes are not eligible, `undefined` is returned.
@@ -205,19 +186,38 @@ interface IWorkerChoiceStrategy {
      * @returns `true` if the worker node key is removed, `false` otherwise.
      */
     readonly remove: (workerNodeKey: number) => boolean;
+    /**
+     * Resets strategy internals.
+     * @returns `true` if the reset is successful, `false` otherwise.
+     */
+    readonly reset: () => boolean;
     /**
      * Sets the worker choice strategy options.
      * @param opts - The worker choice strategy options.
      */
-    readonly setOptions: (opts: WorkerChoiceStrategyOptions | undefined) => void;
+    readonly setOptions: (opts: undefined | WorkerChoiceStrategyOptions) => void;
+    /**
+     * Strategy policy.
+     */
+    readonly strategyPolicy: StrategyPolicy;
+    /**
+     * Tasks statistics requirements.
+     */
+    readonly taskStatisticsRequirements: TaskStatisticsRequirements;
+    /**
+     * Updates the worker node key strategy internals.
+     * This is called after a task has been executed on a worker node.
+     * @returns `true` if the update is successful, `false` otherwise.
+     */
+    readonly update: (workerNodeKey: number) => boolean;
 }
 
 /**
  * Enumeration of kill behaviors.
  */
 declare const KillBehaviors: Readonly<{
-    SOFT: 'SOFT';
     HARD: 'HARD';
+    SOFT: 'SOFT';
 }>;
 /**
  * Kill behavior.
@@ -226,7 +226,7 @@ type KillBehavior = keyof typeof KillBehaviors;
 /**
  * Handler called when a worker is killed.
  */
-type KillHandler = () => void | Promise<void>;
+type KillHandler = () => Promise<void> | void;
 /**
  * Options for workers.
  */
@@ -241,6 +241,11 @@ interface WorkerOptions {
      * @defaultValue KillBehaviors.SOFT
      */
     killBehavior?: KillBehavior;
+    /**
+     * The function to call when a worker is killed.
+     * @defaultValue `() => {}`
+     */
+    killHandler?: KillHandler;
     /**
      * Maximum waiting time in milliseconds for tasks on newly created workers. It must be greater or equal than 5.
      *
@@ -253,11 +258,6 @@ interface WorkerOptions {
      * @defaultValue 60000
      */
     maxInactiveTime?: number;
-    /**
-     * The function to call when a worker is killed.
-     * @defaultValue `() => {}`
-     */
-    killHandler?: KillHandler;
 }
 
 /**
@@ -266,17 +266,17 @@ interface WorkerOptions {
  */
 interface WorkerError<Data = unknown> {
     /**
-     * Task function name triggering the error.
+     * Data triggering the error.
      */
-    readonly name: string;
+    readonly data?: Data;
     /**
      * Error message.
      */
     readonly message: string;
     /**
-     * Data triggering the error.
+     * Task function name triggering the error.
      */
-    readonly data?: Data;
+    readonly name: string;
 }
 /**
  * Task performance.
@@ -284,35 +284,35 @@ interface WorkerError<Data = unknown> {
  */
 interface TaskPerformance {
     /**
-     * Task name.
+     * Task event loop utilization.
      */
-    readonly name: string;
+    readonly elu?: EventLoopUtilization;
     /**
-     * Task performance timestamp.
+     * Task name.
      */
-    readonly timestamp: number;
+    readonly name: string;
     /**
      * Task runtime.
      */
     readonly runTime?: number;
     /**
-     * Task event loop utilization.
+     * Task performance timestamp.
      */
-    readonly elu?: EventLoopUtilization;
+    readonly timestamp: number;
 }
 /**
  * Worker task performance statistics computation settings.
  * @internal
  */
 interface WorkerStatistics {
-    /**
-     * Whether the worker computes the task runtime or not.
-     */
-    readonly runTime: boolean;
     /**
      * Whether the worker computes the task event loop utilization (ELU) or not.
      */
     readonly elu: boolean;
+    /**
+     * Whether the worker computes the task runtime or not.
+     */
+    readonly runTime: boolean;
 }
 /**
  * Task function properties.
@@ -337,14 +337,14 @@ interface TaskFunctionProperties {
  * @internal
  */
 interface Task<Data = unknown> {
-    /**
-     * Task name.
-     */
-    readonly name?: string;
     /**
      * Task input data that will be passed to the worker.
      */
     readonly data?: Data;
+    /**
+     * Task name.
+     */
+    readonly name?: string;
     /**
      * Task priority. Lower values have higher priority.
      * @defaultValue 0
@@ -355,17 +355,17 @@ interface Task<Data = unknown> {
      */
     readonly strategy?: WorkerChoiceStrategy;
     /**
-     * Array of transferable objects.
+     * Task UUID.
      */
-    readonly transferList?: readonly TransferListItem[];
+    readonly taskId?: `${string}-${string}-${string}-${string}-${string}`;
     /**
      * Timestamp.
      */
     readonly timestamp?: number;
     /**
-     * Task UUID.
+     * Array of transferable objects.
      */
-    readonly taskId?: `${string}-${string}-${string}-${string}-${string}`;
+    readonly transferList?: readonly TransferListItem[];
 }
 /**
  * Message object that is passed between main worker and worker.
@@ -375,28 +375,36 @@ interface Task<Data = unknown> {
  */
 interface MessageValue<Data = unknown, ErrorData = unknown> extends Task<Data> {
     /**
-     * Worker id.
+     * Whether the worker starts or stops its activity check.
      */
-    readonly workerId?: number;
+    readonly checkActive?: boolean;
     /**
      * Kill code.
      */
-    readonly kill?: KillBehavior | true | 'success' | 'failure';
+    readonly kill?: 'failure' | 'success' | KillBehavior | true;
     /**
-     * Worker error.
+     * Message port.
      */
-    readonly workerError?: WorkerError<ErrorData>;
+    readonly port?: MessagePort;
     /**
-     * Task performance.
+     * Whether the worker is ready or not.
      */
-    readonly taskPerformance?: TaskPerformance;
+    readonly ready?: boolean;
+    /**
+     * Whether the worker computes the given statistics or not.
+     */
+    readonly statistics?: WorkerStatistics;
+    /**
+     * Task function serialized to string.
+     */
+    readonly taskFunction?: string;
     /**
      * Task function operation:
      * - `'add'` - Add a task function.
      * - `'remove'` - Remove a task function.
      * - `'default'` - Set a task function as default.
      */
-    readonly taskFunctionOperation?: 'add' | 'remove' | 'default';
+    readonly taskFunctionOperation?: 'add' | 'default' | 'remove';
     /**
      * Whether the task function operation is successful or not.
      */
@@ -405,30 +413,22 @@ interface MessageValue<Data = unknown, ErrorData = unknown> extends Task<Data> {
      * Task function properties.
      */
     readonly taskFunctionProperties?: TaskFunctionProperties;
-    /**
-     * Task function serialized to string.
-     */
-    readonly taskFunction?: string;
     /**
      * Task functions properties.
      */
     readonly taskFunctionsProperties?: TaskFunctionProperties[];
     /**
-     * Whether the worker computes the given statistics or not.
-     */
-    readonly statistics?: WorkerStatistics;
-    /**
-     * Whether the worker is ready or not.
+     * Task performance.
      */
-    readonly ready?: boolean;
+    readonly taskPerformance?: TaskPerformance;
     /**
-     * Whether the worker starts or stops its activity check.
+     * Worker error.
      */
-    readonly checkActive?: boolean;
+    readonly workerError?: WorkerError<ErrorData>;
     /**
-     * Message port.
+     * Worker id.
      */
-    readonly port?: MessagePort;
+    readonly workerId?: number;
 }
 /**
  * An object holding the task execution response promise resolve/reject callbacks.
@@ -437,21 +437,21 @@ interface MessageValue<Data = unknown, ErrorData = unknown> extends Task<Data> {
  */
 interface PromiseResponseWrapper<Response = unknown> {
     /**
-     * Resolve callback to fulfill the promise.
+     * The asynchronous resource used to track the task execution.
      */
-    readonly resolve: (value: Response | PromiseLike<Response>) => void;
+    readonly asyncResource?: AsyncResource;
     /**
      * Reject callback to reject the promise.
      */
     readonly reject: (reason?: unknown) => void;
     /**
-     * The worker node key executing the task.
+     * Resolve callback to fulfill the promise.
      */
-    readonly workerNodeKey: number;
+    readonly resolve: (value: PromiseLike<Response> | Response) => void;
     /**
-     * The asynchronous resource used to track the task execution.
+     * The worker node key executing the task.
      */
-    readonly asyncResource?: AsyncResource;
+    readonly workerNodeKey: number;
 }
 /**
  * Remove readonly modifier from all properties of T.
@@ -485,17 +485,13 @@ type TaskAsyncFunction<Data = unknown, Response = unknown> = (data?: Data) => Pr
  * @typeParam Data - Type of data sent to the worker. This can only be structured-cloneable data.
  * @typeParam Response - Type of execution response. This can only be structured-cloneable data.
  */
-type TaskFunction<Data = unknown, Response = unknown> = TaskSyncFunction<Data, Response> | TaskAsyncFunction<Data, Response>;
+type TaskFunction<Data = unknown, Response = unknown> = TaskAsyncFunction<Data, Response> | TaskSyncFunction<Data, Response>;
 /**
  * Task function object.
  * @typeParam Data - Type of data sent to the worker. This can only be structured-cloneable data.
  * @typeParam Response - Type of execution response. This can only be structured-cloneable data.
  */
 interface TaskFunctionObject<Data = unknown, Response = unknown> {
-    /**
-     * Task function.
-     */
-    taskFunction: TaskFunction<Data, Response>;
     /**
      * Task function priority. Lower values have higher priority.
      */
@@ -504,6 +500,10 @@ interface TaskFunctionObject<Data = unknown, Response = unknown> {
      * Task function worker choice strategy.
      */
     strategy?: WorkerChoiceStrategy;
+    /**
+     * Task function.
+     */
+    taskFunction: TaskFunction<Data, Response>;
 }
 /**
  * Tasks functions that can be executed.
@@ -517,8 +517,8 @@ type TaskFunctions<Data = unknown, Response = unknown> = Record<string, TaskFunc
  * Task function operation result.
  */
 interface TaskFunctionOperationResult {
-    status: boolean;
     error?: Error;
+    status: boolean;
 }
 
 /**
@@ -545,7 +545,7 @@ type ExitHandler<Worker extends IWorker> = (this: Worker, exitCode: number) => v
  * Worker event handler.
  * @typeParam Worker - Type of worker.
  */
-type EventHandler<Worker extends IWorker> = OnlineHandler<Worker> | MessageHandler<Worker> | ErrorHandler<Worker> | ExitHandler<Worker>;
+type EventHandler<Worker extends IWorker> = ErrorHandler<Worker> | ExitHandler<Worker> | MessageHandler<Worker> | OnlineHandler<Worker>;
 /**
  * Measurement statistics.
  * @internal
@@ -556,33 +556,33 @@ interface MeasurementStatistics {
      */
     aggregate?: number;
     /**
-     * Measurement minimum.
+     * Measurement average.
      */
-    minimum?: number;
+    average?: number;
     /**
-     * Measurement maximum.
+     * Measurement history.
      */
-    maximum?: number;
+    readonly history: CircularBuffer;
     /**
-     * Measurement average.
+     * Measurement maximum.
      */
-    average?: number;
+    maximum?: number;
     /**
      * Measurement median.
      */
     median?: number;
     /**
-     * Measurement history.
+     * Measurement minimum.
      */
-    readonly history: CircularBuffer;
+    minimum?: number;
 }
 /**
  * Event loop utilization measurement statistics.
  * @internal
  */
 interface EventLoopUtilizationMeasurementStatistics {
-    readonly idle: MeasurementStatistics;
     readonly active: MeasurementStatistics;
+    readonly idle: MeasurementStatistics;
     utilization?: number;
 }
 /**
@@ -599,13 +599,17 @@ interface TaskStatistics {
      */
     executing: number;
     /**
-     * Number of queued tasks.
+     * Number of failed tasks.
      */
-    readonly queued: number;
+    failed: number;
     /**
      * Maximum number of queued tasks.
      */
     readonly maxQueued?: number;
+    /**
+     * Number of queued tasks.
+     */
+    readonly queued: number;
     /**
      * Number of sequentially stolen tasks.
      */
@@ -614,17 +618,13 @@ interface TaskStatistics {
      * Number of stolen tasks.
      */
     stolen: number;
-    /**
-     * Number of failed tasks.
-     */
-    failed: number;
 }
 /**
  * Enumeration of worker types.
  */
 declare const WorkerTypes: Readonly<{
-    thread: 'thread';
     cluster: 'cluster';
+    thread: 'thread';
 }>;
 /**
  * Worker type.
@@ -636,17 +636,28 @@ type WorkerType = keyof typeof WorkerTypes;
  */
 interface WorkerInfo {
     /**
-     * Worker id.
+     * Back pressure flag.
+     * This flag is set to `true` when worker node tasks queue has back pressure.
      */
-    readonly id: number | undefined;
+    backPressure: boolean;
     /**
-     * Worker type.
+     * Back pressure stealing flag.
+     * This flag is set to `true` when worker node is stealing one task from another back pressured worker node.
      */
-    readonly type: WorkerType;
+    backPressureStealing: boolean;
     /**
-     * Dynamic flag.
+     * Continuous stealing flag.
+     * This flag is set to `true` when worker node is continuously stealing tasks from other worker nodes.
+     */
+    continuousStealing: boolean;
+    /**
+     * Dynamic flag.
      */
     dynamic: boolean;
+    /**
+     * Worker id.
+     */
+    readonly id: number | undefined;
     /**
      * Ready flag.
      */
@@ -661,20 +672,14 @@ interface WorkerInfo {
      * This flag is set to `true` when worker node has one task stolen from another worker node.
      */
     stolen: boolean;
-    /**
-     * Continuous stealing flag.
-     * This flag is set to `true` when worker node continuously steal tasks from other worker nodes.
-     */
-    continuousStealing: boolean;
-    /**
-     * Back pressure flag.
-     * This flag is set to `true` when worker node tasks queue has back pressure.
-     */
-    backPressure: boolean;
     /**
      * Task functions properties.
      */
     taskFunctionsProperties?: TaskFunctionProperties[];
+    /**
+     * Worker type.
+     */
+    readonly type: WorkerType;
 }
 /**
  * Worker usage statistics.
@@ -682,21 +687,21 @@ interface WorkerInfo {
  */
 interface WorkerUsage {
     /**
-     * Tasks statistics.
+     * Tasks event loop utilization statistics.
      */
-    readonly tasks: TaskStatistics;
+    readonly elu: EventLoopUtilizationMeasurementStatistics;
     /**
      * Tasks runtime statistics.
      */
     readonly runTime: MeasurementStatistics;
     /**
-     * Tasks wait time statistics.
+     * Tasks statistics.
      */
-    readonly waitTime: MeasurementStatistics;
+    readonly tasks: TaskStatistics;
     /**
-     * Tasks event loop utilization statistics.
+     * Tasks wait time statistics.
      */
-    readonly elu: EventLoopUtilizationMeasurementStatistics;
+    readonly waitTime: MeasurementStatistics;
 }
 /**
  * Worker choice strategy data.
@@ -709,14 +714,18 @@ interface StrategyData {
  * Worker interface.
  */
 interface IWorker extends EventEmitter {
+    /**
+     * Cluster worker disconnect.
+     */
+    readonly disconnect?: () => void;
     /**
      * Cluster worker id.
      */
     readonly id?: number;
     /**
-     * Worker thread worker id.
+     * Cluster worker kill.
      */
-    readonly threadId?: number;
+    readonly kill?: (signal?: string) => void;
     /**
      * Registers an event handler.
      * @param event - The event.
@@ -729,36 +738,32 @@ interface IWorker extends EventEmitter {
      * @param handler - The event handler.
      */
     readonly once: (event: string, handler: EventHandler<this>) => this;
-    /**
-     * Calling `unref()` on a worker allows the thread to exit if this is the only
-     * active handle in the event system. If the worker is already `unref()`ed calling`unref()` again has no effect.
-     * @since v10.5.0
-     */
-    readonly unref?: () => void;
     /**
      * Stop all JavaScript execution in the worker thread as soon as possible.
      * Returns a Promise for the exit code that is fulfilled when the `'exit' event` is emitted.
      */
     readonly terminate?: () => Promise<number>;
     /**
-     * Cluster worker disconnect.
+     * Worker thread worker id.
      */
-    readonly disconnect?: () => void;
+    readonly threadId?: number;
     /**
-     * Cluster worker kill.
+     * Calling `unref()` on a worker allows the thread to exit if this is the only
+     * active handle in the event system. If the worker is already `unref()`ed calling`unref()` again has no effect.
+     * @since v10.5.0
      */
-    readonly kill?: (signal?: string) => void;
+    readonly unref?: () => void;
 }
 /**
  * Worker node options.
  * @internal
  */
 interface WorkerNodeOptions {
-    workerOptions?: WorkerOptions$1;
     env?: Record<string, unknown>;
     tasksQueueBackPressureSize: number | undefined;
     tasksQueueBucketSize: number | undefined;
     tasksQueuePriority: boolean | undefined;
+    workerOptions?: WorkerOptions$1;
 }
 /**
  * Worker node interface.
@@ -768,41 +773,26 @@ interface WorkerNodeOptions {
  */
 interface IWorkerNode<Worker extends IWorker, Data = unknown> extends EventEmitter {
     /**
-     * Worker.
-     */
-    readonly worker: Worker;
-    /**
-     * Worker info.
-     */
-    readonly info: WorkerInfo;
-    /**
-     * Worker usage statistics.
-     */
-    readonly usage: WorkerUsage;
-    /**
-     * Worker choice strategy data.
-     * This is used to store data that are specific to the worker choice strategy.
-     */
-    strategyData?: StrategyData;
-    /**
-     * Message channel (worker thread only).
+     * Clears tasks queue.
      */
-    readonly messageChannel?: MessageChannel;
+    readonly clearTasksQueue: () => void;
     /**
-     * Tasks queue back pressure size.
-     * This is the number of tasks that can be enqueued before the worker node has back pressure.
+     * Deletes task function worker usage statistics.
+     * @param name - The task function name.
+     * @returns `true` if the task function worker usage statistics were deleted, `false` otherwise.
      */
-    tasksQueueBackPressureSize: number;
+    readonly deleteTaskFunctionWorkerUsage: (name: string) => boolean;
     /**
-     * Sets tasks queue priority.
-     * @param enablePriority - Whether to enable tasks queue priority.
+     * Dequeue last prioritized task.
+     * @returns The dequeued task.
      */
-    readonly setTasksQueuePriority: (enablePriority: boolean) => void;
+    readonly dequeueLastPrioritizedTask: () => Task<Data> | undefined;
     /**
-     * Tasks queue size.
-     * @returns The tasks queue size.
+     * Dequeue task.
+     * @param bucket - The prioritized bucket to dequeue from. @defaultValue 0
+     * @returns The dequeued task.
      */
-    readonly tasksQueueSize: () => number;
+    readonly dequeueTask: (bucket?: number) => Task<Data> | undefined;
     /**
      * Enqueue task.
      * @param task - The task to queue.
@@ -810,29 +800,30 @@ interface IWorkerNode<Worker extends IWorker, Data = unknown> extends EventEmitt
      */
     readonly enqueueTask: (task: Task<Data>) => number;
     /**
-     * Dequeue task.
-     * @param bucket - The prioritized bucket to dequeue from. @defaultValue 0
-     * @returns The dequeued task.
+     * Gets task function worker usage statistics.
+     * @param name - The task function name.
+     * @returns The task function worker usage statistics if the task function worker usage statistics are initialized, `undefined` otherwise.
      */
-    readonly dequeueTask: (bucket?: number) => Task<Data> | undefined;
+    readonly getTaskFunctionWorkerUsage: (name: string) => undefined | WorkerUsage;
     /**
-     * Dequeue last prioritized task.
-     * @returns The dequeued task.
+     * Whether the worker node has back pressure (i.e. its tasks queue is full).
+     * @returns `true` if the worker node has back pressure, `false` otherwise.
      */
-    readonly dequeueLastPrioritizedTask: () => Task<Data> | undefined;
+    readonly hasBackPressure: () => boolean;
     /**
-     * Clears tasks queue.
+     * Worker info.
      */
-    readonly clearTasksQueue: () => void;
+    readonly info: WorkerInfo;
     /**
-     * Whether the worker node has back pressure (i.e. its tasks queue is full).
-     * @returns `true` if the worker node has back pressure, `false` otherwise.
+     * Message channel (worker thread only).
      */
-    readonly hasBackPressure: () => boolean;
+    readonly messageChannel?: MessageChannel;
     /**
-     * Terminates the worker node.
+     * Registers once a worker event handler.
+     * @param event - The event.
+     * @param handler - The event handler.
      */
-    readonly terminate: () => Promise<void>;
+    readonly registerOnceWorkerEventHandler: (event: string, handler: EventHandler<Worker>) => void;
     /**
      * Registers a worker event handler.
      * @param event - The event.
@@ -840,23 +831,37 @@ interface IWorkerNode<Worker extends IWorker, Data = unknown> extends EventEmitt
      */
     readonly registerWorkerEventHandler: (event: string, handler: EventHandler<Worker>) => void;
     /**
-     * Registers once a worker event handler.
-     * @param event - The event.
-     * @param handler - The event handler.
+     * Sets tasks queue priority.
+     * @param enablePriority - Whether to enable tasks queue priority.
      */
-    readonly registerOnceWorkerEventHandler: (event: string, handler: EventHandler<Worker>) => void;
+    readonly setTasksQueuePriority: (enablePriority: boolean) => void;
     /**
-     * Gets task function worker usage statistics.
-     * @param name - The task function name.
-     * @returns The task function worker usage statistics if the task function worker usage statistics are initialized, `undefined` otherwise.
+     * Worker choice strategy data.
+     * This is used to store data that are specific to the worker choice strategy.
      */
-    readonly getTaskFunctionWorkerUsage: (name: string) => WorkerUsage | undefined;
+    strategyData?: StrategyData;
     /**
-     * Deletes task function worker usage statistics.
-     * @param name - The task function name.
-     * @returns `true` if the task function worker usage statistics were deleted, `false` otherwise.
+     * Tasks queue back pressure size.
+     * This is the number of tasks that can be enqueued before the worker node has back pressure.
      */
-    readonly deleteTaskFunctionWorkerUsage: (name: string) => boolean;
+    tasksQueueBackPressureSize: number;
+    /**
+     * Tasks queue size.
+     * @returns The tasks queue size.
+     */
+    readonly tasksQueueSize: () => number;
+    /**
+     * Terminates the worker node.
+     */
+    readonly terminate: () => Promise<void>;
+    /**
+     * Worker usage statistics.
+     */
+    readonly usage: WorkerUsage;
+    /**
+     * Worker.
+     */
+    readonly worker: Worker;
 }
 /**
  * Worker node event detail.
@@ -871,8 +876,8 @@ interface WorkerNodeEventDetail {
  * Enumeration of pool types.
  */
 declare const PoolTypes: Readonly<{
-    fixed: 'fixed';
     dynamic: 'dynamic';
+    fixed: 'fixed';
 }>;
 /**
  * Pool type.
@@ -882,14 +887,14 @@ type PoolType = keyof typeof PoolTypes;
  * Enumeration of pool events.
  */
 declare const PoolEvents: Readonly<{
-    ready: 'ready';
+    backPressure: 'backPressure';
     busy: 'busy';
-    full: 'full';
-    empty: 'empty';
     destroy: 'destroy';
+    empty: 'empty';
     error: 'error';
+    full: 'full';
+    ready: 'ready';
     taskError: 'taskError';
-    backPressure: 'backPressure';
 }>;
 /**
  * Pool event.
@@ -899,97 +904,99 @@ type PoolEvent = keyof typeof PoolEvents;
  * Pool information.
  */
 interface PoolInfo {
-    readonly version: string;
-    readonly type: PoolType;
-    readonly worker: WorkerType;
-    readonly started: boolean;
-    readonly ready: boolean;
-    readonly defaultStrategy: WorkerChoiceStrategy;
-    readonly strategyRetries: number;
-    readonly minSize: number;
-    readonly maxSize: number;
-    /** Pool utilization. */
-    readonly utilization?: number;
-    /** Pool total worker nodes. */
-    readonly workerNodes: number;
-    /** Pool continuous stealing worker nodes. */
-    readonly stealingWorkerNodes?: number;
-    /** Pool idle worker nodes. */
-    readonly idleWorkerNodes: number;
+    readonly backPressure?: boolean;
+    /** Pool tasks back pressure worker nodes. */
+    readonly backPressureWorkerNodes?: number;
     /** Pool busy worker nodes. */
     readonly busyWorkerNodes: number;
-    readonly executedTasks: number;
-    readonly executingTasks: number;
-    readonly queuedTasks?: number;
-    readonly maxQueuedTasks?: number;
-    readonly backPressure?: boolean;
-    readonly stolenTasks?: number;
-    readonly failedTasks: number;
-    readonly runTime?: {
-        readonly minimum: number;
-        readonly maximum: number;
-        readonly average?: number;
-        readonly median?: number;
-    };
-    readonly waitTime?: {
-        readonly minimum: number;
-        readonly maximum: number;
-        readonly average?: number;
-        readonly median?: number;
-    };
+    readonly defaultStrategy: WorkerChoiceStrategy;
     readonly elu?: {
-        idle: {
-            readonly minimum: number;
-            readonly maximum: number;
+        active: {
             readonly average?: number;
+            readonly maximum: number;
             readonly median?: number;
-        };
-        active: {
             readonly minimum: number;
-            readonly maximum: number;
+        };
+        idle: {
             readonly average?: number;
+            readonly maximum: number;
             readonly median?: number;
+            readonly minimum: number;
         };
         utilization: {
             readonly average?: number;
             readonly median?: number;
         };
     };
-}
-/**
- * Worker node tasks queue options.
- */
-interface TasksQueueOptions {
-    /**
-     * Maximum tasks queue size per worker node flagging it as back pressured.
-     * @defaultValue (pool maximum size)^2
-     */
-    readonly size?: number;
-    /**
-     * Maximum number of tasks that can be executed concurrently on a worker node.
-     * @defaultValue 1
-     */
-    readonly concurrency?: number;
-    /**
-     * Whether to enable task stealing on idle.
-     * @defaultValue true
-     */
-    readonly taskStealing?: boolean;
-    /**
-     * Whether to enable tasks stealing under back pressure.
-     * @defaultValue true
-     */
-    readonly tasksStealingOnBackPressure?: boolean;
-    /**
-     * Ratio of worker nodes that can steal tasks from another worker node.
-     * @defaultValue 0.6
-     */
-    readonly tasksStealingRatio?: number;
-    /**
+    readonly executedTasks: number;
+    readonly executingTasks: number;
+    readonly failedTasks: number;
+    /** Pool idle worker nodes. */
+    readonly idleWorkerNodes: number;
+    readonly maxQueuedTasks?: number;
+    readonly maxSize: number;
+    readonly minSize: number;
+    readonly queuedTasks?: number;
+    readonly ready: boolean;
+    readonly runTime?: {
+        readonly average?: number;
+        readonly maximum: number;
+        readonly median?: number;
+        readonly minimum: number;
+    };
+    readonly started: boolean;
+    /** Pool tasks stealing worker nodes. */
+    readonly stealingWorkerNodes?: number;
+    readonly stolenTasks?: number;
+    readonly strategyRetries: number;
+    readonly type: PoolType;
+    /** Pool utilization. */
+    readonly utilization?: number;
+    readonly version: string;
+    readonly waitTime?: {
+        readonly average?: number;
+        readonly maximum: number;
+        readonly median?: number;
+        readonly minimum: number;
+    };
+    readonly worker: WorkerType;
+    /** Pool total worker nodes. */
+    readonly workerNodes: number;
+}
+/**
+ * Worker node tasks queue options.
+ */
+interface TasksQueueOptions {
+    /**
+     * Maximum number of tasks that can be executed concurrently on a worker node.
+     * @defaultValue 1
+     */
+    readonly concurrency?: number;
+    /**
+     * Maximum tasks queue size per worker node flagging it as back pressured.
+     * @defaultValue (pool maximum size)^2
+     */
+    readonly size?: number;
+    /**
      * Queued tasks finished timeout in milliseconds at worker node termination.
      * @defaultValue 2000
      */
     readonly tasksFinishedTimeout?: number;
+    /**
+     * Whether to enable tasks stealing under back pressure.
+     * @defaultValue true
+     */
+    readonly tasksStealingOnBackPressure?: boolean;
+    /**
+     * Ratio of worker nodes that can steal tasks from another worker node.
+     * @defaultValue 0.6
+     */
+    readonly tasksStealingRatio?: number;
+    /**
+     * Whether to enable task stealing on idle.
+     * @defaultValue true
+     */
+    readonly taskStealing?: boolean;
 }
 /**
  * Options for a poolifier pool.
@@ -997,15 +1004,20 @@ interface TasksQueueOptions {
  */
 interface PoolOptions<Worker extends IWorker> {
     /**
-     * A function that will listen for online event on each worker.
-     * @defaultValue `() => {}`
+     * Pool events integrated with async resource emission.
+     * @defaultValue true
      */
-    onlineHandler?: OnlineHandler<Worker>;
+    enableEvents?: boolean;
     /**
-     * A function that will listen for message event on each worker.
-     * @defaultValue `() => {}`
+     * Pool worker node tasks queue.
+     * @defaultValue false
      */
-    messageHandler?: MessageHandler<Worker>;
+    enableTasksQueue?: boolean;
+    /**
+     * Key/value pairs to add to worker process environment.
+     * @see https://nodejs.org/api/cluster.html#cluster_cluster_fork_env
+     */
+    env?: Record<string, unknown>;
     /**
      * A function that will listen for error event on each worker.
      * @defaultValue `() => {}`
@@ -1017,52 +1029,47 @@ interface PoolOptions<Worker extends IWorker> {
      */
     exitHandler?: ExitHandler<Worker>;
     /**
-     * Whether to start the minimum number of workers at pool initialization.
-     * @defaultValue true
-     */
-    startWorkers?: boolean;
-    /**
-     * The default worker choice strategy to use in this pool.
-     * @defaultValue WorkerChoiceStrategies.ROUND_ROBIN
+     * A function that will listen for message event on each worker.
+     * @defaultValue `() => {}`
      */
-    workerChoiceStrategy?: WorkerChoiceStrategy;
+    messageHandler?: MessageHandler<Worker>;
     /**
-     * The worker choice strategy options.
+     * A function that will listen for online event on each worker.
+     * @defaultValue `() => {}`
      */
-    workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions;
+    onlineHandler?: OnlineHandler<Worker>;
     /**
      * Restart worker on error.
      */
     restartWorkerOnError?: boolean;
     /**
-     * Pool events integrated with async resource emission.
-     * @defaultValue true
+     * Cluster settings.
+     * @see https://nodejs.org/api/cluster.html#cluster_cluster_settings
      */
-    enableEvents?: boolean;
+    settings?: ClusterSettings;
     /**
-     * Pool worker node tasks queue.
-     * @defaultValue false
+     * Whether to start the minimum number of workers at pool initialization.
+     * @defaultValue true
      */
-    enableTasksQueue?: boolean;
+    startWorkers?: boolean;
     /**
      * Pool worker node tasks queue options.
      */
     tasksQueueOptions?: TasksQueueOptions;
     /**
-     * Worker options.
-     * @see https://nodejs.org/api/worker_threads.html#new-workerfilename-options
+     * The default worker choice strategy to use in this pool.
+     * @defaultValue WorkerChoiceStrategies.ROUND_ROBIN
      */
-    workerOptions?: WorkerOptions$1;
+    workerChoiceStrategy?: WorkerChoiceStrategy;
     /**
-     * Key/value pairs to add to worker process environment.
-     * @see https://nodejs.org/api/cluster.html#cluster_cluster_fork_env
+     * The worker choice strategy options.
      */
-    env?: Record<string, unknown>;
+    workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions;
     /**
-     * Cluster settings.
-     * @see https://nodejs.org/api/cluster.html#cluster_cluster_settings
+     * Worker options.
+     * @see https://nodejs.org/api/worker_threads.html#new-workerfilename-options
      */
-    settings?: ClusterSettings;
+    workerOptions?: WorkerOptions$1;
 }
 /**
  * Contract definition for a poolifier pool.
@@ -1072,14 +1079,19 @@ interface PoolOptions<Worker extends IWorker> {
  */
 interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
     /**
-     * Pool information.
+     * Adds a task function to this pool.
+     * If a task function with the same name already exists, it will be overwritten.
+     * @param name - The name of the task function.
+     * @param fn - The task function.
+     * @returns `true` if the task function was added, `false` otherwise.
+     * @throws {@link https://nodejs.org/api/errors.html#class-typeerror} If the `name` parameter is not a string or an empty string.
+     * @throws {@link https://nodejs.org/api/errors.html#class-typeerror} If the `fn` parameter is not a function or task function object.
      */
-    readonly info: PoolInfo;
+    readonly addTaskFunction: (name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>) => Promise<boolean>;
     /**
-     * Pool worker nodes.
-     * @internal
+     * Terminates all workers in this pool.
      */
-    readonly workerNodes: IWorkerNode<Worker, Data>[];
+    readonly destroy: () => Promise<void>;
     /**
      * Pool event emitter integrated with async resource.
      * The async tracking tooling identifier is `poolifier:<PoolType>-<WorkerType>-pool`.
@@ -1096,6 +1108,12 @@ interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
      * - `'backPressure'`: Emitted when all worker nodes have back pressure (i.e. their tasks queue is full: queue size \>= maximum queue size).
      */
     readonly emitter?: EventEmitterAsyncResource;
+    /**
+     * Enables/disables the worker node tasks queue in this pool.
+     * @param enable - Whether to enable or disable the worker node tasks queue.
+     * @param tasksQueueOptions - The worker node tasks queue options.
+     */
+    readonly enableTasksQueue: (enable: boolean, tasksQueueOptions?: TasksQueueOptions) => void;
     /**
      * Executes the specified function in the worker constructor with the task data input parameter.
      * @param data - The optional task input data for the specified task function. This can only be structured-cloneable data.
@@ -1104,22 +1122,6 @@ interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
      * @returns Promise with a task function response that will be fulfilled when the task is completed.
      */
     readonly execute: (data?: Data, name?: string, transferList?: readonly TransferListItem[]) => Promise<Response>;
-    /**
-     * Executes the specified function in the worker constructor with the tasks data iterable input parameter.
-     * @param data - The tasks iterable input data for the specified task function. This can only be an iterable of structured-cloneable data.
-     * @param name - The optional name of the task function to execute. If not specified, the default task function will be executed.
-     * @param transferList - An optional array of transferable objects to transfer ownership of. Ownership of the transferred objects is given to the chosen pool's worker_threads worker and they should not be used in the main thread afterwards.
-     * @returns Promise with an array of task function responses that will be fulfilled when the tasks are completed.
-     */
-    readonly mapExecute: (data: Iterable<Data>, name?: string, transferList?: readonly TransferListItem[]) => Promise<Response[]>;
-    /**
-     * Starts the minimum number of workers in this pool.
-     */
-    readonly start: () => void;
-    /**
-     * Terminates all workers in this pool.
-     */
-    readonly destroy: () => Promise<void>;
     /**
      * Whether the specified task function exists in this pool.
      * @param name - The name of the task function.
@@ -1127,32 +1129,39 @@ interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
      */
     readonly hasTaskFunction: (name: string) => boolean;
     /**
-     * Adds a task function to this pool.
-     * If a task function with the same name already exists, it will be overwritten.
-     * @param name - The name of the task function.
-     * @param fn - The task function.
-     * @returns `true` if the task function was added, `false` otherwise.
-     * @throws {@link https://nodejs.org/api/errors.html#class-typeerror} If the `name` parameter is not a string or an empty string.
-     * @throws {@link https://nodejs.org/api/errors.html#class-typeerror} If the `fn` parameter is not a function or task function object.
+     * Pool information.
      */
-    readonly addTaskFunction: (name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>) => Promise<boolean>;
+    readonly info: PoolInfo;
+    /**
+     * Lists the properties of task functions available in this pool.
+     * @returns The properties of task functions available in this pool.
+     */
+    readonly listTaskFunctionsProperties: () => TaskFunctionProperties[];
+    /**
+     * Executes the specified function in the worker constructor with the tasks data iterable input parameter.
+     * @param data - The tasks iterable input data for the specified task function. This can only be an iterable of structured-cloneable data.
+     * @param name - The optional name of the task function to execute. If not specified, the default task function will be executed.
+     * @param transferList - An optional array of transferable objects to transfer ownership of. Ownership of the transferred objects is given to the chosen pool's worker_threads worker and they should not be used in the main thread afterwards.
+     * @returns Promise with an array of task function responses that will be fulfilled when the tasks are completed.
+     */
+    readonly mapExecute: (data: Iterable<Data>, name?: string, transferList?: readonly TransferListItem[]) => Promise<Response[]>;
     /**
      * Removes a task function from this pool.
      * @param name - The name of the task function.
      * @returns `true` if the task function was removed, `false` otherwise.
      */
     readonly removeTaskFunction: (name: string) => Promise<boolean>;
-    /**
-     * Lists the properties of task functions available in this pool.
-     * @returns The properties of task functions available in this pool.
-     */
-    readonly listTaskFunctionsProperties: () => TaskFunctionProperties[];
     /**
      * Sets the default task function in this pool.
      * @param name - The name of the task function.
      * @returns `true` if the default task function was set, `false` otherwise.
      */
     readonly setDefaultTaskFunction: (name: string) => Promise<boolean>;
+    /**
+     * Sets the worker node tasks queue options in this pool.
+     * @param tasksQueueOptions - The worker node tasks queue options.
+     */
+    readonly setTasksQueueOptions: (tasksQueueOptions: TasksQueueOptions) => void;
     /**
      * Sets the default worker choice strategy in this pool.
      * @param workerChoiceStrategy - The default worker choice strategy.
@@ -1166,16 +1175,14 @@ interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
      */
     readonly setWorkerChoiceStrategyOptions: (workerChoiceStrategyOptions: WorkerChoiceStrategyOptions) => boolean;
     /**
-     * Enables/disables the worker node tasks queue in this pool.
-     * @param enable - Whether to enable or disable the worker node tasks queue.
-     * @param tasksQueueOptions - The worker node tasks queue options.
+     * Starts the minimum number of workers in this pool.
      */
-    readonly enableTasksQueue: (enable: boolean, tasksQueueOptions?: TasksQueueOptions) => void;
+    readonly start: () => void;
     /**
-     * Sets the worker node tasks queue options in this pool.
-     * @param tasksQueueOptions - The worker node tasks queue options.
+     * Pool worker nodes.
+     * @internal
      */
-    readonly setTasksQueueOptions: (tasksQueueOptions: TasksQueueOptions) => void;
+    readonly workerNodes: IWorkerNode<Worker, Data>[];
 }
 
 /**
@@ -1187,14 +1194,14 @@ interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
  */
 declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unknown, Response = unknown> {
     private readonly pool;
-    /**
-     * The number of worker choice strategies execution retries.
-     */
-    retriesCount: number;
     /**
      * The default worker choice strategy in the context.
      */
     private defaultWorkerChoiceStrategy;
+    /**
+     * The maximum number of worker choice strategies execution retries.
+     */
+    private readonly retries;
     /**
      * The worker choice strategies registered in the context.
      */
@@ -1208,9 +1215,9 @@ declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unkno
      */
     private workerChoiceStrategiesTaskStatisticsRequirements;
     /**
-     * The maximum number of worker choice strategies execution retries.
+     * The number of worker choice strategies execution retries.
      */
-    private readonly retries;
+    retriesCount: number;
     /**
      * Worker choice strategies context constructor.
      * @param pool - The pool instance.
@@ -1218,6 +1225,34 @@ declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unkno
      * @param opts - The worker choice strategy options.
      */
     constructor(pool: IPool<Worker, Data, Response>, workerChoiceStrategies?: WorkerChoiceStrategy[], opts?: WorkerChoiceStrategyOptions);
+    /**
+     * Adds a worker choice strategy to the context.
+     * @param workerChoiceStrategy - The worker choice strategy to add.
+     * @param pool - The pool instance.
+     * @param opts - The worker choice strategy options.
+     * @returns The worker choice strategies.
+     */
+    private addWorkerChoiceStrategy;
+    /**
+     * Executes the given worker choice strategy.
+     * @param workerChoiceStrategy - The worker choice strategy.
+     * @returns The key of the worker node.
+     * @throws {@link https://nodejs.org/api/errors.html#class-error} If after computed retries the worker node key is null or undefined.
+     */
+    private executeStrategy;
+    /**
+     * Removes a worker choice strategy from the context.
+     * @param workerChoiceStrategy - The worker choice strategy to remove.
+     * @returns `true` if the worker choice strategy is removed, `false` otherwise.
+     */
+    private removeWorkerChoiceStrategy;
+    /**
+     * Executes the given worker choice strategy in the context algorithm.
+     * @param workerChoiceStrategy - The worker choice strategy algorithm to execute. @defaultValue this.defaultWorkerChoiceStrategy
+     * @returns The key of the worker node.
+     * @throws {@link https://nodejs.org/api/errors.html#class-error} If after computed retries the worker node key is null or undefined.
+     */
+    execute(workerChoiceStrategy?: WorkerChoiceStrategy): number;
     /**
      * Gets the active worker choice strategies in the context policy.
      * @returns The strategies policy.
@@ -1228,43 +1263,23 @@ declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unkno
      * @returns The strategies task statistics requirements.
      */
     getTaskStatisticsRequirements(): TaskStatisticsRequirements;
+    /**
+     * Removes the worker node key from the active worker choice strategies in the context.
+     * @param workerNodeKey - The worker node key.
+     * @returns `true` if the removal is successful, `false` otherwise.
+     */
+    remove(workerNodeKey: number): boolean;
     /**
      * Sets the default worker choice strategy to use in the context.
      * @param workerChoiceStrategy - The default worker choice strategy to set.
      * @param opts - The worker choice strategy options.
      */
     setDefaultWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy, opts?: WorkerChoiceStrategyOptions): void;
-    /**
-     * Updates the worker node key in the active worker choice strategies in the context internals.
-     * @param workerNodeKey - The worker node key.
-     * @returns `true` if the update is successful, `false` otherwise.
-     */
-    update(workerNodeKey: number): boolean;
-    /**
-     * Executes the given worker choice strategy in the context algorithm.
-     * @param workerChoiceStrategy - The worker choice strategy algorithm to execute. @defaultValue this.defaultWorkerChoiceStrategy
-     * @returns The key of the worker node.
-     * @throws {@link https://nodejs.org/api/errors.html#class-error} If after computed retries the worker node key is null or undefined.
-     */
-    execute(workerChoiceStrategy?: WorkerChoiceStrategy): number;
-    /**
-     * Executes the given worker choice strategy.
-     * @param workerChoiceStrategy - The worker choice strategy.
-     * @returns The key of the worker node.
-     * @throws {@link https://nodejs.org/api/errors.html#class-error} If after computed retries the worker node key is null or undefined.
-     */
-    private executeStrategy;
-    /**
-     * Removes the worker node key from the active worker choice strategies in the context.
-     * @param workerNodeKey - The worker node key.
-     * @returns `true` if the removal is successful, `false` otherwise.
-     */
-    remove(workerNodeKey: number): boolean;
     /**
      * Sets the active worker choice strategies in the context options.
      * @param opts - The worker choice strategy options.
      */
-    setOptions(opts: WorkerChoiceStrategyOptions | undefined): void;
+    setOptions(opts: undefined | WorkerChoiceStrategyOptions): void;
     /**
      * Synchronizes the active worker choice strategies in the context with the given worker choice strategies.
      * @param workerChoiceStrategies - The worker choice strategies to synchronize.
@@ -1272,19 +1287,11 @@ declare class WorkerChoiceStrategiesContext<Worker extends IWorker, Data = unkno
      */
     syncWorkerChoiceStrategies(workerChoiceStrategies: Set<WorkerChoiceStrategy>, opts?: WorkerChoiceStrategyOptions): void;
     /**
-     * Adds a worker choice strategy to the context.
-     * @param workerChoiceStrategy - The worker choice strategy to add.
-     * @param pool - The pool instance.
-     * @param opts - The worker choice strategy options.
-     * @returns The worker choice strategies.
-     */
-    private addWorkerChoiceStrategy;
-    /**
-     * Removes a worker choice strategy from the context.
-     * @param workerChoiceStrategy - The worker choice strategy to remove.
-     * @returns `true` if the worker choice strategy is removed, `false` otherwise.
+     * Updates the worker node key in the active worker choice strategies in the context internals.
+     * @param workerNodeKey - The worker node key.
+     * @returns `true` if the update is successful, `false` otherwise.
      */
-    private removeWorkerChoiceStrategy;
+    update(workerNodeKey: number): boolean;
 }
 
 /**
@@ -1298,10 +1305,6 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
     protected readonly filePath: string;
     protected readonly opts: PoolOptions<Worker>;
     protected readonly maximumNumberOfWorkers?: number | undefined;
-    /** @inheritDoc */
-    readonly workerNodes: IWorkerNode<Worker, Data>[];
-    /** @inheritDoc */
-    emitter?: EventEmitterAsyncResource;
     /**
      * The task execution response promise map:
      * - `key`: The message id of each submitted task.
@@ -1315,35 +1318,73 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      */
     protected workerChoiceStrategiesContext?: WorkerChoiceStrategiesContext<Worker, Data, Response>;
     /**
-     * The task functions added at runtime map:
-     * - `key`: The task function name.
-     * - `value`: The task function object.
+     * This method is the message listener registered on each worker.
+     * @param message - The message received from the worker.
      */
-    private readonly taskFunctions;
+    protected readonly workerMessageListener: (message: MessageValue<Response>) => void;
     /**
-     * Whether the pool is started or not.
+     * Whether the pool is destroying or not.
      */
-    private started;
+    private destroying;
     /**
-     * Whether the pool is starting or not.
+     * Gets task function worker choice strategy, if any.
+     * @param name - The task function name.
+     * @returns The task function worker choice strategy if the task function worker choice strategy is defined, `undefined` otherwise.
      */
-    private starting;
+    private readonly getTaskFunctionWorkerChoiceStrategy;
     /**
-     * Whether the pool is destroying or not.
+     * Gets the worker choice strategies registered in this pool.
+     * @returns The worker choice strategies.
      */
-    private destroying;
+    private readonly getWorkerChoiceStrategies;
     /**
-     * Whether the minimum number of workers is starting or not.
+     * Gets worker node task function priority, if any.
+     * @param workerNodeKey - The worker node key.
+     * @param name - The task function name.
+     * @returns The worker node task function priority if the worker node task function priority is defined, `undefined` otherwise.
      */
-    private startingMinimumNumberOfWorkers;
+    private readonly getWorkerNodeTaskFunctionPriority;
+    /**
+     * Gets worker node task function worker choice strategy, if any.
+     * @param workerNodeKey - The worker node key.
+     * @param name - The task function name.
+     * @returns The worker node task function worker choice strategy if the worker node task function worker choice strategy is defined, `undefined` otherwise.
+     */
+    private readonly getWorkerNodeTaskFunctionWorkerChoiceStrategy;
+    private readonly handleWorkerNodeBackPressureEvent;
+    private readonly handleWorkerNodeIdleEvent;
     /**
      * Whether the pool ready event has been emitted or not.
      */
     private readyEventEmitted;
+    /**
+     * Whether the pool is started or not.
+     */
+    private started;
+    /**
+     * Whether the pool is starting or not.
+     */
+    private starting;
+    /**
+     * Whether the minimum number of workers is starting or not.
+     */
+    private startingMinimumNumberOfWorkers;
     /**
      * The start timestamp of the pool.
      */
     private startTimestamp?;
+    private readonly stealTask;
+    /**
+     * The task functions added at runtime map:
+     * - `key`: The task function name.
+     * - `value`: The task function object.
+     */
+    private readonly taskFunctions;
+    private readonly workerNodeStealTask;
+    /** @inheritDoc */
+    emitter?: EventEmitterAsyncResource;
+    /** @inheritDoc */
+    readonly workerNodes: IWorkerNode<Worker, Data>[];
     /**
      * Constructs a new poolifier pool.
      * @param minimumNumberOfWorkers - Minimum number of workers that this pool manages.
@@ -1352,169 +1393,126 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      * @param maximumNumberOfWorkers - Maximum number of workers that this pool manages.
      */
     constructor(minimumNumberOfWorkers: number, filePath: string, opts: PoolOptions<Worker>, maximumNumberOfWorkers?: number | undefined);
-    private checkPoolType;
-    private checkMinimumNumberOfWorkers;
-    private checkPoolOptions;
-    private checkValidWorkerChoiceStrategyOptions;
-    private initEventEmitter;
-    /** @inheritDoc */
-    get info(): PoolInfo;
     /**
-     * Whether the pool is ready or not.
-     * @returns The pool readiness boolean status.
+     * Hook executed after the worker task execution.
+     * Can be overridden.
+     * @param workerNodeKey - The worker node key.
+     * @param message - The received message.
      */
-    private get ready();
+    protected afterTaskExecutionHook(workerNodeKey: number, message: MessageValue<Response>): void;
     /**
-     * Whether the pool is empty or not.
-     * @returns The pool emptiness boolean status.
+     * Method hooked up after a worker node has been newly created.
+     * Can be overridden.
+     * @param workerNodeKey - The newly created worker node key.
      */
-    protected get empty(): boolean;
+    protected afterWorkerNodeSetup(workerNodeKey: number): void;
     /**
-     * The approximate pool utilization.
-     * @returns The pool utilization.
+     * Hook executed before the worker task execution.
+     * Can be overridden.
+     * @param workerNodeKey - The worker node key.
+     * @param task - The task to execute.
      */
-    private get utilization();
+    protected beforeTaskExecutionHook(workerNodeKey: number, task: Task<Data>): void;
     /**
-     * The pool type.
-     *
-     * If it is `'dynamic'`, it provides the `max` property.
+     * Emits dynamic worker creation events.
      */
-    protected abstract get type(): PoolType;
+    protected abstract checkAndEmitDynamicWorkerCreationEvents(): void;
     /**
-     * The worker type.
+     * Creates a new, completely set up dynamic worker node.
+     * @returns New, completely set up dynamic worker node key.
      */
-    protected abstract get worker(): WorkerType;
+    protected createAndSetupDynamicWorkerNode(): number;
     /**
-     * Checks if the worker id sent in the received message from a worker is valid.
-     * @param message - The received message.
-     * @throws {@link https://nodejs.org/api/errors.html#class-error} If the worker id is invalid.
+     * Creates a new, completely set up worker node.
+     * @returns New, completely set up worker node key.
      */
-    private checkMessageWorkerId;
+    protected createAndSetupWorkerNode(): number;
     /**
-     * Gets the worker node key given its worker id.
-     * @param workerId - The worker id.
-     * @returns The worker node key if the worker id is found in the pool worker nodes, `-1` otherwise.
+     * Deregisters a listener callback on the worker given its worker node key.
+     * @param workerNodeKey - The worker node key.
+     * @param listener - The message listener callback.
      */
-    private getWorkerNodeKeyByWorkerId;
-    /** @inheritDoc */
-    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy, workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions): void;
-    /** @inheritDoc */
-    setWorkerChoiceStrategyOptions(workerChoiceStrategyOptions: WorkerChoiceStrategyOptions | undefined): boolean;
-    /** @inheritDoc */
-    enableTasksQueue(enable: boolean, tasksQueueOptions?: TasksQueueOptions): void;
-    /** @inheritDoc */
-    setTasksQueueOptions(tasksQueueOptions: TasksQueueOptions | undefined): void;
-    private buildTasksQueueOptions;
-    private setTasksQueueSize;
-    private setTaskStealing;
-    private unsetTaskStealing;
-    private setTasksStealingOnBackPressure;
-    private unsetTasksStealingOnBackPressure;
+    protected abstract deregisterWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /**
-     * Whether the pool is full or not.
-     * @returns The pool fullness boolean status.
+     * Terminates the worker node given its worker node key.
+     * @param workerNodeKey - The worker node key.
      */
-    protected get full(): boolean;
+    protected destroyWorkerNode(workerNodeKey: number): Promise<void>;
+    protected flagWorkerNodeAsNotReady(workerNodeKey: number): void;
+    protected flushTasksQueue(workerNodeKey: number): number;
     /**
-     * Whether the pool is busy or not.
-     * @returns The pool busyness boolean status.
+     * Gets the worker information given its worker node key.
+     * @param workerNodeKey - The worker node key.
+     * @returns The worker information.
      */
-    protected abstract get busy(): boolean;
+    protected getWorkerInfo(workerNodeKey: number): undefined | WorkerInfo;
     /**
      * Whether worker nodes are executing concurrently their tasks quota or not.
      * @returns Worker nodes busyness boolean status.
      */
     protected internalBusy(): boolean;
-    private isWorkerNodeIdle;
-    private isWorkerNodeBusy;
-    private sendTaskFunctionOperationToWorker;
-    private sendTaskFunctionOperationToWorkers;
-    /** @inheritDoc */
-    hasTaskFunction(name: string): boolean;
-    /** @inheritDoc */
-    addTaskFunction(name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>): Promise<boolean>;
-    /** @inheritDoc */
-    removeTaskFunction(name: string): Promise<boolean>;
-    /** @inheritDoc */
-    listTaskFunctionsProperties(): TaskFunctionProperties[];
     /**
-     * Gets task function worker choice strategy, if any.
-     * @param name - The task function name.
-     * @returns The task function worker choice strategy if the task function worker choice strategy is defined, `undefined` otherwise.
+     * Returns whether the worker is the main worker or not.
+     * @returns `true` if the worker is the main worker, `false` otherwise.
      */
-    private readonly getTaskFunctionWorkerChoiceStrategy;
+    protected abstract isMain(): boolean;
     /**
-     * Gets worker node task function worker choice strategy, if any.
+     * Registers once a listener callback on the worker given its worker node key.
      * @param workerNodeKey - The worker node key.
-     * @param name - The task function name.
-     * @returns The worker node task function worker choice strategy if the worker node task function worker choice strategy is defined, `undefined` otherwise.
+     * @param listener - The message listener callback.
      */
-    private readonly getWorkerNodeTaskFunctionWorkerChoiceStrategy;
+    protected abstract registerOnceWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /**
-     * Gets worker node task function priority, if any.
+     * Registers a listener callback on the worker given its worker node key.
      * @param workerNodeKey - The worker node key.
-     * @param name - The task function name.
-     * @returns The worker node task function priority if the worker node task function priority is defined, `undefined` otherwise.
-     */
-    private readonly getWorkerNodeTaskFunctionPriority;
-    /**
-     * Gets the worker choice strategies registered in this pool.
-     * @returns The worker choice strategies.
+     * @param listener - The message listener callback.
      */
-    private readonly getWorkerChoiceStrategies;
-    /** @inheritDoc */
-    setDefaultTaskFunction(name: string): Promise<boolean>;
-    private shallExecuteTask;
-    private internalExecute;
-    /** @inheritDoc */
-    execute(data?: Data, name?: string, transferList?: readonly TransferListItem[]): Promise<Response>;
-    /** @inheritDoc */
-    mapExecute(data: Iterable<Data>, name?: string, transferList?: readonly TransferListItem[]): Promise<Response[]>;
+    protected abstract registerWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /**
-     * Starts the minimum number of workers.
-     * @param initWorkerNodeUsage - Whether to initialize the worker node usage or not. @defaultValue false
+     * Sends the startup message to worker given its worker node key.
+     * @param workerNodeKey - The worker node key.
      */
-    private startMinimumNumberOfWorkers;
-    /** @inheritdoc */
-    start(): void;
-    /** @inheritDoc */
-    destroy(): Promise<void>;
-    private sendKillMessageToWorker;
+    protected abstract sendStartupMessageToWorker(workerNodeKey: number): void;
     /**
-     * Terminates the worker node given its worker node key.
+     * Sends a message to worker given its worker node key.
      * @param workerNodeKey - The worker node key.
+     * @param message - The message.
+     * @param transferList - The optional array of transferable objects.
      */
-    protected destroyWorkerNode(workerNodeKey: number): Promise<void>;
+    protected abstract sendToWorker(workerNodeKey: number, message: MessageValue<Data>, transferList?: readonly TransferListItem[]): void;
     /**
      * Setup hook to execute code before worker nodes are created in the abstract constructor.
      * Can be overridden.
      */
     protected setupHook(): void;
     /**
-     * Returns whether the worker is the main worker or not.
-     * @returns `true` if the worker is the main worker, `false` otherwise.
+     * Conditions for dynamic worker creation.
+     * @returns Whether to create a dynamic worker or not.
      */
-    protected abstract isMain(): boolean;
+    protected abstract shallCreateDynamicWorker(): boolean;
     /**
-     * Hook executed before the worker task execution.
-     * Can be overridden.
-     * @param workerNodeKey - The worker node key.
-     * @param task - The task to execute.
+     * Adds the given worker node in the pool worker nodes.
+     * @param workerNode - The worker node.
+     * @returns The added worker node key.
+     * @throws {@link https://nodejs.org/api/errors.html#class-error} If the added worker node is not found.
      */
-    protected beforeTaskExecutionHook(workerNodeKey: number, task: Task<Data>): void;
+    private addWorkerNode;
+    private buildTasksQueueOptions;
+    private cannotStealTask;
+    private checkAndEmitEmptyEvent;
+    private checkAndEmitReadyEvent;
+    private checkAndEmitTaskExecutionEvents;
+    private checkAndEmitTaskQueuingEvents;
     /**
-     * Hook executed after the worker task execution.
-     * Can be overridden.
-     * @param workerNodeKey - The worker node key.
+     * Checks if the worker id sent in the received message from a worker is valid.
      * @param message - The received message.
+     * @throws {@link https://nodejs.org/api/errors.html#class-error} If the worker id is invalid.
      */
-    protected afterTaskExecutionHook(workerNodeKey: number, message: MessageValue<Response>): void;
-    /**
-     * Whether the worker node shall update its task function worker usage or not.
-     * @param workerNodeKey - The worker node key.
-     * @returns `true` if the worker node shall update its task function worker usage, `false` otherwise.
-     */
-    private shallUpdateTaskFunctionWorkerUsage;
+    private checkMessageWorkerId;
+    private checkMinimumNumberOfWorkers;
+    private checkPoolOptions;
+    private checkPoolType;
+    private checkValidWorkerChoiceStrategyOptions;
     /**
      * Chooses a worker node for the next task.
      * @param name - The task function name.
@@ -1522,129 +1520,138 @@ declare abstract class AbstractPool<Worker extends IWorker, Data = unknown, Resp
      */
     private chooseWorkerNode;
     /**
-     * Conditions for dynamic worker creation.
-     * @returns Whether to create a dynamic worker or not.
+     * Creates a worker node.
+     * @returns The created worker node.
      */
-    protected abstract shallCreateDynamicWorker(): boolean;
+    private createWorkerNode;
+    private dequeueTask;
+    private enqueueTask;
     /**
-     * Sends a message to worker given its worker node key.
+     * Executes the given task on the worker given its worker node key.
      * @param workerNodeKey - The worker node key.
-     * @param message - The message.
-     * @param transferList - The optional array of transferable objects.
+     * @param task - The task to execute.
      */
-    protected abstract sendToWorker(workerNodeKey: number, message: MessageValue<Data>, transferList?: readonly TransferListItem[]): void;
+    private executeTask;
+    private flushTasksQueues;
+    private getTasksQueuePriority;
+    /**
+     * Gets the worker node key given its worker id.
+     * @param workerId - The worker id.
+     * @returns The worker node key if the worker id is found in the pool worker nodes, `-1` otherwise.
+     */
+    private getWorkerNodeKeyByWorkerId;
+    private handleTask;
+    private handleTaskExecutionResponse;
+    private handleWorkerReadyResponse;
+    private hasBackPressure;
+    private initEventEmitter;
     /**
      * Initializes the worker node usage with sensible default values gathered during runtime.
      * @param workerNode - The worker node.
      */
     private initWorkerNodeUsage;
+    private internalExecute;
+    private isWorkerNodeBusy;
+    private isWorkerNodeIdle;
+    private redistributeQueuedTasks;
     /**
-     * Creates a new, completely set up worker node.
-     * @returns New, completely set up worker node key.
-     */
-    protected createAndSetupWorkerNode(): number;
-    /**
-     * Creates a new, completely set up dynamic worker node.
-     * @returns New, completely set up dynamic worker node key.
-     */
-    protected createAndSetupDynamicWorkerNode(): number;
-    /**
-     * Registers a listener callback on the worker given its worker node key.
-     * @param workerNodeKey - The worker node key.
-     * @param listener - The message listener callback.
-     */
-    protected abstract registerWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
-    /**
-     * Registers once a listener callback on the worker given its worker node key.
-     * @param workerNodeKey - The worker node key.
-     * @param listener - The message listener callback.
+     * Removes the worker node from the pool worker nodes.
+     * @param workerNode - The worker node.
      */
-    protected abstract registerOnceWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
+    private removeWorkerNode;
+    private resetTaskSequentiallyStolenStatisticsWorkerUsage;
+    private sendKillMessageToWorker;
     /**
-     * Deregisters a listener callback on the worker given its worker node key.
+     * Sends the statistics message to worker given its worker node key.
      * @param workerNodeKey - The worker node key.
-     * @param listener - The message listener callback.
-     */
-    protected abstract deregisterWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
-    /**
-     * Method hooked up after a worker node has been newly created.
-     * Can be overridden.
-     * @param workerNodeKey - The newly created worker node key.
      */
-    protected afterWorkerNodeSetup(workerNodeKey: number): void;
+    private sendStatisticsMessageToWorker;
+    private sendTaskFunctionOperationToWorker;
+    private sendTaskFunctionOperationToWorkers;
+    private setTasksQueuePriority;
+    private setTasksQueueSize;
+    private setTasksStealingOnBackPressure;
+    private setTaskStealing;
+    private shallExecuteTask;
     /**
-     * Sends the startup message to worker given its worker node key.
+     * Whether the worker node shall update its task function worker usage or not.
      * @param workerNodeKey - The worker node key.
+     * @returns `true` if the worker node shall update its task function worker usage, `false` otherwise.
      */
-    protected abstract sendStartupMessageToWorker(workerNodeKey: number): void;
+    private shallUpdateTaskFunctionWorkerUsage;
     /**
-     * Sends the statistics message to worker given its worker node key.
-     * @param workerNodeKey - The worker node key.
+     * Starts the minimum number of workers.
+     * @param initWorkerNodeUsage - Whether to initialize the worker node usage or not. @defaultValue false
      */
-    private sendStatisticsMessageToWorker;
-    private cannotStealTask;
-    private handleTask;
-    private redistributeQueuedTasks;
-    private updateTaskStolenStatisticsWorkerUsage;
+    private startMinimumNumberOfWorkers;
+    private tasksQueueSize;
+    private unsetTasksStealingOnBackPressure;
+    private unsetTaskStealing;
     private updateTaskSequentiallyStolenStatisticsWorkerUsage;
-    private resetTaskSequentiallyStolenStatisticsWorkerUsage;
-    private readonly stealTask;
-    private readonly handleWorkerNodeIdleEvent;
-    private readonly workerNodeStealTask;
-    private readonly handleWorkerNodeBackPressureEvent;
-    private setTasksQueuePriority;
+    private updateTaskStolenStatisticsWorkerUsage;
+    /** @inheritDoc */
+    addTaskFunction(name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>): Promise<boolean>;
+    /** @inheritDoc */
+    destroy(): Promise<void>;
+    /** @inheritDoc */
+    enableTasksQueue(enable: boolean, tasksQueueOptions?: TasksQueueOptions): void;
+    /** @inheritDoc */
+    execute(data?: Data, name?: string, transferList?: readonly TransferListItem[]): Promise<Response>;
+    /** @inheritDoc */
+    hasTaskFunction(name: string): boolean;
+    /** @inheritDoc */
+    listTaskFunctionsProperties(): TaskFunctionProperties[];
+    /** @inheritDoc */
+    mapExecute(data: Iterable<Data>, name?: string, transferList?: readonly TransferListItem[]): Promise<Response[]>;
+    /** @inheritDoc */
+    removeTaskFunction(name: string): Promise<boolean>;
+    /** @inheritDoc */
+    setDefaultTaskFunction(name: string): Promise<boolean>;
+    /** @inheritDoc */
+    setTasksQueueOptions(tasksQueueOptions: TasksQueueOptions | undefined): void;
+    /** @inheritDoc */
+    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy, workerChoiceStrategyOptions?: WorkerChoiceStrategyOptions): void;
+    /** @inheritDoc */
+    setWorkerChoiceStrategyOptions(workerChoiceStrategyOptions: undefined | WorkerChoiceStrategyOptions): boolean;
+    /** @inheritdoc */
+    start(): void;
     /**
-     * This method is the message listener registered on each worker.
-     * @param message - The message received from the worker.
+     * Whether the pool is busy or not.
+     * @returns The pool busyness boolean status.
      */
-    protected readonly workerMessageListener: (message: MessageValue<Response>) => void;
-    private checkAndEmitReadyEvent;
-    private handleWorkerReadyResponse;
-    private handleTaskExecutionResponse;
-    private checkAndEmitTaskExecutionEvents;
-    private checkAndEmitTaskQueuingEvents;
+    protected abstract get busy(): boolean;
     /**
-     * Emits dynamic worker creation events.
+     * Whether the pool is empty or not.
+     * @returns The pool emptiness boolean status.
      */
-    protected abstract checkAndEmitDynamicWorkerCreationEvents(): void;
+    protected get empty(): boolean;
     /**
-     * Gets the worker information given its worker node key.
-     * @param workerNodeKey - The worker node key.
-     * @returns The worker information.
+     * Whether the pool is full or not.
+     * @returns The pool fullness boolean status.
      */
-    protected getWorkerInfo(workerNodeKey: number): WorkerInfo | undefined;
-    private getTasksQueuePriority;
+    protected get full(): boolean;
+    /** @inheritDoc */
+    get info(): PoolInfo;
     /**
-     * Creates a worker node.
-     * @returns The created worker node.
+     * Whether the pool is ready or not.
+     * @returns The pool readiness boolean status.
      */
-    private createWorkerNode;
+    private get ready();
     /**
-     * Adds the given worker node in the pool worker nodes.
-     * @param workerNode - The worker node.
-     * @returns The added worker node key.
-     * @throws {@link https://nodejs.org/api/errors.html#class-error} If the added worker node is not found.
+     * The pool type.
+     *
+     * If it is `'dynamic'`, it provides the `max` property.
      */
-    private addWorkerNode;
-    private checkAndEmitEmptyEvent;
+    protected abstract get type(): PoolType;
     /**
-     * Removes the worker node from the pool worker nodes.
-     * @param workerNode - The worker node.
+     * The approximate pool utilization.
+     * @returns The pool utilization.
      */
-    private removeWorkerNode;
-    protected flagWorkerNodeAsNotReady(workerNodeKey: number): void;
-    private hasBackPressure;
+    private get utilization();
     /**
-     * Executes the given task on the worker given its worker node key.
-     * @param workerNodeKey - The worker node key.
-     * @param task - The task to execute.
+     * The worker type.
      */
-    private executeTask;
-    private enqueueTask;
-    private dequeueTask;
-    private tasksQueueSize;
-    protected flushTasksQueue(workerNodeKey: number): number;
-    private flushTasksQueues;
+    protected abstract get worker(): WorkerType;
 }
 
 /**
@@ -1668,29 +1675,29 @@ declare class FixedClusterPool<Data = unknown, Response = unknown> extends Abstr
      */
     constructor(numberOfWorkers: number, filePath: string, opts?: ClusterPoolOptions, maximumNumberOfWorkers?: number);
     /** @inheritDoc */
-    protected setupHook(): void;
+    protected checkAndEmitDynamicWorkerCreationEvents(): void;
     /** @inheritDoc */
-    protected isMain(): boolean;
+    protected deregisterWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /** @inheritDoc */
-    protected sendToWorker(workerNodeKey: number, message: MessageValue<Data>): void;
+    protected isMain(): boolean;
     /** @inheritDoc */
-    protected sendStartupMessageToWorker(workerNodeKey: number): void;
+    protected registerOnceWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /** @inheritDoc */
     protected registerWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /** @inheritDoc */
-    protected registerOnceWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
+    protected sendStartupMessageToWorker(workerNodeKey: number): void;
     /** @inheritDoc */
-    protected deregisterWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
+    protected sendToWorker(workerNodeKey: number, message: MessageValue<Data>): void;
+    /** @inheritDoc */
+    protected setupHook(): void;
     /** @inheritDoc */
     protected shallCreateDynamicWorker(): boolean;
     /** @inheritDoc */
-    protected checkAndEmitDynamicWorkerCreationEvents(): void;
+    protected get busy(): boolean;
     /** @inheritDoc */
     protected get type(): PoolType;
     /** @inheritDoc */
     protected get worker(): WorkerType;
-    /** @inheritDoc */
-    protected get busy(): boolean;
 }
 
 /**
@@ -1713,13 +1720,13 @@ declare class DynamicClusterPool<Data = unknown, Response = unknown> extends Fix
      */
     constructor(min: number, max: number, filePath: string, opts?: ClusterPoolOptions);
     /** @inheritDoc */
-    protected shallCreateDynamicWorker(): boolean;
-    /** @inheritDoc */
     protected checkAndEmitDynamicWorkerCreationEvents(): void;
     /** @inheritDoc */
-    protected get type(): PoolType;
+    protected shallCreateDynamicWorker(): boolean;
     /** @inheritDoc */
     protected get busy(): boolean;
+    /** @inheritDoc */
+    protected get type(): PoolType;
 }
 
 /**
@@ -1743,27 +1750,27 @@ declare class FixedThreadPool<Data = unknown, Response = unknown> extends Abstra
      */
     constructor(numberOfThreads: number, filePath: string, opts?: ThreadPoolOptions, maximumNumberOfThreads?: number);
     /** @inheritDoc */
-    protected isMain(): boolean;
+    protected checkAndEmitDynamicWorkerCreationEvents(): void;
     /** @inheritDoc */
-    protected sendToWorker(workerNodeKey: number, message: MessageValue<Data>, transferList?: readonly TransferListItem[]): void;
+    protected deregisterWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /** @inheritDoc */
-    protected sendStartupMessageToWorker(workerNodeKey: number): void;
+    protected isMain(): boolean;
+    /** @inheritDoc */
+    protected registerOnceWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /** @inheritDoc */
     protected registerWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
     /** @inheritDoc */
-    protected registerOnceWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
+    protected sendStartupMessageToWorker(workerNodeKey: number): void;
     /** @inheritDoc */
-    protected deregisterWorkerMessageListener<Message extends Data | Response>(workerNodeKey: number, listener: (message: MessageValue<Message>) => void): void;
+    protected sendToWorker(workerNodeKey: number, message: MessageValue<Data>, transferList?: readonly TransferListItem[]): void;
     /** @inheritDoc */
     protected shallCreateDynamicWorker(): boolean;
     /** @inheritDoc */
-    protected checkAndEmitDynamicWorkerCreationEvents(): void;
+    protected get busy(): boolean;
     /** @inheritDoc */
     protected get type(): PoolType;
     /** @inheritDoc */
     protected get worker(): WorkerType;
-    /** @inheritDoc */
-    protected get busy(): boolean;
 }
 
 /**
@@ -1786,13 +1793,13 @@ declare class DynamicThreadPool<Data = unknown, Response = unknown> extends Fixe
      */
     constructor(min: number, max: number, filePath: string, opts?: ThreadPoolOptions);
     /** @inheritDoc */
-    protected shallCreateDynamicWorker(): boolean;
-    /** @inheritDoc */
     protected checkAndEmitDynamicWorkerCreationEvents(): void;
     /** @inheritDoc */
-    protected get type(): PoolType;
+    protected shallCreateDynamicWorker(): boolean;
     /** @inheritDoc */
     protected get busy(): boolean;
+    /** @inheritDoc */
+    protected get type(): PoolType;
 }
 
 /**
@@ -1801,10 +1808,10 @@ declare class DynamicThreadPool<Data = unknown, Response = unknown> extends Fixe
  * @internal
  */
 declare class PriorityQueue<T> {
-    private head;
-    private tail;
     private readonly bucketSize;
+    private head;
     private priorityEnabled;
+    private tail;
     /** The priority queue maximum size. */
     maxSize: number;
     /**
@@ -1814,33 +1821,11 @@ declare class PriorityQueue<T> {
      * @returns PriorityQueue.
      */
     constructor(bucketSize?: number, enablePriority?: boolean);
+    private getPriorityQueueNode;
     /**
-     * The priority queue size.
-     * @returns The priority queue size.
-     */
-    get size(): number;
-    /**
-     * Whether priority is enabled.
-     * @returns Whether priority is enabled.
-     */
-    get enablePriority(): boolean;
-    /**
-     * Enables/disables priority.
-     * @param enablePriority - Whether to enable priority.
-     */
-    set enablePriority(enablePriority: boolean);
-    /**
-     * The number of filled prioritized buckets.
-     * @returns The number of filled prioritized buckets.
-     */
-    get buckets(): number;
-    /**
-     * Enqueue data into the priority queue.
-     * @param data - Data to enqueue.
-     * @param priority - Priority of the data. Lower values have higher priority.
-     * @returns The new size of the priority queue.
+     * Clears the priority queue.
      */
-    enqueue(data: T, priority?: number): number;
+    clear(): void;
     /**
      * Dequeue data from the priority queue.
      * @param bucket - The prioritized bucket to dequeue from.
@@ -1848,16 +1833,38 @@ declare class PriorityQueue<T> {
      */
     dequeue(bucket?: number): T | undefined;
     /**
-     * Clears the priority queue.
+     * Enqueue data into the priority queue.
+     * @param data - Data to enqueue.
+     * @param priority - Priority of the data. Lower values have higher priority.
+     * @returns The new size of the priority queue.
      */
-    clear(): void;
+    enqueue(data: T, priority?: number): number;
     /**
      * Returns an iterator for the priority queue.
      * @returns An iterator for the priority queue.
      * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
      */
     [Symbol.iterator](): Iterator<T>;
-    private getPriorityQueueNode;
+    /**
+     * The number of filled prioritized buckets.
+     * @returns The number of filled prioritized buckets.
+     */
+    get buckets(): number;
+    /**
+     * Whether priority is enabled.
+     * @returns Whether priority is enabled.
+     */
+    get enablePriority(): boolean;
+    /**
+     * Enables/disables priority.
+     * @param enablePriority - Whether to enable priority.
+     */
+    set enablePriority(enablePriority: boolean);
+    /**
+     * The priority queue size.
+     * @returns The priority queue size.
+     */
+    get size(): number;
 }
 
 /**
@@ -1875,22 +1882,28 @@ interface FixedQueueNode<T> {
  * @internal
  */
 interface IFixedQueue<T> {
+    /**
+     * Returns an iterator for the fixed queue.
+     * @returns An iterator for the fixed queue.
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
+     */
+    [Symbol.iterator]: () => Iterator<T>;
     /** The fixed queue capacity. */
     readonly capacity: number;
-    /** The fixed queue size. */
-    readonly size: number;
-    /** The fixed queue node array. */
-    nodeArray: FixedQueueNode<T>[];
+    /**
+     * Clears the fixed queue.
+     */
+    clear: () => void;
+    /**
+     * Dequeue data from the fixed queue.
+     * @returns The dequeued data or `undefined` if the fixed queue is empty.
+     */
+    dequeue: () => T | undefined;
     /**
      * Checks if the fixed queue is empty.
      * @returns `true` if the fixed queue is empty, `false` otherwise.
      */
     empty: () => boolean;
-    /**
-     * Checks if the fixed queue is full.
-     * @returns `true` if the fixed queue is full, `false` otherwise.
-     */
-    full: () => boolean;
     /**
      * Enqueue data into the fixed queue.
      * @param data - Data to enqueue.
@@ -1899,27 +1912,21 @@ interface IFixedQueue<T> {
      * @throws If the fixed queue is full.
      */
     enqueue: (data: T, priority?: number) => number;
+    /**
+     * Checks if the fixed queue is full.
+     * @returns `true` if the fixed queue is full, `false` otherwise.
+     */
+    full: () => boolean;
     /**
      * Gets data from the fixed queue.
      * @param index - The index of the data to get.
      * @returns The data at the index or `undefined` if the fixed queue is empty or the index is out of bounds.
      */
     get: (index: number) => T | undefined;
-    /**
-     * Dequeue data from the fixed queue.
-     * @returns The dequeued data or `undefined` if the fixed queue is empty.
-     */
-    dequeue: () => T | undefined;
-    /**
-     * Clears the fixed queue.
-     */
-    clear: () => void;
-    /**
-     * Returns an iterator for the fixed queue.
-     * @returns An iterator for the fixed queue.
-     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
-     */
-    [Symbol.iterator]: () => Iterator<T>;
+    /** The fixed queue node array. */
+    nodeArray: FixedQueueNode<T>[];
+    /** The fixed queue size. */
+    readonly size: number;
 }
 
 /**
@@ -1935,30 +1942,47 @@ declare const availableParallelism: () => number;
  * @typeParam Data - Type of data this worker receives from pool's execution. This can only be structured-cloneable data.
  * @typeParam Response - Type of response the worker sends back to the main worker. This can only be structured-cloneable data.
  */
-declare abstract class AbstractWorker<MainWorker extends Worker | MessagePort, Data = unknown, Response = unknown> {
+declare abstract class AbstractWorker<MainWorker extends MessagePort | Worker, Data = unknown, Response = unknown> {
     protected readonly isMain: boolean | undefined;
     private readonly mainWorker;
     protected opts: WorkerOptions;
     /**
-     * Worker id.
+     * Handler id of the `activeInterval` worker activity check.
      */
-    protected abstract id: number;
+    protected activeInterval?: NodeJS.Timeout;
     /**
-     * Task function object(s) processed by the worker when the pool's `execution` function is invoked.
+     * Worker id.
      */
-    protected taskFunctions: Map<string, TaskFunctionObject<Data, Response>>;
+    protected abstract id: number;
     /**
      * Timestamp of the last task processed by this worker.
      */
     protected lastTaskTimestamp: number;
+    /**
+     * Runs the given task.
+     * @param task - The task to execute.
+     */
+    protected readonly run: (task: Task<Data>) => void;
+    /**
+     * Runs the given task function asynchronously.
+     * @param fn - Task function that will be executed.
+     * @param task - Input data for the task function.
+     */
+    protected readonly runAsync: (fn: TaskAsyncFunction<Data, Response>, task: Task<Data>) => void;
+    /**
+     * Runs the given task function synchronously.
+     * @param fn - Task function that will be executed.
+     * @param task - Input data for the task function.
+     */
+    protected readonly runSync: (fn: TaskSyncFunction<Data, Response>, task: Task<Data>) => void;
     /**
      * Performance statistics computation requirements.
      */
     protected statistics?: WorkerStatistics;
     /**
-     * Handler id of the `activeInterval` worker activity check.
+     * Task function object(s) processed by the worker when the pool's `execution` function is invoked.
      */
-    protected activeInterval?: NodeJS.Timeout;
+    protected taskFunctions: Map<string, TaskFunctionObject<Data, Response>>;
     /**
      * Constructs a new poolifier worker.
      * @param isMain - Whether this is the main worker or not.
@@ -1966,66 +1990,62 @@ declare abstract class AbstractWorker<MainWorker extends Worker | MessagePort, D
      * @param taskFunctions - Task function(s) processed by the worker when the pool's `execution` function is invoked. The first function is the default function.
      * @param opts - Options for the worker.
      */
-    constructor(isMain: boolean | undefined, mainWorker: MainWorker | undefined | null, taskFunctions: TaskFunction<Data, Response> | TaskFunctions<Data, Response>, opts?: WorkerOptions);
-    private checkWorkerOptions;
-    /**
-     * Checks if the `taskFunctions` parameter is passed to the constructor and valid.
-     * @param taskFunctions - The task function(s) parameter that should be checked.
-     */
-    private checkTaskFunctions;
-    /**
-     * Checks if the worker has a task function with the given name.
-     * @param name - The name of the task function to check.
-     * @returns Whether the worker has a task function with the given name or not.
-     */
-    hasTaskFunction(name: string): TaskFunctionOperationResult;
-    /**
-     * Adds a task function to the worker.
-     * If a task function with the same name already exists, it is replaced.
-     * @param name - The name of the task function to add.
-     * @param fn - The task function to add.
-     * @returns Whether the task function was added or not.
-     */
-    addTaskFunction(name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>): TaskFunctionOperationResult;
+    constructor(isMain: boolean | undefined, mainWorker: MainWorker | null | undefined, taskFunctions: TaskFunction<Data, Response> | TaskFunctions<Data, Response>, opts?: WorkerOptions);
     /**
-     * Removes a task function from the worker.
-     * @param name - The name of the task function to remove.
-     * @returns Whether the task function existed and was removed or not.
+     * Returns the main worker.
+     * @returns Reference to the main worker.
+     * @throws {@link https://nodejs.org/api/errors.html#class-error} If the main worker is not set.
      */
-    removeTaskFunction(name: string): TaskFunctionOperationResult;
+    protected getMainWorker(): MainWorker;
     /**
-     * Lists the properties of the worker's task functions.
-     * @returns The properties of the worker's task functions.
+     * Handles an error and convert it to a string so it can be sent back to the main worker.
+     * @param error - The error raised by the worker.
+     * @returns The error message.
      */
-    listTaskFunctionsProperties(): TaskFunctionProperties[];
+    protected handleError(error: Error | string): string;
     /**
-     * Sets the default task function to use in the worker.
-     * @param name - The name of the task function to use as default task function.
-     * @returns Whether the default task function was set or not.
+     * Handles a kill message sent by the main worker.
+     * @param message - The kill message.
      */
-    setDefaultTaskFunction(name: string): TaskFunctionOperationResult;
+    protected handleKillMessage(message: MessageValue<Data>): void;
     /**
      * Handles the ready message sent by the main worker.
      * @param message - The ready message.
      */
     protected abstract handleReadyMessage(message: MessageValue<Data>): void;
+    protected handleTaskFunctionOperationMessage(message: MessageValue<Data>): void;
     /**
      * Worker message listener.
      * @param message - The received message.
      */
     protected messageListener(message: MessageValue<Data>): void;
-    protected handleTaskFunctionOperationMessage(message: MessageValue<Data>): void;
     /**
-     * Handles a kill message sent by the main worker.
-     * @param message - The kill message.
+     * Sends task functions properties to the main worker.
      */
-    protected handleKillMessage(message: MessageValue<Data>): void;
+    protected sendTaskFunctionsPropertiesToMainWorker(): void;
+    /**
+     * Sends a message to main worker.
+     * @param message - The response message.
+     */
+    protected abstract sendToMainWorker(message: MessageValue<Response, Data>): void;
+    private beginTaskPerformance;
+    /**
+     * Checks if the worker should be terminated, because its living too long.
+     */
+    private checkActive;
     /**
      * Check if the message worker id is set and matches the worker id.
      * @param message - The message to check.
      * @throws {@link https://nodejs.org/api/errors.html#class-error} If the message worker id is not set or does not match the worker id.
      */
     private checkMessageWorkerId;
+    /**
+     * Checks if the `taskFunctions` parameter is passed to the constructor and valid.
+     * @param taskFunctions - The task function(s) parameter that should be checked.
+     */
+    private checkTaskFunctions;
+    private checkWorkerOptions;
+    private endTaskPerformance;
     /**
      * Starts the worker check active interval.
      */
@@ -2034,51 +2054,38 @@ declare abstract class AbstractWorker<MainWorker extends Worker | MessagePort, D
      * Stops the worker check active interval.
      */
     private stopCheckActive;
+    private updateLastTaskTimestamp;
     /**
-     * Checks if the worker should be terminated, because its living too long.
-     */
-    private checkActive;
-    /**
-     * Returns the main worker.
-     * @returns Reference to the main worker.
-     * @throws {@link https://nodejs.org/api/errors.html#class-error} If the main worker is not set.
-     */
-    protected getMainWorker(): MainWorker;
-    /**
-     * Sends a message to main worker.
-     * @param message - The response message.
-     */
-    protected abstract sendToMainWorker(message: MessageValue<Response, Data>): void;
-    /**
-     * Sends task functions properties to the main worker.
+     * Adds a task function to the worker.
+     * If a task function with the same name already exists, it is replaced.
+     * @param name - The name of the task function to add.
+     * @param fn - The task function to add.
+     * @returns Whether the task function was added or not.
      */
-    protected sendTaskFunctionsPropertiesToMainWorker(): void;
+    addTaskFunction(name: string, fn: TaskFunction<Data, Response> | TaskFunctionObject<Data, Response>): TaskFunctionOperationResult;
     /**
-     * Handles an error and convert it to a string so it can be sent back to the main worker.
-     * @param error - The error raised by the worker.
-     * @returns The error message.
+     * Checks if the worker has a task function with the given name.
+     * @param name - The name of the task function to check.
+     * @returns Whether the worker has a task function with the given name or not.
      */
-    protected handleError(error: Error | string): string;
+    hasTaskFunction(name: string): TaskFunctionOperationResult;
     /**
-     * Runs the given task.
-     * @param task - The task to execute.
+     * Lists the properties of the worker's task functions.
+     * @returns The properties of the worker's task functions.
      */
-    protected readonly run: (task: Task<Data>) => void;
+    listTaskFunctionsProperties(): TaskFunctionProperties[];
     /**
-     * Runs the given task function synchronously.
-     * @param fn - Task function that will be executed.
-     * @param task - Input data for the task function.
+     * Removes a task function from the worker.
+     * @param name - The name of the task function to remove.
+     * @returns Whether the task function existed and was removed or not.
      */
-    protected readonly runSync: (fn: TaskSyncFunction<Data, Response>, task: Task<Data>) => void;
+    removeTaskFunction(name: string): TaskFunctionOperationResult;
     /**
-     * Runs the given task function asynchronously.
-     * @param fn - Task function that will be executed.
-     * @param task - Input data for the task function.
+     * Sets the default task function to use in the worker.
+     * @param name - The name of the task function to use as default task function.
+     * @returns Whether the default task function was set or not.
      */
-    protected readonly runAsync: (fn: TaskAsyncFunction<Data, Response>, task: Task<Data>) => void;
-    private beginTaskPerformance;
-    private endTaskPerformance;
-    private updateLastTaskTimestamp;
+    setDefaultTaskFunction(name: string): TaskFunctionOperationResult;
 }
 
 /**
@@ -2095,6 +2102,8 @@ declare abstract class AbstractWorker<MainWorker extends Worker | MessagePort, D
  * @since 2.0.0
  */
 declare class ClusterWorker<Data = unknown, Response = unknown> extends AbstractWorker<Worker, Data, Response> {
+    /** @inheritDoc */
+    protected readonly sendToMainWorker: (message: MessageValue<Response>) => void;
     /**
      * Constructs a new poolifier cluster worker.
      * @param taskFunctions - Task function(s) processed by the worker when the pool's `execution` function is invoked.
@@ -2105,8 +2114,6 @@ declare class ClusterWorker<Data = unknown, Response = unknown> extends Abstract
     protected handleReadyMessage(message: MessageValue<Data>): void;
     /** @inheritDoc */
     protected get id(): number;
-    /** @inheritDoc */
-    protected readonly sendToMainWorker: (message: MessageValue<Response>) => void;
 }
 
 /**
@@ -2123,6 +2130,8 @@ declare class ClusterWorker<Data = unknown, Response = unknown> extends Abstract
  * @since 0.0.1
  */
 declare class ThreadWorker<Data = unknown, Response = unknown> extends AbstractWorker<MessagePort, Data, Response> {
+    /** @inheritDoc */
+    protected readonly sendToMainWorker: (message: MessageValue<Response>) => void;
     /**
      * Message port used to communicate with the main worker.
      */
@@ -2133,18 +2142,16 @@ declare class ThreadWorker<Data = unknown, Response = unknown> extends AbstractW
      * @param opts - Options for the worker.
      */
     constructor(taskFunctions: TaskFunction<Data, Response> | TaskFunctions<Data, Response>, opts?: WorkerOptions);
-    /** @inheritDoc */
-    protected handleReadyMessage(message: MessageValue<Data>): void;
-    /** @inheritDoc */
-    protected handleKillMessage(message: MessageValue<Data>): void;
-    /** @inheritDoc */
-    protected get id(): number;
-    /** @inheritDoc */
-    protected readonly sendToMainWorker: (message: MessageValue<Response>) => void;
     /**
      * @inheritDoc
      */
     protected handleError(error: Error | string): string;
+    /** @inheritDoc */
+    protected handleKillMessage(message: MessageValue<Data>): void;
+    /** @inheritDoc */
+    protected handleReadyMessage(message: MessageValue<Data>): void;
+    /** @inheritDoc */
+    protected get id(): number;
 }
 
 export { AbstractPool, AbstractWorker, CircularBuffer, type ClusterPoolOptions, ClusterWorker, DynamicClusterPool, DynamicThreadPool, type ErrorHandler, type EventHandler, type EventLoopUtilizationMeasurementStatistics, type ExitHandler, FixedClusterPool, type FixedQueueNode, FixedThreadPool, type IFixedQueue, type IPool, type IWorker, type IWorkerChoiceStrategy, type IWorkerNode, type KillBehavior, KillBehaviors, type KillHandler, type Measurement, type MeasurementOptions, type MeasurementStatistics, type MeasurementStatisticsRequirements, Measurements, type MessageHandler, type MessageValue, type OnlineHandler, type PoolEvent, PoolEvents, type PoolInfo, type PoolOptions, type PoolType, PoolTypes, PriorityQueue, type PromiseResponseWrapper, type StrategyData, type StrategyPolicy, type Task, type TaskAsyncFunction, type TaskFunction, type TaskFunctionObject, type TaskFunctionOperationResult, type TaskFunctionProperties, type TaskFunctions, type TaskPerformance, type TaskStatistics, type TaskStatisticsRequirements, type TaskSyncFunction, type TasksQueueOptions, type ThreadPoolOptions, ThreadWorker, WorkerChoiceStrategies, WorkerChoiceStrategiesContext, type WorkerChoiceStrategy, type WorkerChoiceStrategyOptions, type WorkerError, type WorkerInfo, type WorkerNodeEventDetail, type WorkerNodeOptions, type WorkerOptions, type WorkerStatistics, type WorkerType, WorkerTypes, type WorkerUsage, type Writable, availableParallelism };