import { SerializedVector, Vector } from './vector.js';
import { Align } from '../common/enums.js';
import { UINode, UINodeOptions } from '../ui/ui-node.js';
import { Container } from '../ui/container.js';
import { Color, SerializedColor } from './color.js';
import { Flow } from './flow.js';
import { Group } from './group.js';
import { Terminal, SerializedTerminal } from './terminal.js';
import { Hooks } from './hooks.js';
import { DataPersistenceProvider, Events, NodeRenderers, Renderable, RenderFn, RenderState, Serializable } from '../common/interfaces.js';
export interface NodeState {
    [x: string]: unknown;
}
export declare abstract class Node<S extends NodeState = NodeState> extends Hooks implements Events, Serializable<SerializedNode>, Renderable {
    renderers: NodeRenderers;
    private _width?;
    private _zIndex;
    private _position?;
    private stateObserver;
    currHitTerminal?: Terminal;
    prevHitTerminal?: Terminal;
    currHitUINode?: UINode;
    prevHitUINode?: UINode;
    flow?: Flow;
    name?: string;
    id?: string;
    type?: string;
    hitColor?: Color;
    private _style?;
    focused: boolean;
    ui?: Container;
    uiNodes: Map<string, UINode>;
    terminals: Map<string, Terminal>;
    inputs: Terminal[];
    outputs: Terminal[];
    inputsUI: Terminal[];
    outputsUI: Terminal[];
    state?: S;
    group?: Group;
    nodeButtons: Map<string, NodeButton>;
    renderState: RenderState;
    get style(): NodeStyle | undefined;
    set style(style: NodeStyle);
    get height(): number | undefined;
    get context(): CanvasRenderingContext2D | undefined;
    get offContext(): OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D | undefined;
    get offUIContext(): OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D | undefined;
    get position(): Vector | undefined;
    set position(position: Vector);
    get zIndex(): number;
    set zIndex(zIndex: number);
    get width(): number | undefined;
    set width(width: number);
    protected constructor();
    static create<T extends Node = Node>(type: string, flow: Flow, position: Vector, options?: NodeOptions, isDeserialized?: boolean): T;
    abstract setupIO(options: NodeOptions): void;
    protected abstract created(options: NodeOptions): void;
    protected abstract process(inputs: any[]): void;
    private setupTerminals;
    private setupState;
    watch(propName: string, callback: (oldVal: any, newVal: any) => void): number | undefined;
    unwatch(propName: string, id: number): void;
    private setHitColor;
    addNodeButton(onClick: (node: Node) => void, render: RenderFn<NodeButton, NodeButtonRenderParams | undefined>, align: Align): NodeButton | undefined;
    private reflow;
    private updateRenderState;
    private recalculateInputTerminals;
    private recalculateOutputTerminals;
    getHitTerminal(hitColor: string, screenPosition: Vector, realPosition: Vector): Terminal | undefined;
    getHitUINode(hitColor: string): UINode | undefined;
    private getHitNodeButton;
    run(): void;
    render(): void;
    private renderTerminals;
    private renderName;
    private renderFocused;
    private _render;
    private _offRender;
    private static renderControlButton;
    private getRenderParams;
    addTerminals(terminals: Terminal[] | SerializedTerminal[]): void;
    addTerminal(terminal: Terminal | SerializedTerminal): Terminal;
    removeTerminal(terminal: Terminal): void;
    getInput(terminal: string | number): any;
    getInputs(): any[];
    setOutputs(outputs: string | number | Record<string, any>, data?: any): void;
    toggle(): void;
    dispose(): void;
    createUI<T extends UINode = UINode, O extends UINodeOptions = UINodeOptions>(type: string, options: O): T;
    onDown(screenPos: Vector, realPos: Vector): void;
    onOver(screenPos: Vector, realPos: Vector): void;
    onEnter(screenPosition: Vector, realPosition: Vector): void;
    onExit(screenPosition: Vector, realPosition: Vector): void;
    onUp(screenPos: Vector, realPos: Vector): void;
    onClick(screenPos: Vector, realPos: Vector): void;
    onDrag(screenPos: Vector, realPos: Vector): void;
    onContextMenu(screenPos: Vector, realPos: Vector): void;
    onWheel(direction: boolean, screenPos: Vector, realPos: Vector): void;
    private serializeState;
    serialize(persist?: DataPersistenceProvider): Promise<SerializedNode>;
}
export interface NodeRenderParams {
    position: SerializedVector;
    width: number;
    height: number;
    focus: boolean;
}
export declare enum NodeUIState {
    MAXIMIZED = "Maximized",
    MINIMIZED = "Minimized"
}
export interface NodeStyle {
    font?: string;
    fontSize?: string;
    titleFont?: string;
    titleFontSize?: string;
    padding?: number;
    spacing?: number;
    rowHeight?: number;
    color?: string;
    titleColor?: string;
    titleHeight?: number;
    terminalRowHeight?: number;
    terminalStripMargin?: number;
    maximizeButtonColor?: string;
    expandButtonColor?: string;
    minimizedTerminalColor?: string;
    nodeButtonSize?: number;
    nodeButtonSpacing?: number;
    outlineColor?: string;
}
export interface SerializedNode {
    id?: string;
    name?: string;
    type?: string;
    position?: SerializedVector;
    width?: number;
    hitColor?: SerializedColor;
    zIndex: number;
    focused: boolean;
    state: Record<string, any>;
    renderState: RenderState;
    inputs: SerializedTerminal[];
    outputs: SerializedTerminal[];
    style?: NodeStyle;
}
export interface NodeOptions<S extends NodeState = NodeState> {
    name: string;
    width?: number;
    style?: NodeStyle;
    state?: S;
    id?: string;
    hitColor?: Color;
    inputs?: SerializedTerminal[];
    outputs?: SerializedTerminal[];
}
export declare class NodeButton extends Hooks implements Renderable {
    node: Node;
    onClick: (n: Node) => void;
    align: Align;
    renderer: RenderFn<NodeButton, NodeButtonRenderParams | undefined>;
    style: Record<string, any>;
    hitColor?: Color;
    deltaX: number;
    constructor(node: Node, onClick: (n: Node) => void, renderer: RenderFn<NodeButton, NodeButtonRenderParams | undefined>, align: Align, style?: Record<string, any>);
    private setHitColor;
    render(): void;
    private getRenderParams;
    private _offUIRender;
}
export interface NodeButtonRenderParams {
    position: SerializedVector;
}