import type { ILogger } from '@omnitron-dev/titan/module/logger';
import type { IProcessPoolOptions, IPoolMetrics, IProcessManager } from './types.js';
export declare class PoolBackpressureError extends Error {
    readonly retryAfterMs: number;
    constructor(queueSize: number, retryAfterMs?: number);
}
export declare class ProcessPool<T> {
    private readonly manager;
    private readonly processPathOrClass;
    private readonly logger;
    private workers;
    private queue;
    private isInitialized;
    private isShuttingDown;
    private isDraining;
    private currentRoundRobinIndex;
    private requestIdCounter;
    private workerIndexCounter;
    private totalRequests;
    private totalErrors;
    private totalResponseTime;
    private successfulRequests;
    private autoScaleTimer?;
    private lastScaleCheck;
    private scaleHistory;
    private healthCheckTimer?;
    private recycleTimer?;
    private heartbeatTimer?;
    private memoryMonitorTimer?;
    private unhealthyWorkers;
    private readonly healthFailures;
    private readonly memoryLimitBytes;
    private readonly memoryWarningThreshold;
    private readonly queueBatchSize;
    private queueProcessingScheduled;
    private circuitBreaker;
    private emitter;
    private poolOptions;
    private healthyWorkersCache;
    private healthyWorkersCacheValid;
    constructor(manager: IProcessManager, processPathOrClass: string | (new (...args: any[]) => T), options: IProcessPoolOptions, logger: ILogger);
    private parseMemoryLimit;
    private get processName();
    private normalizeOptions;
    initialize(): Promise<void>;
    get size(): number;
    get active(): number;
    get pending(): number;
    getWorkerIds(): string[];
    getWorkerHandle(workerId: string): {
        send: (message: unknown) => Promise<void>;
    } | null;
    get metrics(): IPoolMetrics;
    get circuitBreakerState(): {
        state: 'closed' | 'open' | 'half-open';
        failures: number;
        lastFailTime: number;
        isEnabled: boolean;
    };
    scale(newSize: number): Promise<void>;
    drain(): Promise<void>;
    destroy(): Promise<void>;
    execute(method: string, ...args: any[]): Promise<any>;
    private getPoolSize;
    private spawnWorker;
    private shutdownWorker;
    private invalidateHealthyWorkersCache;
    private getHealthyWorkers;
    private selectWorker;
    private selectRoundRobin;
    private selectLeastLoaded;
    private selectRandom;
    private selectWeighted;
    private selectAdaptive;
    private computeWorkerScore;
    private selectConsistentHash;
    private selectByLatency;
    private selectLeastConnections;
    private selectWeightedRoundRobin;
    private selectPowerOfTwoChoices;
    private computeP2CScore;
    private executeOnWorker;
    private queueRequest;
    private processQueue;
    private processQueueBatch;
    private selectBestFromTwo;
    private emitHealthDecision;
    private healthCheckRunning;
    private setupHealthMonitoring;
    private autoScaleRunning;
    private setupAutoScaling;
    private recyclingRunning;
    private setupRecycling;
    private memoryMonitorRunning;
    private setupMemoryMonitoring;
    private heartbeatRunning;
    private setupHeartbeatMonitoring;
    private sendHeartbeat;
    private replaceWorker;
    private warmupPool;
    private scaleUp;
    private scaleDown;
    private waitForActiveRequests;
    private calculateThroughput;
    private calculateSaturation;
    private handleCircuitBreakerFailure;
    private circuitBreakerHalfOpenTimer?;
    private openCircuitBreaker;
    private closeCircuitBreaker;
    private shouldTryHalfOpen;
    private emit;
    on(event: string, listener: (...args: any[]) => void): void;
    off(event: string, listener: (...args: any[]) => void): void;
}
//# sourceMappingURL=process-pool.d.ts.map