import type { Counter, Distribution, Metrics } from "crow-metrics";
import { PersistentQueue, QueuedJob, QueuedQueryJob } from "./persistent_queue";
import { PromiseCallbacks } from "./promises";
import { Timer } from "./timer";
export declare function delay(msec: number): Promise<void>;
export interface WorkerPoolOptions<J> {
    workerConfig: Object;
    localHandler?: (job: J) => J | null;
    logger?: (text: string) => void;
    errorLogger?: (error: Error | undefined, text: string) => void;
    traceLogger?: (text: string) => void;
    notifyError?: (error: WorkerPoolError) => void;
    metrics?: Metrics;
    describeJob: (job: J) => string;
    pingFrequency: number;
    pingTimeout: number;
    replyTimeout: number;
    workerDeathThreshold: number;
    workerDeathDuration: number;
}
export declare const DEFAULT_WORKER_POOL_OPTIONS: WorkerPoolOptions<any>;
export declare enum WorkerPoolError {
    WORKER_DIED = 1,// we'll restart it
    WORKER_TIMED_OUT = 2,// we'll restart it
    WORKER_POOL_DIED = 3
}
export declare const WORKER_POOL_ERROR_DESCRIPTIONS: Map<WorkerPoolError, string>;
export declare class WorkerStatus<P> {
    id: number;
    status: P | string;
    constructor(id: number, status: P | string);
}
export interface Ready {
    type: "ready";
}
export interface PostJob<J> {
    type: "post";
    job?: J;
    jobs?: J[];
}
export interface TimerJob<J> {
    type: "timer";
    timeout: number;
    job: J;
}
export interface ExpiresJob<J> {
    type: "expires";
    expires: number;
    job: J;
}
export interface JobDone<J> {
    type: "done";
    success: boolean;
    pong?: boolean;
    errorMessage?: string;
    reply?: J;
}
export interface Reply<J> {
    type: "reply";
    returnAddress: string;
    reply: J;
}
export interface Status<P> {
    type: "status";
    time: number;
    errorMessage?: string;
    reply?: P;
}
export type WorkerMessage<J, P> = Ready | PostJob<J> | JobDone<J> | Reply<J> | TimerJob<J> | ExpiresJob<J> | Status<P>;
export declare class WorkerPool<J, P> {
    queue: PersistentQueue<J>;
    timer: Timer<J>;
    options: WorkerPoolOptions<J>;
    private workerCodePath;
    private workers;
    private idleWorkers;
    protected stopping: boolean;
    private nextId;
    protected replies: Map<string, PromiseCallbacks<J>>;
    jobCounter?: Counter;
    jobTiming?: Distribution;
    pingDistribution?: Distribution;
    deadCounter?: Counter;
    private pingsWaiting;
    private pingTimer;
    private pingTimeoutTimer;
    private workerDeathCount;
    private workerDeathSince;
    private monitorTime;
    private monitorResults;
    constructor(queue: PersistentQueue<J>, timer: Timer<J>, options?: Partial<WorkerPoolOptions<J>>);
    launch(workerCodePath: string, count: number): void;
    ready(count: number): Promise<void>;
    idle(): Promise<void>;
    stop(): Promise<void>;
    stopped(): boolean;
    add(job: J): QueuedJob<J>;
    addQuery(job: J): QueuedQueryJob<J>;
    monitor(frequency: number, timeout: number): AsyncIterable<WorkerStatus<P>[]>;
    private launchWorker;
    private dropWorker;
    private workerFinished;
    workerReply(returnAddress: string, reply: J): void;
    private gotPong;
    private startNextJob;
    private ping;
    checkAbandonedPromises(): void;
    private logPingResults;
    private log;
    private logError;
    private logTrace;
}
export declare class FakeWorkerPool<J, P> extends WorkerPool<J, P> {
    queue: PersistentQueue<J>;
    timer: Timer<J>;
    processJob: (job: J, returnAddress?: string) => Promise<J | undefined>;
    currentJob: Promise<void>;
    _idle: boolean;
    constructor(queue: PersistentQueue<J>, timer: Timer<J>, options: Partial<WorkerPoolOptions<J>> | undefined, processJob: (job: J, returnAddress?: string) => Promise<J | undefined>);
    launch(_workerCodePath: string, _count: number): void;
    ready(count: number): Promise<void>;
    idle(): Promise<void>;
    stop(): Promise<void>;
}