poolifier 2.3.7 → 2.3.9

package/lib/index.d.ts

@@ -1,881 +1,14 @@
-/// <reference types="node" />
-import EventEmitter from "events";
-import { ClusterSettings, Worker } from "cluster";
-import { Worker as ClusterWorker } from "cluster";
-import { MessagePort, MessageChannel } from "worker_threads";
-import { Worker as Worker$0 } from "worker_threads";
-import { AsyncResource } from "async_hooks";
-/**
- * Callback invoked if the worker has received a message.
- */
-type MessageHandler<Worker> = (this: Worker, m: unknown) => void;
-/**
- * Callback invoked if the worker raised an error.
- */
-type ErrorHandler<Worker> = (this: Worker, e: Error) => void;
-/**
- * Callback invoked when the worker has started successfully.
- */
-type OnlineHandler<Worker> = (this: Worker) => void;
-/**
- * Callback invoked when the worker exits successfully.
- */
-type ExitHandler<Worker> = (this: Worker, code: number) => void;
-/**
- * Interface that describes the minimum required implementation of listener events for a pool worker.
- */
-interface IPoolWorker {
-    /**
-     * Register an event listener.
-     *
-     * @param event The event.
-     * @param handler The event listener.
-     */
-    on: ((event: "message", handler: MessageHandler<this>) => void) & ((event: "error", handler: ErrorHandler<this>) => void) & ((event: "online", handler: OnlineHandler<this>) => void) & ((event: "exit", handler: ExitHandler<this>) => void);
-    /**
-     * Register a listener to the exit event that will only performed once.
-     *
-     * @param event `'exit'`.
-     * @param handler The exit handler.
-     */
-    once: (event: "exit", handler: ExitHandler<this>) => void;
-}
-/**
- * Enumeration of worker choice strategies.
- */
-declare const WorkerChoiceStrategies: Readonly<{
-    readonly ROUND_ROBIN: "ROUND_ROBIN";
-    readonly LESS_RECENTLY_USED: "LESS_RECENTLY_USED";
-    readonly FAIR_SHARE: "FAIR_SHARE";
-    readonly WEIGHTED_ROUND_ROBIN: "WEIGHTED_ROUND_ROBIN";
-}>;
-/**
- * Worker choice strategy.
- */
-type WorkerChoiceStrategy = keyof typeof WorkerChoiceStrategies;
-/**
- * Pool tasks usage statistics requirements.
- */
-interface RequiredStatistics {
-    runTime: boolean;
-}
-/**
- * Worker choice strategy interface.
- *
- * @template Worker Type of worker which manages the strategy.
- */
-interface IWorkerChoiceStrategy<Worker extends IPoolWorker> {
-    /**
-     * Is the pool attached to the strategy dynamic?.
-     */
-    readonly isDynamicPool: boolean;
-    /**
-     * Required pool tasks usage statistics.
-     */
-    readonly requiredStatistics: RequiredStatistics;
-    /**
-     * Resets strategy internals (counters, statistics, etc.).
-     */
-    reset: () => boolean;
-    /**
-     * Chooses a worker in the pool.
-     */
-    choose: () => Worker;
-}
-/**
- * Pool events emitter.
- */
-declare class PoolEmitter extends EventEmitter {
-}
-/**
- * Options for a poolifier pool.
- */
-interface PoolOptions<Worker> {
-    /**
-     * A function that will listen for message event on each worker.
-     */
-    messageHandler?: MessageHandler<Worker>;
-    /**
-     * A function that will listen for error event on each worker.
-     */
-    errorHandler?: ErrorHandler<Worker>;
-    /**
-     * A function that will listen for online event on each worker.
-     */
-    onlineHandler?: OnlineHandler<Worker>;
-    /**
-     * A function that will listen for exit event on each worker.
-     */
-    exitHandler?: ExitHandler<Worker>;
-    /**
-     * The worker choice strategy to use in this pool.
-     */
-    workerChoiceStrategy?: WorkerChoiceStrategy;
-    /**
-     * Pool events emission.
-     *
-     * @default true
-     */
-    enableEvents?: boolean;
-}
-/**
- * Contract definition for a poolifier pool.
- *
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- */
-interface IPool<Data = unknown, Response = unknown> {
-    /**
-     * Emitter on which events can be listened to.
-     *
-     * Events that can currently be listened to:
-     *
-     * - `'busy'`
-     */
-    readonly emitter?: PoolEmitter;
-    /**
-     * Performs the task specified in the constructor with the data parameter.
-     *
-     * @param data The input for the specified task. This can only be serializable data.
-     * @returns Promise that will be resolved when the task is successfully completed.
-     */
-    execute: (data: Data) => Promise<Response>;
-    /**
-     * Shutdowns every current worker in this pool.
-     */
-    destroy: () => Promise<void>;
-    /**
-     * Sets the worker choice strategy in this pool.
-     *
-     * @param workerChoiceStrategy The worker choice strategy.
-     */
-    setWorkerChoiceStrategy: (workerChoiceStrategy: WorkerChoiceStrategy) => void;
-}
-/**
- * Internal pool types.
- */
-declare enum PoolType {
-    FIXED = "fixed",
-    DYNAMIC = "dynamic"
-}
-/**
- * Internal tasks usage statistics.
- */
-interface TasksUsage {
-    run: number;
-    running: number;
-    runTime: number;
-    avgRunTime: number;
-}
-/**
- * Internal contract definition for a poolifier pool.
- *
- * @template Worker Type of worker which manages this pool.
- * @template Data Type of data sent to the worker.
- * @template Response Type of response of execution.
- */
-interface IPoolInternal<Worker extends IPoolWorker, Data = unknown, Response = unknown> extends IPool<Data, Response> {
-    /**
-     * List of currently available workers.
-     */
-    readonly workers: Worker[];
-    /**
-     * The workers tasks usage map.
-     *
-     *  `key`: The `Worker`
-     *  `value`: Worker tasks usage statistics.
-     */
-    readonly workersTasksUsage: Map<Worker, TasksUsage>;
-    /**
-     * Pool type.
-     *
-     * If it is `'dynamic'`, it provides the `max` property.
-     */
-    readonly type: PoolType;
-    /**
-     * Whether the pool is busy or not.
-     *
-     * The pool busyness boolean status.
-     */
-    readonly busy: boolean;
-    /**
-     * Number of tasks currently concurrently running.
-     */
-    readonly numberOfRunningTasks: number;
-    /**
-     * Finds a free worker based on the number of tasks the worker has applied.
-     *
-     * If a worker is found with `0` running tasks, it is detected as free and returned.
-     *
-     * If no free worker is found, `false` is returned.
-     *
-     * @returns A free worker if there is one, otherwise `false`.
-     */
-    findFreeWorker: () => Worker | false;
-    /**
-     * Gets worker index.
-     *
-     * @param worker The worker.
-     * @returns The worker index.
-     */
-    getWorkerIndex: (worker: Worker) => number;
-    /**
-     * Gets worker running tasks.
-     *
-     * @param worker The worker.
-     * @returns The number of tasks currently running on the worker.
-     */
-    getWorkerRunningTasks: (worker: Worker) => number | undefined;
-    /**
-     * Gets worker average tasks runtime.
-     *
-     * @param worker The worker.
-     * @returns The average tasks runtime on the worker.
-     */
-    getWorkerAverageTasksRunTime: (worker: Worker) => number | undefined;
-}
-/**
- * Enumeration of kill behaviors.
- */
-declare const KillBehaviors: Readonly<{
-    readonly SOFT: "SOFT";
-    readonly HARD: "HARD";
-}>;
-/**
- * Kill behavior.
- */
-type KillBehavior = keyof typeof KillBehaviors;
-/**
- * Options for workers.
- */
-interface WorkerOptions {
-    /**
-     * Maximum waiting time in milliseconds for tasks.
-     *
-     * After this time, newly created workers will be terminated.
-     * The last active time of your worker unit will be updated when a task is submitted to a worker or when a worker terminate a task.
-     *
-     * - If `killBehavior` is set to `KillBehaviors.HARD` this value represents also the timeout for the tasks that you submit to the pool,
-     *   when this timeout expires your tasks is interrupted and the worker is killed if is not part of the minimum size of the pool.
-     * - If `killBehavior` is set to `KillBehaviors.SOFT` your tasks have no timeout and your workers will not be terminated until your task is completed.
-     *
-     * @default 60000 ms
-     */
-    maxInactiveTime?: number;
-    /**
-     * Whether your worker will perform asynchronous or not.
-     *
-     * @default false
-     */
-    async?: boolean;
-    /**
-     * `killBehavior` dictates if your async unit (worker/process) will be deleted in case that a task is active on it.
-     *
-     * - SOFT: If `currentTime - lastActiveTime` is greater than `maxInactiveTime` but a task is still running, then the worker **won't** be deleted.
-     * - HARD: If `lastActiveTime` is greater than `maxInactiveTime` but a task is still running, then the worker will be deleted.
-     *
-     * This option only apply to the newly created workers.
-     *
-     * @default KillBehaviors.SOFT
-     */
-    killBehavior?: KillBehavior;
-}
-/**
- * Make all properties in T non-readonly.
- */
-type Draft<T> = {
-    -readonly [P in keyof T]?: T[P];
-};
-/**
- * Message object that is passed between worker and main worker.
- */
-interface MessageValue<Data = unknown, MainWorker extends ClusterWorker | MessagePort | unknown = unknown> {
-    /**
-     * Input data that will be passed to the worker.
-     */
-    readonly data?: Data;
-    /**
-     * Id of the message.
-     */
-    readonly id?: number;
-    /**
-     * Kill code.
-     */
-    readonly kill?: KillBehavior | 1;
-    /**
-     * Error.
-     */
-    readonly error?: string;
-    /**
-     * Task runtime.
-     */
-    readonly taskRunTime?: number;
-    /**
-     * Reference to main worker.
-     *
-     * Only for internal use.
-     */
-    readonly parent?: MainWorker;
-}
-/**
- * An object holding the worker that will be used to resolve/rejects the promise later on.
- *
- * @template Worker Type of worker.
- * @template Response Type of response of execution. This can only be serializable data.
- */
-interface PromiseWorkerResponseWrapper<Worker extends IPoolWorker, Response = unknown> {
-    /**
-     * Resolve callback to fulfill the promise.
-     */
-    readonly resolve: (value: Response) => void;
-    /**
-     * Reject callback to reject the promise.
-     */
-    readonly reject: (reason?: string) => void;
-    /**
-     * The worker that has the assigned task.
-     */
-    readonly worker: Worker;
-}
-/**
- * The worker choice strategy context.
- *
- * @template Worker Type of worker.
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- */
-declare class WorkerChoiceStrategyContext<Worker extends IPoolWorker, Data, Response> {
-    private readonly pool;
-    private readonly createDynamicallyWorkerCallback;
-    private workerChoiceStrategy;
-    /**
-     * Worker choice strategy context constructor.
-     *
-     * @param pool The pool instance.
-     * @param createDynamicallyWorkerCallback The worker creation callback for dynamic pool.
-     * @param workerChoiceStrategy The worker choice strategy.
-     */
-    constructor(pool: IPoolInternal<Worker, Data, Response>, createDynamicallyWorkerCallback: () => Worker, workerChoiceStrategy?: WorkerChoiceStrategy);
-    /**
-     * Gets the worker choice strategy instance specific to the pool type.
-     *
-     * @param workerChoiceStrategy The worker choice strategy.
-     * @returns The worker choice strategy instance for the pool type.
-     */
-    private getPoolWorkerChoiceStrategy;
-    /**
-     * Gets the worker choice strategy used in the context.
-     *
-     * @returns The worker choice strategy.
-     */
-    getWorkerChoiceStrategy(): IWorkerChoiceStrategy<Worker>;
-    /**
-     * Sets the worker choice strategy to use in the context.
-     *
-     * @param workerChoiceStrategy The worker choice strategy to set.
-     */
-    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy): void;
-    /**
-     * Chooses a worker with the underlying selection strategy.
-     *
-     * @returns The chosen one.
-     */
-    execute(): Worker;
-}
-/**
- * Base class that implements some shared logic for all poolifier pools.
- *
- * @template Worker Type of worker which manages this pool.
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- */
-declare abstract class AbstractPool<Worker extends IPoolWorker, Data = unknown, Response = unknown> implements IPoolInternal<Worker, Data, Response> {
-    readonly numberOfWorkers: number;
-    readonly filePath: string;
-    readonly opts: PoolOptions<Worker>;
-    /** @inheritDoc */
-    readonly workers: Worker[];
-    /** @inheritDoc */
-    readonly workersTasksUsage: Map<Worker, TasksUsage>;
-    /** @inheritDoc */
-    readonly emitter?: PoolEmitter;
-    /**
-     * The promise map.
-     *
-     * - `key`: This is the message Id of each submitted task.
-     * - `value`: An object that contains the worker, the resolve function and the reject function.
-     *
-     * When we receive a message from the worker we get a map entry and resolve/reject the promise based on the message.
-     */
-    protected promiseMap: Map<number, PromiseWorkerResponseWrapper<Worker, Response>>;
-    /**
-     * Id of the next message.
-     */
-    protected nextMessageId: number;
-    /**
-     * Worker choice strategy instance implementing the worker choice algorithm.
-     *
-     * Default to a strategy implementing a round robin algorithm.
-     */
-    protected workerChoiceStrategyContext: WorkerChoiceStrategyContext<Worker, Data, Response>;
-    /**
-     * Constructs a new poolifier pool.
-     *
-     * @param numberOfWorkers Number of workers that this pool should manage.
-     * @param filePath Path to the worker-file.
-     * @param opts Options for the pool.
-     */
-    constructor(numberOfWorkers: number, filePath: string, opts: PoolOptions<Worker>);
-    private checkFilePath;
-    private checkNumberOfWorkers;
-    private checkPoolOptions;
-    /** @inheritDoc */
-    abstract get type(): PoolType;
-    /** @inheritDoc */
-    get numberOfRunningTasks(): number;
-    /** @inheritDoc */
-    getWorkerIndex(worker: Worker): number;
-    /** @inheritDoc */
-    getWorkerRunningTasks(worker: Worker): number | undefined;
-    /** @inheritDoc */
-    getWorkerAverageTasksRunTime(worker: Worker): number | undefined;
-    /** @inheritDoc */
-    setWorkerChoiceStrategy(workerChoiceStrategy: WorkerChoiceStrategy): void;
-    /** @inheritDoc */
-    abstract get busy(): boolean;
-    protected internalGetBusyStatus(): boolean;
-    /** @inheritDoc */
-    findFreeWorker(): Worker | false;
-    /** @inheritDoc */
-    execute(data: Data): Promise<Response>;
-    /** @inheritDoc */
-    destroy(): Promise<void>;
-    /**
-     * Shutdowns given worker.
-     *
-     * @param worker A worker within `workers`.
-     */
-    protected abstract destroyWorker(worker: Worker): void | Promise<void>;
-    /**
-     * Setup hook that can be overridden by a Poolifier pool implementation
-     * to run code before workers are created in the abstract constructor.
-     */
-    protected setupHook(): void;
-    /**
-     * Should return whether the worker is the main worker or not.
-     */
-    protected abstract isMain(): boolean;
-    /**
-     * Hook executed before the worker task promise resolution.
-     * Can be overridden.
-     *
-     * @param worker The worker.
-     */
-    protected beforePromiseWorkerResponseHook(worker: Worker): void;
-    /**
-     * Hook executed after the worker task promise resolution.
-     * Can be overridden.
-     *
-     * @param message The received message.
-     * @param promise The Promise response.
-     */
-    protected afterPromiseWorkerResponseHook(message: MessageValue<Response>, promise: PromiseWorkerResponseWrapper<Worker, Response>): void;
-    /**
-     * Removes the given worker from the pool.
-     *
-     * @param worker The worker that will be removed.
-     */
-    protected removeWorker(worker: Worker): void;
-    /**
-     * Chooses a worker for the next task.
-     *
-     * The default implementation uses a round robin algorithm to distribute the load.
-     *
-     * @returns Worker.
-     */
-    protected chooseWorker(): Worker;
-    /**
-     * Sends a message to the given worker.
-     *
-     * @param worker The worker which should receive the message.
-     * @param message The message.
-     */
-    protected abstract sendToWorker(worker: Worker, message: MessageValue<Data>): void;
-    /**
-     * Registers a listener callback on a given worker.
-     *
-     * @param worker The worker which should register a listener.
-     * @param listener The message listener callback.
-     */
-    protected abstract registerWorkerMessageListener<Message extends Data | Response>(worker: Worker, listener: (message: MessageValue<Message>) => void): void;
-    /**
-     * Returns a newly created worker.
-     */
-    protected abstract createWorker(): Worker;
-    /**
-     * Function that can be hooked up when a worker has been newly created and moved to the workers registry.
-     *
-     * Can be used to update the `maxListeners` or binding the `main-worker`<->`worker` connection if not bind by default.
-     *
-     * @param worker The newly created worker.
-     */
-    protected abstract afterWorkerSetup(worker: Worker): void;
-    /**
-     * Creates a new worker for this pool and sets it up completely.
-     *
-     * @returns New, completely set up worker.
-     */
-    protected createAndSetupWorker(): Worker;
-    /**
-     * This function is the listener registered for each worker.
-     *
-     * @returns The listener function to execute when a message is received from a worker.
-     */
-    protected workerListener(): (message: MessageValue<Response>) => void;
-    private internalExecute;
-    private checkAndEmitBusy;
-    /**
-     * Increases the number of tasks that the given worker has applied.
-     *
-     * @param worker Worker which running tasks is increased.
-     */
-    private increaseWorkerRunningTasks;
-    /**
-     * Decreases the number of tasks that the given worker has applied.
-     *
-     * @param worker Worker which running tasks is decreased.
-     */
-    private decreaseWorkerRunningTasks;
-    /**
-     * Steps the number of tasks that the given worker has applied.
-     *
-     * @param worker Worker which running tasks are stepped.
-     * @param step Number of running tasks step.
-     */
-    private stepWorkerRunningTasks;
-    /**
-     * Steps the number of tasks that the given worker has run.
-     *
-     * @param worker Worker which has run tasks.
-     * @param step Number of run tasks step.
-     */
-    private stepWorkerRunTasks;
-    /**
-     * Updates tasks runtime for the given worker.
-     *
-     * @param worker Worker which run the task.
-     * @param taskRunTime Worker task runtime.
-     */
-    private updateWorkerTasksRunTime;
-    /**
-     * Checks if the given worker is registered in the workers tasks usage map.
-     *
-     * @param worker Worker to check.
-     * @returns `true` if the worker is registered in the workers tasks usage map. `false` otherwise.
-     */
-    private checkWorkerTasksUsage;
-    /**
-     * Initializes tasks usage statistics.
-     *
-     * @param worker The worker.
-     */
-    private initWorkerTasksUsage;
-    /**
-     * Removes worker tasks usage statistics.
-     *
-     * @param worker The worker.
-     */
-    private removeWorkerTasksUsage;
-    /**
-     * Resets worker tasks usage statistics.
-     *
-     * @param worker The worker.
-     */
-    private resetWorkerTasksUsage;
-}
-/**
- * Options for a poolifier cluster pool.
- */
-interface ClusterPoolOptions extends PoolOptions<Worker> {
-    /**
-     * Key/value pairs to add to worker process environment.
-     *
-     * @see https://nodejs.org/api/cluster.html#cluster_cluster_fork_env
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    env?: any;
-    /**
-     * Cluster settings.
-     *
-     * @see https://nodejs.org/api/cluster.html#cluster_cluster_settings
-     */
-    settings?: ClusterSettings;
-}
-/**
- * A cluster pool with a fixed number of workers.
- *
- * It is possible to perform tasks in sync or asynchronous mode as you prefer.
- *
- * This pool selects the workers in a round robin fashion.
- *
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- * @author [Christopher Quadflieg](https://github.com/Shinigami92)
- * @since 2.0.0
- */
-declare class FixedClusterPool<Data = unknown, Response = unknown> extends AbstractPool<Worker, Data, Response> {
-    readonly opts: ClusterPoolOptions;
-    /**
-     * Constructs a new poolifier fixed cluster pool.
-     *
-     * @param numberOfWorkers Number of workers for this pool.
-     * @param filePath Path to an implementation of a `ClusterWorker` file, which can be relative or absolute.
-     * @param opts Options for this fixed cluster pool.
-     */
-    constructor(numberOfWorkers: number, filePath: string, opts?: ClusterPoolOptions);
-    /** @inheritDoc */
-    protected setupHook(): void;
-    /** @inheritDoc */
-    protected isMain(): boolean;
-    /** @inheritDoc */
-    destroyWorker(worker: Worker): void;
-    /** @inheritDoc */
-    protected sendToWorker(worker: Worker, message: MessageValue<Data>): void;
-    /** @inheritDoc */
-    registerWorkerMessageListener<Message extends Data | Response>(worker: Worker, listener: (message: MessageValue<Message>) => void): void;
-    /** @inheritDoc */
-    protected createWorker(): Worker;
-    /** @inheritDoc */
-    protected afterWorkerSetup(worker: Worker): void;
-    /** @inheritDoc */
-    get type(): PoolType;
-    /** @inheritDoc */
-    get busy(): boolean;
-}
-/**
- * A cluster pool with a dynamic number of workers, but a guaranteed minimum number of workers.
- *
- * This cluster pool creates new workers when the others are busy, up to the maximum number of workers.
- * When the maximum number of workers is reached, an event is emitted. If you want to listen to this event, use the pool's `emitter`.
- *
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- * @author [Christopher Quadflieg](https://github.com/Shinigami92)
- * @since 2.0.0
- */
-declare class DynamicClusterPool<Data = unknown, Response = unknown> extends FixedClusterPool<Data, Response> {
-    protected readonly max: number;
-    /**
-     * Constructs a new poolifier dynamic cluster pool.
-     *
-     * @param min Minimum number of workers which are always active.
-     * @param max Maximum number of workers that can be created by this pool.
-     * @param filePath Path to an implementation of a `ClusterWorker` file, which can be relative or absolute.
-     * @param opts Options for this dynamic cluster pool.
-     */
-    constructor(min: number, max: number, filePath: string, opts?: ClusterPoolOptions);
-    /** @inheritDoc */
-    get type(): PoolType;
-    /** @inheritDoc */
-    get busy(): boolean;
-}
-/**
- * A thread worker with message channels for communication between main thread and thread worker.
- */
-type ThreadWorkerWithMessageChannel = Worker$0 & Draft<MessageChannel>;
-/**
- * A thread pool with a fixed number of threads.
- *
- * It is possible to perform tasks in sync or asynchronous mode as you prefer.
- *
- * This pool selects the threads in a round robin fashion.
- *
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- * @author [Alessandro Pio Ardizio](https://github.com/pioardi)
- * @since 0.0.1
- */
-declare class FixedThreadPool<Data = unknown, Response = unknown> extends AbstractPool<ThreadWorkerWithMessageChannel, Data, Response> {
-    /**
-     * Constructs a new poolifier fixed thread pool.
-     *
-     * @param numberOfThreads Number of threads for this pool.
-     * @param filePath Path to an implementation of a `ThreadWorker` file, which can be relative or absolute.
-     * @param opts Options for this fixed thread pool.
-     */
-    constructor(numberOfThreads: number, filePath: string, opts?: PoolOptions<ThreadWorkerWithMessageChannel>);
-    /** @inheritDoc */
-    protected isMain(): boolean;
-    /** @inheritDoc */
-    destroyWorker(worker: ThreadWorkerWithMessageChannel): Promise<void>;
-    /** @inheritDoc */
-    protected sendToWorker(worker: ThreadWorkerWithMessageChannel, message: MessageValue<Data>): void;
-    /** @inheritDoc */
-    registerWorkerMessageListener<Message extends Data | Response>(messageChannel: ThreadWorkerWithMessageChannel, listener: (message: MessageValue<Message>) => void): void;
-    /** @inheritDoc */
-    protected createWorker(): ThreadWorkerWithMessageChannel;
-    /** @inheritDoc */
-    protected afterWorkerSetup(worker: ThreadWorkerWithMessageChannel): void;
-    /** @inheritDoc */
-    get type(): PoolType;
-    /** @inheritDoc */
-    get busy(): boolean;
-}
-/**
- * A thread pool with a dynamic number of threads, but a guaranteed minimum number of threads.
- *
- * This thread pool creates new threads when the others are busy, up to the maximum number of threads.
- * When the maximum number of threads is reached, an event is emitted. If you want to listen to this event, use the pool's `emitter`.
- *
- * @template Data Type of data sent to the worker. This can only be serializable data.
- * @template Response Type of response of execution. This can only be serializable data.
- * @author [Alessandro Pio Ardizio](https://github.com/pioardi)
- * @since 0.0.1
- */
-declare class DynamicThreadPool<Data = unknown, Response = unknown> extends FixedThreadPool<Data, Response> {
-    protected readonly max: number;
-    /**
-     * Constructs a new poolifier dynamic thread pool.
-     *
-     * @param min Minimum number of threads which are always active.
-     * @param max Maximum number of threads that can be created by this pool.
-     * @param filePath Path to an implementation of a `ThreadWorker` file, which can be relative or absolute.
-     * @param opts Options for this dynamic thread pool.
-     */
-    constructor(min: number, max: number, filePath: string, opts?: PoolOptions<ThreadWorkerWithMessageChannel>);
-    /** @inheritDoc */
-    get type(): PoolType;
-    /** @inheritDoc */
-    get busy(): boolean;
-}
-/**
- * Base class that implements some shared logic for all poolifier workers.
- *
- * @template MainWorker Type of main worker.
- * @template Data Type of data this worker receives from pool's execution. This can only be serializable data.
- * @template Response Type of response the worker sends back to the main worker. This can only be serializable data.
- */
-declare abstract class AbstractWorker<MainWorker extends Worker | MessagePort, Data = unknown, Response = unknown> extends AsyncResource {
-    protected mainWorker: MainWorker | undefined | null;
-    /**
-     * Timestamp of the last task processed by this worker.
-     */
-    protected lastTaskTimestamp: number;
-    /**
-     * Handler Id of the `aliveInterval` worker alive check.
-     */
-    protected readonly aliveInterval?: NodeJS.Timeout;
-    /**
-     * Options for the worker.
-     */
-    readonly opts: WorkerOptions;
-    /**
-     * Constructs a new poolifier worker.
-     *
-     * @param type The type of async event.
-     * @param isMain Whether this is the main worker or not.
-     * @param fn Function processed by the worker when the pool's `execution` function is invoked.
-     * @param mainWorker Reference to main worker.
-     * @param opts Options for the worker.
-     */
-    constructor(type: string, isMain: boolean, fn: (data: Data) => Response, mainWorker: MainWorker | undefined | null, opts?: WorkerOptions);
-    protected messageListener(value: MessageValue<Data, MainWorker>, fn: (data: Data) => Response): void;
-    private checkWorkerOptions;
-    /**
-     * Checks if the `fn` parameter is passed to the constructor.
-     *
-     * @param fn The function that should be defined.
-     */
-    private checkFunctionInput;
-    /**
-     * Returns the main worker.
-     *
-     * @returns Reference to the main worker.
-     */
-    protected getMainWorker(): MainWorker;
-    /**
-     * Sends a message to the main worker.
-     *
-     * @param message The response message.
-     */
-    protected abstract sendToMainWorker(message: MessageValue<Response>): void;
-    /**
-     * Checks if the worker should be terminated, because its living too long.
-     */
-    protected checkAlive(): void;
-    /**
-     * Handles an error and convert it to a string so it can be sent back to the main worker.
-     *
-     * @param e The error raised by the worker.
-     * @returns Message of the error.
-     */
-    protected handleError(e: Error | string): string;
-    /**
-     * Runs the given function synchronously.
-     *
-     * @param fn Function that will be executed.
-     * @param value Input data for the given function.
-     */
-    protected run(fn: (data?: Data) => Response, value: MessageValue<Data>): void;
-    /**
-     * Runs the given function asynchronously.
-     *
-     * @param fn Function that will be executed.
-     * @param value Input data for the given function.
-     */
-    protected runAsync(fn: (data?: Data) => Promise<Response>, value: MessageValue<Data>): void;
-}
-/**
- * A cluster worker used by a poolifier `ClusterPool`.
- *
- * When this worker is inactive for more than the given `maxInactiveTime`,
- * it will send a termination request to its main worker.
- *
- * If you use a `DynamicClusterPool` the extra workers that were created will be terminated,
- * but the minimum number of workers will be guaranteed.
- *
- * @template Data Type of data this worker receives from pool's execution. This can only be serializable data.
- * @template Response Type of response the worker sends back to the main worker. This can only be serializable data.
- * @author [Christopher Quadflieg](https://github.com/Shinigami92)
- * @since 2.0.0
- */
-declare class ClusterWorker$0<Data = unknown, Response = unknown> extends AbstractWorker<Worker, Data, Response> {
-    /**
-     * Constructs a new poolifier cluster worker.
-     *
-     * @param fn Function processed by the worker when the pool's `execution` function is invoked.
-     * @param opts Options for the worker.
-     */
-    constructor(fn: (data: Data) => Response, opts?: WorkerOptions);
-    /** @inheritDoc */
-    protected sendToMainWorker(message: MessageValue<Response>): void;
-    /** @inheritDoc */
-    protected handleError(e: Error | string): string;
-}
-/**
- * A thread worker used by a poolifier `ThreadPool`.
- *
- * When this worker is inactive for more than the given `maxInactiveTime`,
- * it will send a termination request to its main thread.
- *
- * If you use a `DynamicThreadPool` the extra workers that were created will be terminated,
- * but the minimum number of workers will be guaranteed.
- *
- * @template Data Type of data this worker receives from pool's execution. This can only be serializable data.
- * @template Response Type of response the worker sends back to the main thread. This can only be serializable data.
- * @author [Alessandro Pio Ardizio](https://github.com/pioardi)
- * @since 0.0.1
- */
-declare class ThreadWorker<Data = unknown, Response = unknown> extends AbstractWorker<MessagePort, Data, Response> {
-    /**
-     * Constructs a new poolifier thread worker.
-     *
-     * @param fn Function processed by the worker when the pool's `execution` function is invoked.
-     * @param opts Options for the worker.
-     */
-    constructor(fn: (data: Data) => Response, opts?: WorkerOptions);
-    /** @inheritDoc */
-    protected sendToMainWorker(message: MessageValue<Response>): void;
-}
-export { DynamicClusterPool, FixedClusterPool, WorkerChoiceStrategies, DynamicThreadPool, FixedThreadPool, ClusterWorker$0 as ClusterWorker, ThreadWorker, KillBehaviors };
-export type { ClusterPoolOptions, IPool, PoolEmitter, PoolOptions, ErrorHandler, ExitHandler, MessageHandler, OnlineHandler, WorkerChoiceStrategy, ThreadWorkerWithMessageChannel, KillBehavior, WorkerOptions };
+export { DynamicClusterPool } from './pools/cluster/dynamic';
+export { FixedClusterPool } from './pools/cluster/fixed';
+export type { ClusterPoolOptions } from './pools/cluster/fixed';
+export type { IPool, PoolEmitter, PoolOptions } from './pools/pool';
+export type { ErrorHandler, ExitHandler, MessageHandler, OnlineHandler } from './pools/pool-worker';
+export { WorkerChoiceStrategies } from './pools/selection-strategies/selection-strategies-types';
+export type { WorkerChoiceStrategy } from './pools/selection-strategies/selection-strategies-types';
+export { DynamicThreadPool } from './pools/thread/dynamic';
+export { FixedThreadPool } from './pools/thread/fixed';
+export type { ThreadWorkerWithMessageChannel } from './pools/thread/fixed';
+export { ClusterWorker } from './worker/cluster-worker';
+export { ThreadWorker } from './worker/thread-worker';
+export { KillBehaviors } from './worker/worker-options';
+export type { KillBehavior, WorkerOptions } from './worker/worker-options';