import * as i0 from '@angular/core';
import { Injector, Type, OnChanges, OnDestroy, ElementRef, ChangeDetectorRef, OnInit, ViewContainerRef, ComponentRef, ComponentFactoryResolver, SimpleChanges, EventEmitter, PipeTransform } from '@angular/core';
import { GetSchemes, ClassicPreset, NodeId, BaseSchemes, Scope, CanAssignSignal, ConnectionId } from 'rete';
import { SocketPositionWatcher } from 'rete-render-utils';
import { NgElement as NgElement$1, NgElementStrategy } from '@angular/elements';
import * as i1 from '@angular/common';
import { KeyValue } from '@angular/common';

type NgElement = NgElement$1 & {
    ngElementStrategy: NgElementStrategy & {
        setInputValue(key: string, value: any): void;
    };
};
type Position$1 = {
    x: number;
    y: number;
};
type RenderSignal<Type extends string, Data> = {
    type: 'render';
    data: {
        element: HTMLElement;
        filled?: boolean;
        type: Type;
    } & Data;
} | {
    type: 'rendered';
    data: {
        element: HTMLElement;
        type: Type;
    } & Data;
};

type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
type GetControls<T extends ClassicScheme['Node'], Intersection = UnionToIntersection<T['controls']>> = Intersection[keyof Intersection] extends ClassicPreset.Control ? Intersection[keyof Intersection] : ClassicPreset.Control;
type GetSockets<T extends ClassicScheme['Node'], Intersection = UnionToIntersection<T['inputs'] | T['outputs']>, Union = Exclude<Intersection[keyof Intersection], undefined>> = Union extends {
    socket: any;
} ? Union['socket'] : ClassicPreset.Socket;
type Side = 'input' | 'output';
type ExtractPayload<T extends ClassicScheme, K extends string> = Extract<AngularArea2D<T>, {
    type: 'render';
    data: {
        type: K;
    };
}>['data'];
type AngularArea2D<T extends ClassicScheme> = RenderSignal<'node', {
    payload: T['Node'];
}> | RenderSignal<'connection', {
    payload: T['Connection'];
    start?: Position$1;
    end?: Position$1;
}> | RenderSignal<'socket', {
    payload: GetSockets<T['Node']>;
    nodeId: NodeId;
    side: Side;
    key: string;
}> | RenderSignal<'control', {
    payload: GetControls<T['Node']>;
}> | {
    type: 'unmount';
    data: {
        element: HTMLElement;
    };
};
type ClassicScheme = GetSchemes<ClassicPreset.Node, ClassicPreset.Connection<ClassicPreset.Node, ClassicPreset.Node> & {
    isLoop?: boolean;
}>;

type Item$1 = {
    key: string;
    ngElement: NgElement;
};
type Renderer = {
    get(element: HTMLElement): Item$1 | undefined;
    mount(element: HTMLElement, key: string, component: any, injector: Injector, props: Record<string, unknown>): void;
    update(item: Item$1, props: Record<string, unknown>): void;
    unmount(element: HTMLElement): void;
};
/**
 * Signals that can be emitted by the plugin
 * @priority 10
 */
type Produces<Schemes extends BaseSchemes> = {
    type: 'connectionpath';
    data: {
        payload: Schemes['Connection'];
        path?: string;
        points: Position$1[];
    };
};
type Requires<Schemes extends BaseSchemes> = RenderSignal<'node', {
    payload: Schemes['Node'];
}> | RenderSignal<'connection', {
    payload: Schemes['Connection'];
    start?: Position$1;
    end?: Position$1;
}> | {
    type: 'unmount';
    data: {
        element: HTMLElement;
    };
};
/**
 * Angular plugin. Renders nodes, connections and other elements using React.
 * @priority 9
 * @emits connectionpath
 * @listens render
 * @listens unmount
 */
declare class AngularPlugin<Schemes extends BaseSchemes, T = Requires<Schemes>> extends Scope<Produces<Schemes>, [Requires<Schemes> | T]> {
    private params;
    presets: RenderPreset<Schemes, T>[];
    renderer: Renderer;
    owners: WeakMap<HTMLElement, RenderPreset<Schemes, T>>;
    /**
     * @constructor
     * @param params Plugin properties
     * @param params.injector Angular's Injector instance
     */
    constructor(params: {
        injector: Injector;
    });
    setParent(scope: Scope<Requires<Schemes> | T>): void;
    private unmount;
    private mount;
    /**
     * Adds a preset to the plugin.
     * @param preset Preset that can render nodes, connections and other elements.
     */
    addPreset<K>(preset: RenderPreset<Schemes, CanAssignSignal<T, K> extends true ? K : 'Cannot apply preset. Provided signals are not compatible'>): void;
}

type RenderPreset<Schemes extends BaseSchemes, T> = {
    attach?: (plugin: AngularPlugin<Schemes, T>) => void;
    update: (context: Extract<T, {
        type: 'render';
    }>, plugin: AngularPlugin<Schemes, T>) => Record<string, unknown> | undefined | null | void;
    mount: (context: Extract<T, {
        type: 'render';
    }>, plugin: AngularPlugin<Schemes, T>) => {
        key: string;
        component: any;
        props: Record<string, unknown>;
    } | undefined | null | void;
};

type AngularComponent = Type<any>;
type CustomizationProps<Schemes extends ClassicScheme> = {
    node?: (data: ExtractPayload<Schemes, 'node'>) => AngularComponent | null;
    connection?: (data: ExtractPayload<Schemes, 'connection'>) => AngularComponent | null;
    socket?: (data: ExtractPayload<Schemes, 'socket'>) => AngularComponent | null;
    control?: (data: ExtractPayload<Schemes, 'control'>) => AngularComponent | null;
};
type ClassicProps<Schemes extends ClassicScheme, K> = {
    socketPositionWatcher?: SocketPositionWatcher<Scope<never, [K]>>;
    customize?: CustomizationProps<Schemes>;
};
/**
 * Classic preset for rendering nodes, connections, controls and sockets.
 */
declare function setup$3<Schemes extends ClassicScheme, K extends AngularArea2D<Schemes>>(props?: ClassicProps<Schemes, K>): RenderPreset<Schemes, K>;

declare namespace index_d$4 {
  export {
    setup$3 as setup,
  };
}

type Item = {
    label: string;
    key: string;
    handler(): void;
    subitems?: Item[];
};
type ContextMenuRender = RenderSignal<'contextmenu', {
    items: Item[];
    onHide(): void;
    searchBar?: boolean;
}>;

/**
 * Preset for rendering context menu.
 */
declare function setup$2<Schemes extends BaseSchemes, K extends ContextMenuRender>(props?: {
    delay?: number;
}): RenderPreset<Schemes, K>;

declare namespace index_d$3 {
  export {
    setup$2 as setup,
  };
}

type Rect = {
    width: number;
    height: number;
    left: number;
    top: number;
};
type Transform = {
    x: number;
    y: number;
    k: number;
};
type Translate = (dx: number, dy: number) => void;
type MinimapData = {
    ratio: number;
    nodes: Rect[];
    viewport: Rect;
    start(): Transform;
    translate: Translate;
    point(x: number, y: number): void;
};
type MinimapRender = RenderSignal<'minimap', MinimapData>;

/**
 * Preset for rendering minimap.
 */
declare function setup$1<Schemes extends BaseSchemes, K extends MinimapRender>(props?: {
    size?: number;
}): RenderPreset<Schemes, K>;

declare namespace index_d$2 {
  export {
    setup$1 as setup,
  };
}

type Position = {
    x: number;
    y: number;
};
type Pin = {
    id: string;
    position: Position;
    selected?: boolean;
};
type PinData = {
    id: ConnectionId;
    pins: Pin[];
};
type PinsRender = RenderSignal<'reroute-pins', {
    data: PinData;
}>;

type Props = {
    translate?: (id: string, dx: number, dy: number) => void;
    contextMenu?: (id: string) => void;
    pointerdown?: (id: string) => void;
};
/**
 * Preset for rendering pins.
 */
declare function setup<Schemes extends BaseSchemes, K extends PinsRender>(props?: Props): RenderPreset<Schemes, K>;

declare const index_d$1_setup: typeof setup;
declare namespace index_d$1 {
  export {
    index_d$1_setup as setup,
  };
}

/**
 * Built-in presets, responsible for rendering different parts of the editor.
 * @module
 */

declare namespace index_d {
  export {
    index_d$4 as classic,
    index_d$3 as contextMenu,
    index_d$2 as minimap,
    index_d$1 as reroute,
  };
}

declare class RefDirective implements OnChanges, OnDestroy {
    private el;
    data: any;
    emit: any;
    constructor(el: ElementRef);
    ngOnChanges(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RefDirective, "[refComponent]", never, { "data": { "alias": "data"; "required": false; }; "emit": { "alias": "emit"; "required": false; }; }, {}, never, never, true, never>;
}

type NodeExtraData = {
    width?: number;
    height?: number;
};
type SortValue<N extends ClassicPreset.Node> = (N['controls'] | N['inputs'] | N['outputs'])[string];
declare class NodeComponent implements OnChanges {
    private cdr;
    data: ClassicPreset.Node & NodeExtraData;
    emit: (data: any) => void;
    rendered: () => void;
    seed: number;
    get width(): number;
    get height(): number;
    get selected(): boolean;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(): void;
    sortByIndex<N extends ClassicPreset.Node, I extends KeyValue<string, SortValue<N>>>(a: I, b: I): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<NodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NodeComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "emit": { "alias": "emit"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ConnectionComponent {
    data: ClassicPreset.Connection<ClassicPreset.Node, ClassicPreset.Node>;
    start: Position$1;
    end: Position$1;
    path: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConnectionComponent, "connection", never, { "data": { "alias": "data"; "required": false; }; "start": { "alias": "start"; "required": false; }; "end": { "alias": "end"; "required": false; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, true, never>;
}

type PositionWatcher = (cb: (value: Position$1) => void) => (() => void);
declare class ConnectionWrapperComponent implements OnInit, OnChanges {
    private cdr;
    viewContainerRef: ViewContainerRef;
    private componentFactoryResolver;
    data: ClassicPreset.Connection<ClassicPreset.Node, ClassicPreset.Node>;
    start: Position$1 | PositionWatcher;
    end: Position$1 | PositionWatcher;
    path: (start: Position$1, end: Position$1) => Promise<string>;
    rendered: any;
    connectionComponent: any;
    ref: ComponentRef<any>;
    startOb: Position$1 | null;
    get _start(): Position$1 | null;
    endOb: Position$1 | null;
    get _end(): Position$1 | null;
    _path: string;
    constructor(cdr: ChangeDetectorRef, viewContainerRef: ViewContainerRef, componentFactoryResolver: ComponentFactoryResolver);
    ngOnChanges(): Promise<void>;
    updatePath(): Promise<void>;
    ngOnInit(): void;
    update(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConnectionWrapperComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "start": { "alias": "start"; "required": false; }; "end": { "alias": "end"; "required": false; }; "path": { "alias": "path"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; "connectionComponent": { "alias": "connectionComponent"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SocketComponent implements OnChanges {
    private cdr;
    data: any;
    rendered: any;
    get title(): any;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SocketComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SocketComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ControlComponent<T extends 'text' | 'number'> implements OnChanges {
    private cdr;
    data: ClassicPreset.InputControl<T>;
    rendered: any;
    pointerdown(event: any): void;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    onChange(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ControlComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ControlComponent<any>, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ReteModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ReteModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteModule, never, [typeof i1.CommonModule, typeof RefDirective, typeof NodeComponent, typeof ConnectionComponent, typeof ConnectionWrapperComponent, typeof SocketComponent, typeof ControlComponent], [typeof RefDirective, typeof NodeComponent, typeof ConnectionComponent, typeof ConnectionWrapperComponent, typeof SocketComponent, typeof ControlComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ReteModule>;
}

declare class ContextMenuComponent implements OnChanges, OnDestroy {
    private cdr;
    items: Item[];
    delay: number;
    searchBar?: boolean;
    onHide: () => void;
    rendered: () => void;
    filter: string;
    hide: {
        timeout: null | number;
        cancel(): void;
        call(delay: number): void;
    };
    customAttribute: string;
    pointerover(): void;
    pointerleave(): void;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(): void;
    setFilter(value: string): void;
    getItems(): Item[];
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "ng-component", never, { "items": { "alias": "items"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "searchBar": { "alias": "searchBar"; "required": false; }; "onHide": { "alias": "onHide"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ContextMenuSearchComponent {
    value: string;
    update: EventEmitter<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuSearchComponent, "context-menu-search", never, { "value": { "alias": "value"; "required": false; }; }, { "update": "update"; }, never, never, true, never>;
}

declare class ContextMenuItemComponent {
    private cdr;
    subitems?: Item[];
    delay: number;
    select: EventEmitter<void>;
    hide: EventEmitter<void>;
    get block(): boolean;
    get hasSubitems(): Item[];
    click(event: MouseEvent): void;
    pointerdown(event: PointerEvent): void;
    wheel(event: MouseEvent): void;
    hideSubitems: {
        timeout: null | number;
        cancel(): void;
        call(delay: number): void;
    };
    visibleSubitems: boolean;
    pointerover(): void;
    pointerleave(): void;
    constructor(cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuItemComponent, "context-menu-item", never, { "subitems": { "alias": "subitems"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; }, { "select": "select"; "hide": "hide"; }, never, ["*"], true, never>;
}

declare class ReteContextMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ReteContextMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteContextMenuModule, never, [typeof i1.CommonModule, typeof ContextMenuComponent, typeof ContextMenuSearchComponent, typeof ContextMenuItemComponent], [typeof ContextMenuComponent, typeof ContextMenuSearchComponent, typeof ContextMenuItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ReteContextMenuModule>;
}

declare class MinimapComponent implements OnChanges {
    el: ElementRef;
    private cdr;
    rendered: () => void;
    size: number;
    ratio: MinimapData['ratio'];
    nodes: MinimapData['nodes'];
    viewport: MinimapData['viewport'];
    translate: MinimapData['translate'];
    point: MinimapData['point'];
    get width(): string;
    get height(): string;
    pointerdown(event: PointerEvent): void;
    dblclick(event: MouseEvent): void;
    constructor(el: ElementRef, cdr: ChangeDetectorRef);
    ngOnChanges(): void;
    px(value: number): string;
    scale(value: number): number;
    identifyMiniNode(_: number, item: MinimapData['nodes'][number]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MinimapComponent, "ng-component", never, { "rendered": { "alias": "rendered"; "required": false; }; "size": { "alias": "size"; "required": false; }; "ratio": { "alias": "ratio"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; "viewport": { "alias": "viewport"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; "point": { "alias": "point"; "required": false; }; }, {}, never, never, true, never>;
}

declare class MiniViewportComponent {
    left: number;
    top: number;
    width: number;
    height: number;
    containerWidth: number;
    translate: MinimapData['translate'];
    drag: {
        start(e: {
            pageX: number;
            pageY: number;
        }): void;
    };
    get styleLeft(): string;
    get styleTop(): string;
    get styleWidth(): string;
    get styleHeight(): string;
    pointerdown(event: PointerEvent): void;
    px(value: number): string;
    scale(v: number): number;
    invert(v: number): number;
    onDrag(dx: number, dy: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MiniViewportComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MiniViewportComponent, "minimap-mini-viewport", never, { "left": { "alias": "left"; "required": false; }; "top": { "alias": "top"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "containerWidth": { "alias": "containerWidth"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; }, {}, never, never, true, never>;
}

declare class MiniNodeComponent {
    left: number;
    top: number;
    width: number;
    height: number;
    get styleLeft(): string;
    get styleTop(): string;
    get styleWidth(): string;
    get styleHeight(): string;
    px(value: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MiniNodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MiniNodeComponent, "minimap-mini-node", never, { "left": { "alias": "left"; "required": false; }; "top": { "alias": "top"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ReteMinimapModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ReteMinimapModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteMinimapModule, never, [typeof i1.CommonModule, typeof MinimapComponent, typeof MiniViewportComponent, typeof MiniNodeComponent], [typeof MinimapComponent, typeof MiniViewportComponent, typeof MiniNodeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ReteMinimapModule>;
}

declare class PinsComponent implements OnChanges {
    private cdr;
    rendered: () => void;
    pins: PinData['pins'];
    down?: (id: string) => void;
    translate?: (id: string, dx: number, dy: number) => void;
    menu?: (id: string) => void;
    getPointer?: () => Position;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(): void;
    track(_: number, item: Pin): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PinsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PinsComponent, "ng-component", never, { "rendered": { "alias": "rendered"; "required": false; }; "pins": { "alias": "pins"; "required": false; }; "down": { "alias": "down"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "getPointer": { "alias": "getPointer"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PinComponent implements OnChanges {
    private cdr;
    position: Position;
    selected?: boolean;
    getPointer: () => Position;
    menu: EventEmitter<void>;
    translate: EventEmitter<{
        dx: number;
        dy: number;
    }>;
    down: EventEmitter<void>;
    drag: {
        start(e: {
            pageX: number;
            pageY: number;
        }): void;
    };
    get _selected(): boolean;
    get top(): string;
    get left(): string;
    pointerdown(event: PointerEvent): void;
    contextmenu(event: MouseEvent): void;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PinComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PinComponent, "reroute-pin", never, { "position": { "alias": "position"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "getPointer": { "alias": "getPointer"; "required": false; }; }, { "menu": "menu"; "translate": "translate"; "down": "down"; }, never, never, true, never>;
}

declare class ReteRerouteModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ReteRerouteModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteRerouteModule, never, [typeof i1.CommonModule, typeof PinsComponent, typeof PinComponent], [typeof PinsComponent, typeof PinComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ReteRerouteModule>;
}

declare class ImpureKeyvaluePipe implements PipeTransform {
    transform(value: {
        [key: string]: any;
    } | null | undefined, compareFn?: (a: any, b: any) => number): Array<{
        key: string;
        value: any;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImpureKeyvaluePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ImpureKeyvaluePipe, "keyvalueimpure", true>;
}

export { AngularPlugin, ConnectionComponent, ConnectionWrapperComponent, ContextMenuComponent, ContextMenuItemComponent, ContextMenuSearchComponent, ControlComponent, ImpureKeyvaluePipe, MiniNodeComponent, MiniViewportComponent, MinimapComponent, NodeComponent, PinComponent, PinsComponent, index_d as Presets, RefDirective, ReteContextMenuModule, ReteMinimapModule, ReteModule, ReteRerouteModule, SocketComponent };
export type { AngularArea2D, Produces, RenderPreset };