poolifier 3.1.21 → 3.1.22

package/lib/index.d.ts

@@ -1,10 +1,116 @@
 /// <reference types="node" />
-import { TransferListItem, MessagePort, WorkerOptions as WorkerOptions$1, MessageChannel, Worker as Worker$1 } from 'node:worker_threads';
 import { EventEmitter, EventEmitterAsyncResource } from 'node:events';
-import { EventLoopUtilization } from 'node:perf_hooks';
+import { TransferListItem, MessagePort, WorkerOptions as WorkerOptions$1, MessageChannel, Worker as Worker$1 } from 'node:worker_threads';
 import { AsyncResource } from 'node:async_hooks';
+import { EventLoopUtilization } from 'node:perf_hooks';
 import { ClusterSettings, Worker } from 'node:cluster';
 
+/**
+ * Array with a maximum length and shifting items when full.
+ *
+ * @typeParam T - Type of items.
+ * @internal
+ */
+declare class CircularArray<T> extends Array<T> {
+    size: number;
+    constructor(size?: number, ...items: T[]);
+    /** @inheritDoc */
+    push(...items: T[]): number;
+    /** @inheritDoc */
+    unshift(...items: T[]): number;
+    /** @inheritDoc */
+    concat(...items: Array<T | ConcatArray<T>>): CircularArray<T>;
+    /** @inheritDoc */
+    splice(start: number, deleteCount?: number, ...items: T[]): CircularArray<T>;
+    resize(size: number): void;
+    empty(): boolean;
+    full(): boolean;
+    private checkSize;
+}
+
+/**
+ * Linked list node interface.
+ *
+ * @typeParam T - Type of linked list node data.
+ * @internal
+ */
+interface ILinkedListNode<T> {
+    data: T;
+    next?: ILinkedListNode<T>;
+    prev?: ILinkedListNode<T>;
+}
+/**
+ * Deque.
+ * Implemented with a doubly linked list.
+ *
+ * @typeParam T - Type of deque data.
+ * @internal
+ */
+declare class Deque<T> {
+    private head?;
+    private tail?;
+    /** The size of the deque. */
+    size: number;
+    /** The maximum size of the deque. */
+    maxSize: number;
+    constructor();
+    /**
+     * Appends data to the deque.
+     *
+     * @param data - Data to append.
+     * @returns The new size of the deque.
+     */
+    push(data: T): number;
+    /**
+     * Prepends data to the deque.
+     *
+     * @param data - Data to prepend.
+     * @returns The new size of the deque.
+     */
+    unshift(data: T): number;
+    /**
+     * Pops data from the deque.
+     *
+     * @returns The popped data or `undefined` if the deque is empty.
+     */
+    pop(): T | undefined;
+    /**
+     * Shifts data from the deque.
+     *
+     * @returns The shifted data or `undefined` if the deque is empty.
+     */
+    shift(): T | undefined;
+    /**
+     * Peeks at the first data.
+     * @returns The first data or `undefined` if the deque is empty.
+     */
+    peekFirst(): T | undefined;
+    /**
+     * Peeks at the last data.
+     * @returns The last data or `undefined` if the deque is empty.
+     */
+    peekLast(): T | undefined;
+    /**
+     * Clears the deque.
+     */
+    clear(): void;
+    /**
+     * Returns an iterator for the deque.
+     *
+     * @returns An iterator for the deque.
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Returns an backward iterator for the deque.
+     *
+     * @returns An backward iterator for the deque.
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
+     */
+    backward(): Iterable<T>;
+    private incrementSize;
+}
+
 /**
  * Enumeration of kill behaviors.
  */
@@ -285,26 +391,200 @@ interface TaskFunctionOperationResult {
 }
 
 /**
- * Array with a maximum length and shifting items when full.
+ * Enumeration of worker choice strategies.
+ */
+declare const WorkerChoiceStrategies: Readonly<{
+    /**
+     * Round robin worker selection strategy.
+     */
+    readonly ROUND_ROBIN: "ROUND_ROBIN";
+    /**
+     * Least used worker selection strategy.
+     */
+    readonly LEAST_USED: "LEAST_USED";
+    /**
+     * Least busy worker selection strategy.
+     */
+    readonly LEAST_BUSY: "LEAST_BUSY";
+    /**
+     * Least ELU worker selection strategy.
+     */
+    readonly LEAST_ELU: "LEAST_ELU";
+    /**
+     * Fair share worker selection strategy.
+     */
+    readonly FAIR_SHARE: "FAIR_SHARE";
+    /**
+     * Weighted round robin worker selection strategy.
+     */
+    readonly WEIGHTED_ROUND_ROBIN: "WEIGHTED_ROUND_ROBIN";
+    /**
+     * Interleaved weighted round robin worker selection strategy.
+     *
+     * @experimental
+     */
+    readonly INTERLEAVED_WEIGHTED_ROUND_ROBIN: "INTERLEAVED_WEIGHTED_ROUND_ROBIN";
+}>;
+/**
+ * Worker choice strategy.
+ */
+type WorkerChoiceStrategy = keyof typeof WorkerChoiceStrategies;
+/**
+ * Enumeration of measurements.
+ */
+declare const Measurements: Readonly<{
+    readonly runTime: "runTime";
+    readonly waitTime: "waitTime";
+    readonly elu: "elu";
+}>;
+/**
+ * Measurement.
+ */
+type Measurement = keyof typeof Measurements;
+/**
+ * Measurement options.
+ */
+interface MeasurementOptions {
+    /**
+     * Set measurement median.
+     */
+    readonly median: boolean;
+}
+/**
+ * Worker choice strategy options.
+ */
+interface WorkerChoiceStrategyOptions {
+    /**
+     * Measurement to use in worker choice strategy supporting it.
+     */
+    readonly measurement?: Measurement;
+    /**
+     * Runtime options.
+     *
+     * @defaultValue \{ median: false \}
+     */
+    readonly runTime?: MeasurementOptions;
+    /**
+     * Wait time options.
+     *
+     * @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.
+     *
+     * @defaultValue Weights computed automatically given the CPU performance.
+     */
+    weights?: Record<number, number>;
+}
+/**
+ * Measurement statistics requirements.
  *
- * @typeParam T - Type of items.
  * @internal
  */
-declare class CircularArray<T> extends Array<T> {
-    size: number;
-    constructor(size?: number, ...items: T[]);
-    /** @inheritDoc */
-    push(...items: T[]): number;
-    /** @inheritDoc */
-    unshift(...items: T[]): number;
-    /** @inheritDoc */
-    concat(...items: Array<T | ConcatArray<T>>): CircularArray<T>;
-    /** @inheritDoc */
-    splice(start: number, deleteCount?: number, ...items: T[]): CircularArray<T>;
-    resize(size: number): void;
-    empty(): boolean;
-    full(): boolean;
-    private checkSize;
+interface MeasurementStatisticsRequirements {
+    /**
+     * Requires measurement aggregate.
+     */
+    aggregate: boolean;
+    /**
+     * Requires measurement average.
+     */
+    average: boolean;
+    /**
+     * Requires measurement median.
+     */
+    median: boolean;
+}
+/**
+ * Pool worker node worker usage statistics requirements.
+ *
+ * @internal
+ */
+interface TaskStatisticsRequirements {
+    /**
+     * Tasks runtime requirements.
+     */
+    readonly runTime: MeasurementStatisticsRequirements;
+    /**
+     * 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;
+}
+/**
+ * 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.
+     * If `undefined` is returned, the caller retry.
+     *
+     * @returns The worker node key or `undefined`.
+     */
+    readonly choose: () => number | undefined;
+    /**
+     * Removes the worker node key from strategy internals.
+     *
+     * @param workerNodeKey - The worker node key.
+     * @returns `true` if the worker node key is removed, `false` otherwise.
+     */
+    readonly remove: (workerNodeKey: number) => boolean;
+    /**
+     * Sets the worker choice strategy options.
+     *
+     * @param opts - The worker choice strategy options.
+     */
+    readonly setOptions: (opts: WorkerChoiceStrategyOptions | undefined) => void;
 }
 
 /**
@@ -550,317 +830,120 @@ interface WorkerNodeOptions {
  * @typeParam Data - Type of data sent to the worker. This can only be structured-cloneable data.
  * @internal
  */
-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).
-     */
-    readonly messageChannel?: MessageChannel;
-    /**
-     * Tasks queue back pressure size.
-     * This is the number of tasks that can be enqueued before the worker node has back pressure.
-     */
-    tasksQueueBackPressureSize: number;
-    /**
-     * Tasks queue size.
-     *
-     * @returns The tasks queue size.
-     */
-    readonly tasksQueueSize: () => number;
-    /**
-     * Enqueue task.
-     *
-     * @param task - The task to queue.
-     * @returns The tasks queue size.
-     */
-    readonly enqueueTask: (task: Task<Data>) => number;
-    /**
-     * Prepends a task to the tasks queue.
-     *
-     * @param task - The task to prepend.
-     * @returns The tasks queue size.
-     */
-    readonly unshiftTask: (task: Task<Data>) => number;
-    /**
-     * Dequeue task.
-     *
-     * @returns The dequeued task.
-     */
-    readonly dequeueTask: () => Task<Data> | undefined;
-    /**
-     * Pops a task from the tasks queue.
-     *
-     * @returns The popped task.
-     */
-    readonly popTask: () => Task<Data> | undefined;
-    /**
-     * Clears tasks queue.
-     */
-    readonly clearTasksQueue: () => void;
-    /**
-     * 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 hasBackPressure: () => boolean;
-    /**
-     * Resets usage statistics.
-     */
-    readonly resetUsage: () => void;
-    /**
-     * Terminates the worker node.
-     */
-    readonly terminate: () => Promise<void>;
-    /**
-     * Registers a worker event handler.
-     *
-     * @param event - The event.
-     * @param handler - The event handler.
-     */
-    readonly registerWorkerEventHandler: (event: string, handler: EventHandler<Worker>) => void;
-    /**
-     * Registers once a worker event handler.
-     *
-     * @param event - The event.
-     * @param handler - The event handler.
-     */
-    readonly registerOnceWorkerEventHandler: (event: string, handler: EventHandler<Worker>) => 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.
-     */
-    readonly getTaskFunctionWorkerUsage: (name: string) => WorkerUsage | undefined;
-    /**
-     * 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.
-     */
-    readonly deleteTaskFunctionWorkerUsage: (name: string) => boolean;
-}
-/**
- * Worker node event detail.
- *
- * @internal
- */
-interface WorkerNodeEventDetail {
-    workerId?: number;
-    workerNodeKey?: number;
-}
-
-/**
- * Enumeration of worker choice strategies.
- */
-declare const WorkerChoiceStrategies: Readonly<{
-    /**
-     * Round robin worker selection strategy.
-     */
-    readonly ROUND_ROBIN: "ROUND_ROBIN";
-    /**
-     * Least used worker selection strategy.
-     */
-    readonly LEAST_USED: "LEAST_USED";
-    /**
-     * Least busy worker selection strategy.
-     */
-    readonly LEAST_BUSY: "LEAST_BUSY";
-    /**
-     * Least ELU worker selection strategy.
-     */
-    readonly LEAST_ELU: "LEAST_ELU";
-    /**
-     * Fair share worker selection strategy.
-     */
-    readonly FAIR_SHARE: "FAIR_SHARE";
-    /**
-     * Weighted round robin worker selection strategy.
-     */
-    readonly WEIGHTED_ROUND_ROBIN: "WEIGHTED_ROUND_ROBIN";
-    /**
-     * Interleaved weighted round robin worker selection strategy.
-     *
-     * @experimental
-     */
-    readonly INTERLEAVED_WEIGHTED_ROUND_ROBIN: "INTERLEAVED_WEIGHTED_ROUND_ROBIN";
-}>;
-/**
- * Worker choice strategy.
- */
-type WorkerChoiceStrategy = keyof typeof WorkerChoiceStrategies;
-/**
- * Enumeration of measurements.
- */
-declare const Measurements: Readonly<{
-    readonly runTime: "runTime";
-    readonly waitTime: "waitTime";
-    readonly elu: "elu";
-}>;
-/**
- * Measurement.
- */
-type Measurement = keyof typeof Measurements;
-/**
- * Measurement options.
- */
-interface MeasurementOptions {
-    /**
-     * Set measurement median.
-     */
-    readonly median: boolean;
-}
-/**
- * Worker choice strategy options.
- */
-interface WorkerChoiceStrategyOptions {
-    /**
-     * Measurement to use in worker choice strategy supporting it.
-     */
-    readonly measurement?: Measurement;
+interface IWorkerNode<Worker extends IWorker, Data = unknown> extends EventEmitter {
     /**
-     * Runtime options.
-     *
-     * @defaultValue \{ median: false \}
+     * Worker.
      */
-    readonly runTime?: MeasurementOptions;
+    readonly worker: Worker;
     /**
-     * Wait time options.
-     *
-     * @defaultValue \{ median: false \}
+     * Worker info.
      */
-    readonly waitTime?: MeasurementOptions;
+    readonly info: WorkerInfo;
     /**
-     * Event loop utilization options.
-     *
-     * @defaultValue \{ median: false \}
+     * Worker usage statistics.
      */
-    readonly elu?: MeasurementOptions;
+    readonly usage: WorkerUsage;
     /**
-     * Worker weights to use for weighted round robin worker selection strategies.
-     * A weight is tasks maximum execution time in milliseconds for a worker node.
-     *
-     * @defaultValue Weights computed automatically given the CPU performance.
+     * Worker choice strategy data.
+     * This is used to store data that are specific to the worker choice strategy.
      */
-    weights?: Record<number, number>;
-}
-/**
- * Measurement statistics requirements.
- *
- * @internal
- */
-interface MeasurementStatisticsRequirements {
+    strategyData?: StrategyData;
     /**
-     * Requires measurement aggregate.
+     * Message channel (worker thread only).
      */
-    aggregate: boolean;
+    readonly messageChannel?: MessageChannel;
     /**
-     * Requires measurement average.
+     * Tasks queue back pressure size.
+     * This is the number of tasks that can be enqueued before the worker node has back pressure.
      */
-    average: boolean;
+    tasksQueueBackPressureSize: number;
     /**
-     * Requires measurement median.
+     * Tasks queue size.
+     *
+     * @returns The tasks queue size.
      */
-    median: boolean;
-}
-/**
- * Pool worker node worker usage statistics requirements.
- *
- * @internal
- */
-interface TaskStatisticsRequirements {
+    readonly tasksQueueSize: () => number;
     /**
-     * Tasks runtime requirements.
+     * Enqueue task.
+     *
+     * @param task - The task to queue.
+     * @returns The tasks queue size.
      */
-    readonly runTime: MeasurementStatisticsRequirements;
+    readonly enqueueTask: (task: Task<Data>) => number;
     /**
-     * Tasks wait time requirements.
+     * Prepends a task to the tasks queue.
+     *
+     * @param task - The task to prepend.
+     * @returns The tasks queue size.
      */
-    readonly waitTime: MeasurementStatisticsRequirements;
+    readonly unshiftTask: (task: Task<Data>) => number;
     /**
-     * Tasks event loop utilization requirements.
+     * Dequeue task.
+     *
+     * @returns The dequeued task.
      */
-    readonly elu: MeasurementStatisticsRequirements;
-}
-/**
- * Strategy policy.
- *
- * @internal
- */
-interface StrategyPolicy {
+    readonly dequeueTask: () => Task<Data> | undefined;
     /**
-     * Expects tasks execution on the newly created dynamic worker.
+     * Pops a task from the tasks queue.
+     *
+     * @returns The popped task.
      */
-    readonly dynamicWorkerUsage: boolean;
+    readonly popTask: () => Task<Data> | undefined;
     /**
-     * Expects the newly created dynamic worker to be flagged as ready.
+     * Clears tasks queue.
      */
-    readonly dynamicWorkerReady: boolean;
-}
-/**
- * Worker choice strategy interface.
- *
- * @internal
- */
-interface IWorkerChoiceStrategy {
+    readonly clearTasksQueue: () => void;
     /**
-     * Strategy policy.
+     * 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 strategyPolicy: StrategyPolicy;
+    readonly hasBackPressure: () => boolean;
     /**
-     * Tasks statistics requirements.
+     * Resets usage statistics.
      */
-    readonly taskStatisticsRequirements: TaskStatisticsRequirements;
+    readonly resetUsage: () => void;
     /**
-     * Resets strategy internals.
-     *
-     * @returns `true` if the reset is successful, `false` otherwise.
+     * Terminates the worker node.
      */
-    readonly reset: () => boolean;
+    readonly terminate: () => Promise<void>;
     /**
-     * Updates the worker node key strategy internals.
-     * This is called after a task has been executed on a worker node.
+     * Registers a worker event handler.
      *
-     * @returns `true` if the update is successful, `false` otherwise.
+     * @param event - The event.
+     * @param handler - The event handler.
      */
-    readonly update: (workerNodeKey: number) => boolean;
+    readonly registerWorkerEventHandler: (event: string, handler: EventHandler<Worker>) => void;
     /**
-     * Chooses a worker node in the pool and returns its key.
-     * If no worker nodes are not eligible, `undefined` is returned.
-     * If `undefined` is returned, the caller retry.
+     * Registers once a worker event handler.
      *
-     * @returns The worker node key or `undefined`.
+     * @param event - The event.
+     * @param handler - The event handler.
      */
-    readonly choose: () => number | undefined;
+    readonly registerOnceWorkerEventHandler: (event: string, handler: EventHandler<Worker>) => void;
     /**
-     * Removes the worker node key from strategy internals.
+     * Gets task function worker usage statistics.
      *
-     * @param workerNodeKey - The worker node key.
-     * @returns `true` if the worker node key is removed, `false` otherwise.
+     * @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 remove: (workerNodeKey: number) => boolean;
+    readonly getTaskFunctionWorkerUsage: (name: string) => WorkerUsage | undefined;
     /**
-     * Sets the worker choice strategy options.
+     * Deletes task function worker usage statistics.
      *
-     * @param opts - The worker choice strategy options.
+     * @param name - The task function name.
+     * @returns `true` if the task function worker usage statistics were deleted, `false` otherwise.
      */
-    readonly setOptions: (opts: WorkerChoiceStrategyOptions | undefined) => void;
+    readonly deleteTaskFunctionWorkerUsage: (name: string) => boolean;
+}
+/**
+ * Worker node event detail.
+ *
+ * @internal
+ */
+interface WorkerNodeEventDetail {
+    workerId?: number;
+    workerNodeKey?: number;
 }
 
 /**
@@ -1079,7 +1162,7 @@ interface IPool<Worker extends IWorker, Data = unknown, Response = unknown> {
      */
     readonly workerNodes: Array<IWorkerNode<Worker, Data>>;
     /**
-     * Event emitter integrated with async resource on which events can be listened to.
+     * Pool event emitter integrated with async resource.
      * The async tracking tooling identifier is `poolifier:<PoolType>-<WorkerType>-pool`.
      *
      * Events that can currently be listened to:
@@ -1758,6 +1841,14 @@ declare class DynamicThreadPool<Data = unknown, Response = unknown> extends Fixe
     protected get busy(): boolean;
 }
 
+/**
+ * Returns safe host OS optimized estimate of the default amount of parallelism a pool should use.
+ * Always returns a value greater than zero.
+ *
+ * @returns The host OS optimized maximum pool size.
+ */
+declare const availableParallelism: () => number;
+
 /**
  * Base class that implements some shared logic for all poolifier workers.
  *
@@ -1999,95 +2090,4 @@ declare class ThreadWorker<Data = unknown, Response = unknown> extends AbstractW
     protected handleError(error: Error | string): string;
 }
 
-/**
- * Linked list node interface.
- *
- * @typeParam T - Type of linked list node data.
- * @internal
- */
-interface ILinkedListNode<T> {
-    data: T;
-    next?: ILinkedListNode<T>;
-    prev?: ILinkedListNode<T>;
-}
-/**
- * Deque.
- * Implemented with a doubly linked list.
- *
- * @typeParam T - Type of deque data.
- * @internal
- */
-declare class Deque<T> {
-    private head?;
-    private tail?;
-    /** The size of the deque. */
-    size: number;
-    /** The maximum size of the deque. */
-    maxSize: number;
-    constructor();
-    /**
-     * Appends data to the deque.
-     *
-     * @param data - Data to append.
-     * @returns The new size of the deque.
-     */
-    push(data: T): number;
-    /**
-     * Prepends data to the deque.
-     *
-     * @param data - Data to prepend.
-     * @returns The new size of the deque.
-     */
-    unshift(data: T): number;
-    /**
-     * Pops data from the deque.
-     *
-     * @returns The popped data or `undefined` if the deque is empty.
-     */
-    pop(): T | undefined;
-    /**
-     * Shifts data from the deque.
-     *
-     * @returns The shifted data or `undefined` if the deque is empty.
-     */
-    shift(): T | undefined;
-    /**
-     * Peeks at the first data.
-     * @returns The first data or `undefined` if the deque is empty.
-     */
-    peekFirst(): T | undefined;
-    /**
-     * Peeks at the last data.
-     * @returns The last data or `undefined` if the deque is empty.
-     */
-    peekLast(): T | undefined;
-    /**
-     * Clears the deque.
-     */
-    clear(): void;
-    /**
-     * Returns an iterator for the deque.
-     *
-     * @returns An iterator for the deque.
-     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
-     */
-    [Symbol.iterator](): Iterator<T>;
-    /**
-     * Returns an backward iterator for the deque.
-     *
-     * @returns An backward iterator for the deque.
-     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
-     */
-    backward(): Iterable<T>;
-    private incrementSize;
-}
-
-/**
- * Returns safe host OS optimized estimate of the default amount of parallelism a pool should use.
- * Always returns a value greater than zero.
- *
- * @returns The host OS optimized maximum pool size.
- */
-declare const availableParallelism: () => number;
-
 export { AbstractPool, AbstractWorker, CircularArray, type ClusterPoolOptions, ClusterWorker, Deque, DynamicClusterPool, DynamicThreadPool, type ErrorHandler, type EventHandler, type EventLoopUtilizationMeasurementStatistics, type ExitHandler, FixedClusterPool, FixedThreadPool, type ILinkedListNode, 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, type PromiseResponseWrapper, type StrategyData, type StrategyPolicy, type Task, type TaskAsyncFunction, type TaskFunction, type TaskFunctionOperationResult, type TaskFunctions, type TaskPerformance, type TaskStatistics, type TaskStatisticsRequirements, type TaskSyncFunction, type TasksQueueOptions, type ThreadPoolOptions, ThreadWorker, WorkerChoiceStrategies, type WorkerChoiceStrategy, WorkerChoiceStrategyContext, type WorkerChoiceStrategyOptions, type WorkerError, type WorkerInfo, type WorkerNodeEventDetail, type WorkerNodeOptions, type WorkerOptions, type WorkerStatistics, type WorkerType, WorkerTypes, type WorkerUsage, type Writable, availableParallelism };