import { EventEmitter } from '@omnitron-dev/eventemitter';
import { Worker } from 'worker_threads';
import { ChildProcess } from 'node:child_process';
import type { ILogger } from '@omnitron-dev/titan/module/logger';
import type { IProcessSpawner, ISpawnOptions, IWorkerHandle, IWorkerExitInfo, IProcessManagerConfig } from './types.js';
import { ProcessStatus } from './types.js';
import { NetronClient } from './netron-client.js';
interface ITransportConfig {
    type: 'tcp' | 'unix' | 'ws';
    host?: string;
    port?: number;
    path?: string;
    url?: string;
}
export declare class WorkerHandle extends EventEmitter implements IWorkerHandle {
    readonly id: string;
    readonly transportUrl: string;
    readonly serviceName: string;
    readonly serviceVersion: string;
    private readonly logger;
    private readonly isWorkerThread;
    readonly proxy?: any | undefined;
    readonly transportConfig?: ITransportConfig | undefined;
    private _status;
    private messageHandlers;
    private logHandlers;
    private exitEmitted;
    readonly worker: Worker | ChildProcess;
    readonly netronClient: NetronClient | null;
    constructor(id: string, worker: Worker | ChildProcess, netronClient: NetronClient | null, transportUrl: string, serviceName: string, serviceVersion: string, logger: ILogger, isWorkerThread: boolean, proxy?: any | undefined, initialStatus?: ProcessStatus, transportConfig?: ITransportConfig | undefined);
    private emitExit;
    get status(): ProcessStatus;
    get pid(): number | undefined;
    onExit(handler: (info: IWorkerExitInfo) => void): () => void;
    terminate(opts?: {
        shutdownTimeout?: number;
    }): Promise<void>;
    private terminateChildProcess;
    isAlive(): boolean;
    send(message: any): Promise<void>;
    onMessage(handler: (data: any) => void): void;
    onLog(handler: (line: string, stream: 'stdout' | 'stderr') => void): void;
    emitLog(line: string, stream: 'stdout' | 'stderr'): void;
    private setupMessageHandlers;
    private setupLogCapture;
    private setupDefaultLogForwarding;
}
export declare class ProcessSpawner implements IProcessSpawner {
    private readonly logger;
    private readonly config;
    private readonly workerRuntimePath;
    private readonly forkWorkerPath;
    private readonly tempDir;
    constructor(logger: ILogger, config?: IProcessManagerConfig);
    spawn<T>(processPathOrClass: string | (new (...args: any[]) => T), options?: ISpawnOptions): Promise<IWorkerHandle>;
    cleanup(): Promise<void>;
    private setupTransport;
    private createLegacyModule;
    private spawnWorkerThread;
    private makeSerializable;
    private spawnChildProcess;
    private waitForReady;
}
export declare class ProcessSpawnerFactory {
    static create(logger: ILogger, config?: IProcessManagerConfig): IProcessSpawner;
    static setMockSpawner(MockSpawnerClass: any): void;
    static createAsync(logger: ILogger, config?: IProcessManagerConfig): Promise<IProcessSpawner>;
}
export {};
//# sourceMappingURL=process-spawner.d.ts.map