import { SocketType, InputSocket, OutputSocket, SocketOwner, Socket, SocketTemplateGenerator } from './socket';
import { PacketSymbol, Packet } from './packet';
import { Signal, SignalReceiver, SignalHandler, SignalReceiverCastResult } from './signal';
import { EventEmitter } from 'eventemitter3';
import { ErrorInfo, ErrorCode, ErrorCodeSpace, ErrorInfoSpace } from './error';
import { SocketDescriptor } from './socket-descriptor';
export declare enum ProcessorEvent {
    ANY_SOCKET_CREATED = "processor:socket-created",
    INPUT_SOCKET_CREATED = "processor:input-socket-created",
    OUTPUT_SOCKET_CREATED = "processor:output-socket-created",
    OUTPUT_SOCKET_SHADOW = "processor:output-socket-shadow",
    SYMBOLIC_PACKET = "processor:symbolic-packet",
    SIGNAL = "processor:signal",
    ERROR = "processor:error"
}
export declare type ProcessorError = ErrorInfoSpace<ErrorCodeSpace.PROC> & {
    processor: Processor;
};
export declare type ProcessorEventDataProps = Partial<{
    socket: Socket;
    symbol: PacketSymbol;
    packet: Packet;
    signal: Signal;
    error: ProcessorError;
}>;
export declare type ProcessorEventData = {
    event: ProcessorEvent;
    processor: Processor;
} & ProcessorEventDataProps;
export declare type ProcessorEventHandler = (data: ProcessorEventData) => void;
export declare const PROCESSOR_RPC_INVOKE_PACKET_HANDLER = "mmjs:processor:RPC:invokePacketHandler";
export declare enum ProcessorConfigParamType {
    NUMBER = "number",
    STRING = "string",
    OBJECT = "object",
    ANY = "any"
}
export declare type ProcessorConfigParam = {
    name: string;
    type: ProcessorConfigParamType;
    value: any;
};
export declare function createProcessorConfigParam(name: string, value: any, type?: ProcessorConfigParamType): ProcessorConfigParam;
export declare function createProcessorConfigParamsFromArguments(args: any[]): ProcessorConfigParam[];
export declare abstract class Processor extends EventEmitter<ProcessorEvent> implements SocketOwner, SignalReceiver {
    private onSignal_;
    private socketTemplate_;
    static getName(): string;
    private inputs_;
    private outputs_;
    private taskWorker_;
    enableSymbolProxying: boolean;
    muteSymbolProcessing: boolean;
    constructor(onSignal_?: SignalHandler, socketTemplate_?: SocketTemplateGenerator);
    configure(params: ProcessorConfigParam[]): void;
    terminate(): void;
    templateSocketDescriptor(socketType: SocketType): SocketDescriptor;
    createEvent(event: ProcessorEvent, eventProps: ProcessorEventDataProps): ProcessorEventData;
    createErrorEvent(code: ErrorCode, message: string, nativeError?: Error, innerError?: ErrorInfo): ProcessorEventData;
    emitErrorEvent(code: ErrorCode, message: string, nativeError?: Error, innerError?: ErrorInfo): void;
    emit(event: ProcessorEvent, data: ProcessorEventData): boolean;
    emitEvent(event: ProcessorEvent, props: ProcessorEventDataProps): void;
    on(event: ProcessorEvent, handler: ProcessorEventHandler): this;
    once(event: ProcessorEvent, handler: ProcessorEventHandler): this;
    off(event: ProcessorEvent, handler: ProcessorEventHandler): this;
    getOwnSockets(): Set<Socket>;
    cast(signal: Signal): SignalReceiverCastResult;
    /**
     * Returns a copy of internal array, safe to manipulate
     * {InputSocket[]}
     */
    inputs(): InputSocket[];
    /**
     * Returns a copy of internal array, safe to manipulate
     * {OutputSocket[]}
     */
    outputs(): OutputSocket[];
    /**
     * Read-only internal array ref
     * {InputSocket[]}
     */
    get in(): InputSocket[];
    /**
     * Read-only internal array ref
     * {OutputSocket[]}
     */
    get out(): OutputSocket[];
    /**
     * Adds a new input socket with the given descriptor (or from default template)
     * {SocketDescriptor} sd optional
     */
    createInput(sd?: SocketDescriptor): InputSocket;
    /**
     * Adds a new output socket with the given descriptor (or from default template)
     * {SocketDescriptor} sd optional
     */
    createOutput(sd?: SocketDescriptor): OutputSocket;
    private getTaskWorker;
    /**
     * @returns True when packet was forwarded
     */
    private onSymbolicPacketReceived_;
    /**
     * p packet to transfer to all outputs
     */
    private transferPacketToAllOutputs_;
    private onReceiveFromInput_;
    private wrapTemplateSocketDescriptor_;
    private onSignalCast_;
    protected onTaskWorkerMessage(event: MessageEvent): void;
    protected dispatchTask(name: string, packet: Packet): void;
    /**
     * FIXME: explain this better
     *
     * At the same time handler for symbols, as well as
     * arbiter function to determine if this proc proxies or not specific symbols.
     *
     * Default proxies all non-VOID symbols.
     *
     * Per design this merely passes in the symbol, not the actual packet.
     *
     * Symbolic packets are only supposed to be a shell for the symbol itself,
     * their other properties should be ignored in that case. They also should
     * not carry any data.
     *
     * Returning false will have this packet carrying the symbol be passed into `processTransfer_`.
     *
     * Setting the Processor instance property `enableSymbolProxying` to false (default true)
     * will disable proxying generally for all packets. That way, proxying can be disabled while
     * packets with symbols will also not be passed into the processing scope.
     *
     * NOTE: Transferring the packet with the symbol to all output sockets "manually" is de-facto performing proxying.
     *
     * @returns True if the symbolic packet should be proxied, false if we want to handle this manually in the processing scope (when symbol-proxying enabled)
     */
    protected handleSymbolicPacket_(symbol: PacketSymbol): boolean;
    /**
     * Called when a packet is received on an input socket.
     * Returns true when packet was handled correctly in some way.
     */
    protected abstract processTransfer_(inS: InputSocket, p: Packet, inputIndex: number): boolean;
    /**
     * Needed by proxy shell
     * @param st
     */
    protected overrideSocketTemplate(st: SocketTemplateGenerator): void;
}
export declare class VoidProcessor extends Processor {
    protected processTransfer_(inS: InputSocket, p: Packet, inputIndex: number): boolean;
}