/// <reference types="node" />
/// <reference types="node" />
import { EventEmitter } from 'events';
import createDebug from 'debug';
export { withTransfer } from './Transferable';
import { WorkerOptions } from 'worker_threads';
import { ThreadId } from './types/general';
import { WorkerThread } from './WorkerThread';
export declare const threadId: any;
export declare let debug: createDebug.Debugger;
export interface ThreadRequest {
    resolve(thread: WorkerThread): void;
    reject(error: Error): void;
}
export declare type ThreadPoolOptions = {
    size?: number;
    typecheck?: boolean;
    workerOptions?: WorkerOptions;
    startupTimeout?: number;
    maxQueueSize?: number;
    autoRefill?: boolean;
};
export interface BaseWorker {
    pool: PoolInterface;
}
export interface PoolInterface extends EventEmitter {
    terminate(): void;
    refill(): void;
    drain(shouldTerminate?: boolean): Promise<void>;
    size: number;
    isTerminated: boolean;
    threads: ReadonlyMap<ThreadId, WorkerThread>;
}
declare type FilterType<Base, Condition> = Pick<Base, {
    [Key in keyof Base]: Base[Key] extends Condition ? Key : never;
}[keyof Base]>;
declare type TypeWithMethods = Record<string | number | symbol, (...a: any) => any | Promise<any>>;
export declare type AsyncMethod = (...param: any) => Promise<any>;
declare type WrapReturnType<Base extends TypeWithMethods> = {
    [Key in keyof Base]: Base[Key] extends AsyncMethod ? Base[Key] : (...a: Parameters<Base[Key]>) => Promise<ReturnType<Base[Key]>>;
};
declare type FilterAndWrap<Base> = WrapReturnType<FilterType<Required<Base>, Function>>;
export declare type WrapWorkerType<Base> = FilterAndWrap<Base> & BaseWorker & {
    all: FilterAndWrap<Base>;
};
export declare function createThreadPool<T>(workerPath: string, { size, workerOptions, startupTimeout, typecheck, maxQueueSize, autoRefill }?: ThreadPoolOptions): Promise<BaseWorker & {
    all: WrapReturnType<FilterType<Required<T>, Function>>;
} & WrapReturnType<FilterType<Required<T>, Function>>>;