import { ProcessType } from '../../types';
import { Observable } from 'rxjs';
export { ProcessType };
export declare type IpcHandlerRef = {
    type: IpcMessage['type'];
    clients: IpcIdentifier[];
};
export declare type IpcHandlerRefs = {
    [key: string]: IpcHandlerRef;
};
export declare type IpcGlobalMainRefs = {
    _ipcRefs: {
        client?: IpcClient;
        handlers: IpcHandlerRefs;
    };
};
export declare type IpcMessageType = string;
export declare type IpcPayload = object;
export declare type IpcMessage = {
    type: string;
    payload: {
        [key: string]: any;
    };
};
export declare type IpcIdentifier = {
    id: number;
    process: ProcessType;
};
export declare type IpcEvent<M extends IpcMessage = any> = {
    eid: string;
    type: M['type'];
    payload: M['payload'];
    sender: IpcIdentifier;
    targets: number[];
};
export declare type IpcEventObservable<M extends IpcMessage> = Observable<IpcEvent<M>>;
export declare type IpcFilter<M extends IpcMessage> = (e: IpcEvent<M>, index: number) => boolean;
export declare type IpcClient<M extends IpcMessage = any> = {
    readonly MAIN: number;
    readonly process: ProcessType;
    readonly events$: IpcEventObservable<M>;
    readonly id: number;
    dispose: () => void;
    filter: <T extends M>(criteria: IpcFilter<T> | T['type']) => IpcEventObservable<T>;
    on: <T extends M>(type: T['type']) => IpcEventObservable<T>;
    send: <T extends M, D = any>(type: T['type'], payload: T['payload'], options?: IpcClientSendOptions) => IpcSend<T, D>;
    handle: <T extends M>(type: T['type'], handler: IpcEventHandler<T>) => IpcClient<M>;
};
export declare type IpcClientSendOptions = {
    target?: number | number[];
    timeout?: number;
};
export declare type IpcSend<M extends IpcMessage, D = any> = {
    eid: string;
    type: M['type'];
    results$: Observable<ISendResponse<M, D>>;
    timeout$: Observable<{}>;
    cancel$: Observable<{}>;
    results: Array<{
        sender: IpcIdentifier;
        data?: D;
    }>;
    cancel: () => IpcSend<M, D>;
    isCancelled: boolean;
};
export declare type ISendResponse<M extends IpcMessage, D = any> = {
    elapsed: number;
    data: D;
    type: M['type'];
    sender: IpcIdentifier;
};
export declare type IpcEventHandlerArgs<M extends IpcMessage> = IpcEvent<M> & {};
export declare type IpcEventHandler<M extends IpcMessage = any> = (e: IpcEventHandlerArgs<M>) => Promise<any>;
export declare type IpcHandlerResponseEvent = {
    type: './SYS/IPC/handler/response';
    payload: {
        eid: string;
        data?: any;
    };
};
export declare type IpcRegisterHandlerEvent = {
    type: './SYS/IPC/register-handler';
    payload: {
        type: IpcMessage['type'];
        stage: 'CREATE' | 'DISPOSE';
    };
};