import { EvalOptions, MessageTypes, SerializableInput, Serializable, PackageType } from '../types';
import { ClusterClient } from '../core/clusterClient';
import { Cluster } from '../core/cluster';
/** Eval message type. */
export type EvalMessage<P extends object = object> = {
    options?: EvalOptions<P>;
    script: string;
};
/** Respawn message type. */
export type RespawnMessage = {
    clusterDelay?: number;
    respawnDelay?: number;
    timeout?: number;
    except?: number[];
};
/** Respawn some message type. */
export type RespawnSomeMessage = {
    clusterIds: number[];
    clusterDelay?: number;
    respawnDelay?: number;
    timeout?: number;
};
/** Result of an eval message. */
export type EvalResultMessage = unknown;
/** The type of the message. */
export type DataType = 'normal' | 'eval' | 'respawnAll' | 'evalResult' | 'readyOrSpawn' | 'heartbeat' | 'error' | 'reply' | 'respawnSome';
/** The type of the message. */
export type DataTypes<A = object, P extends object = object> = {
    normal: A extends never ? Serializable : A;
    reply: DataTypes<A, P>['normal'];
    eval: EvalMessage<P>;
    readyOrSpawn: {
        packageType?: PackageType | null;
    } | undefined;
    heartbeat: undefined;
    respawnAll: RespawnMessage;
    respawnSome: RespawnSomeMessage;
    evalResult: EvalResultMessage;
    error: {
        message: string;
        script: string;
        stack?: string;
        name: string;
    };
};
/** Base message for IPC communication. */
export type BaseMessage<D extends DataType, A = Serializable, P extends object = object> = {
    _type: MessageTypes;
    _nonce: string;
    data: DataTypes<A, P>[D];
};
/** Serializable input. */
export type BaseMessageInput<D extends DataType, A extends Serializable = Serializable> = Omit<BaseMessage<D, A>, '_nonce'>;
/** Message that is sent on IPC. */
export declare class ProcessMessage<D extends DataType = 'normal', A extends Serializable = Serializable, P extends object = object> {
    /** Instance of the cluster client or cluster. */
    private _instance;
    /** The nonce of the message. */
    private _nonce;
    /** The data of the message. */
    data: DataTypes<A, object>[D];
    /** Creates an instance of ProcessMessage. */
    constructor(instance: ClusterClient | Cluster, data: BaseMessage<D, A, P>);
    /** Replies to the message. */
    reply<T extends Serializable>(message: SerializableInput<T>): Promise<void>;
}