import { ComponentFactoryResolver, ComponentRef, Renderer2, RendererFactory2, ViewContainerRef } from '@angular/core';
import { BaseEntity } from '../base.entity';
import { AbstractLabelFactory } from '../factories/label.factory';
import { AbstractLinkFactory } from '../factories/link.factory';
import { AbstractNodeFactory } from '../factories/node.factory';
import { AbstractPortFactory } from '../factories/port.factory';
import { DiagramModel } from '../models/diagram.model';
import { LabelModel } from '../models/label.model';
import { LinkModel } from '../models/link.model';
import { NodeModel } from '../models/node.model';
import { PortModel } from '../models/port.model';
import { PathFinding } from '../plugins/smart-routing.plugin';
import { EntityMap } from '../utils';
export declare class DiagramEngine {
    protected resolver: ComponentFactoryResolver;
    protected rendererFactory: RendererFactory2;
    protected _renderer: Renderer2;
    protected nodeFactories: Map<string, AbstractNodeFactory<NodeModel<PortModel>>>;
    protected labelFactories: Map<string, AbstractLabelFactory<LabelModel>>;
    protected linkFactories: Map<string, AbstractLinkFactory<LinkModel>>;
    protected portFactories: Map<string, AbstractPortFactory<PortModel>>;
    protected canvas$: import("../state/state").ValueState<Element>;
    smartRouting: boolean;
    pathFinding: PathFinding;
    canvasMatrix: number[][];
    routingMatrix: number[][];
    hAdjustmentFactor: number;
    vAdjustmentFactor: number;
    diagramModel: DiagramModel;
    constructor(resolver: ComponentFactoryResolver, rendererFactory: RendererFactory2);
    createDiagram(): DiagramModel;
    registerDefaultFactories(): void;
    registerLabelFactory(labelFactory: AbstractLabelFactory): void;
    getLabelFactories(): EntityMap<AbstractLabelFactory>;
    getLabelFactory(type: string): AbstractLabelFactory;
    getFactoryForLabel(label: LabelModel): AbstractLabelFactory | null;
    generateWidgetForLabel(label: LabelModel, labelHost: ViewContainerRef): ComponentRef<LabelModel> | null;
    registerNodeFactory(nodeFactory: AbstractNodeFactory): void;
    getNodeFactories(): EntityMap<AbstractNodeFactory>;
    getNodeFactory(type: string): AbstractNodeFactory;
    getFactoryForNode(node: NodeModel): AbstractNodeFactory | null;
    generateWidgetForNode(node: NodeModel, nodesHost: ViewContainerRef): ComponentRef<NodeModel> | null;
    registerPortFactory(factory: AbstractPortFactory): void;
    getPortFactories(): Map<string, AbstractPortFactory<PortModel>>;
    getPortFactory(type: string): AbstractPortFactory;
    getFactoryForPort(port: PortModel): AbstractPortFactory | null;
    generateWidgetForPort(port: PortModel, portsHost: ViewContainerRef): ComponentRef<PortModel> | null;
    getLinkFactories(): EntityMap<AbstractLinkFactory>;
    registerLinkFactory(factory: AbstractLinkFactory): void;
    getLinkFactory(type: string): AbstractLinkFactory;
    getFactoryForLink(link: LinkModel): AbstractLinkFactory | null;
    generateWidgetForLink(link: LinkModel, linksHost: ViewContainerRef): ComponentRef<LinkModel> | null;
    getNodeElement(node: NodeModel): HTMLElement;
    getNodePortElement(port: PortModel): HTMLElement;
    getPortCenter(port: PortModel): {
        x: number;
        y: number;
    };
    /**
     * Calculate rectangular coordinates of the port passed in.
     */
    getPortCoords(port: PortModel): {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    /**
     * Determine the width and height of the node passed in.
     * It currently assumes nodes have a rectangular shape, can be overriden for customised shapes.
     */
    getNodeDimensions(node: NodeModel): {
        width: number;
        height: number;
    };
    setCanvas(canvas: Element): void;
    getRelativeMousePoint(event: MouseEvent): {
        x: number;
        y: number;
    };
    getRelativePoint(x: number, y: number): {
        x: number;
        y: number;
    };
    getDiagramModel(): DiagramModel;
    isModelLocked(model: BaseEntity): boolean;
    /**
     * fit the canvas zoom levels to the elements contained.
     * @param additionalZoomFactor allow for further zooming out to make sure edges doesn't cut
     */
    zoomToFit(additionalZoomFactor?: number): void;
    setSmartRoutingStatus(status: boolean): void;
    getPathfinding(): PathFinding;
    calculateCanvasMatrix(): void;
    /**
     * Despite being a long method, we simply iterate over all three collections (nodes, ports and points)
     * to find the highest X and Y dimensions, so we can build the matrix large enough to contain all elements.
     */
    calculateMatrixDimensions(): {
        width: number;
        hAdjustmentFactor: number;
        height: number;
        vAdjustmentFactor: number;
    };
    /**
     * A representation of the canvas in the following format:
     *
     * +-----------------+
     * | 0 0 0 0 0 0 0 0 |
     * | 0 0 0 0 0 0 0 0 |
     * | 0 0 0 0 0 0 0 0 |
     * | 0 0 0 0 0 0 0 0 |
     * | 0 0 0 0 0 0 0 0 |
     * +-----------------+
     *
     * In which all walkable points are marked by zeros.
     * It uses @link{#ROUTING_SCALING_FACTOR} to reduce the matrix dimensions and improve performance.
     */
    getCanvasMatrix(): number[][];
    /**
     * The routing matrix does not have negative indexes, but elements could be negatively positioned.
     * We use the functions below to translate back and forth between these coordinates, relying on the
     * calculated values of hAdjustmentFactor and vAdjustmentFactor.
     */
    translateRoutingX(x: number, reverse?: boolean): number;
    translateRoutingY(y: number, reverse?: boolean): number;
    /**
     * A representation of the canvas in the following format:
     *
     * +-----------------+
     * | 0 0 1 1 0 0 0 0 |
     * | 0 0 1 1 0 0 1 1 |
     * | 0 0 0 0 0 0 1 1 |
     * | 1 1 0 0 0 0 0 0 |
     * | 1 1 0 0 0 0 0 0 |
     * +-----------------+
     *
     * In which all points blocked by a node (and its ports) are
     * marked as 1; points were there is nothing (ie, free) receive 0.
     */
    getRoutingMatrix(): number[][];
    calculateRoutingMatrix(): void;
    getSmartRouting(): boolean;
    /**
     * Updates (by reference) where nodes will be drawn on the matrix passed in.
     */
    markNodes(matrix: number[][]): void;
    /**
     * Updates (by reference) where ports will be drawn on the matrix passed in.
     */
    markPorts(matrix: number[][]): void;
    markMatrixPoint: (matrix: number[][], x: number, y: number) => void;
}