/**
 * Abstract class for process discovery and communication
 */
export declare type IPCRequestHandler<T = any> = (data: any) => Promise<T>;
export declare type ProcessListener<T> = (data: T) => void;
export interface IProcessRequest {
    requestId: string;
    method: string;
    data: any;
}
export interface IProcessResponse {
    error?: any;
    data?: any;
}
export interface IProcessState {
    [key: string]: any;
}
export interface IPCParams<T extends IProcessState> {
    timeout?: number;
    state?: T;
    processId: string;
    instanceName?: string;
    healthCheckInterval?: number;
}
export interface IProcessInstance<T extends IProcessState> {
    ttl: number;
    state: T;
}
export interface IProcessInfo<T extends IProcessState> {
    id: string;
    state: T;
}
export declare abstract class IPCManager<S extends IProcessState = any> {
    processId: string;
    timeout: number;
    healthCheckInterval: number;
    requestHandlers: {
        [method: string]: IPCRequestHandler;
    };
    state: S;
    instances: Map<string, IProcessInstance<S>>;
    private healthCheckTimeout?;
    private instanceName;
    constructor(params: IPCParams<S>);
    init(): void;
    startHealthCheck(): void;
    terminate(): void;
    stopHealthCheck(): void;
    publishState(): void;
    private addInstance;
    private updateInstanceState;
    private deleteInstance;
    requestProcess<L, R>(id: string | number, method: string, data: L): Promise<R>;
    onRequest(method: string, handler: IPCRequestHandler): void;
    pids(): string[];
    abstract subscribe<T>(channel: string, listener: ProcessListener<T>): void;
    abstract unsubscribe(channel: string): void;
    abstract publish<T>(channel: string, data: T): void;
    abstract close(): void;
}