declare class Vec {
    x: number;
    y: number;
    constructor(x: number, y: number);
    add(v: Vec): void;
}

type DummyValues<A> = {
    srcNodeKey: string;
    srcNodeAttributes: A | undefined;
    destNodeKey: string;
    destNodeAttributes: A | undefined;
};
declare class Node<A> {
    key: string;
    depth: number;
    position: Vec;
    orderNr: number;
    optimalPosY: number;
    attributes: A | undefined;
    clicked: boolean;
    mouseOver: boolean;
    dummyValues?: DummyValues<A>;
    edges: Edge<A>[];
    inEdges: Edge<A>[];
    constructor(key: string, attributes?: A, dummyValues?: DummyValues<A>);
    get dummy(): boolean;
    get posX(): number;
    set posX(x: number);
    get posY(): number;
    set posY(y: number);
    equalValues(node: Node<A>): boolean;
    equalStructure(node: Node<A>): boolean;
    setOptimalPositionY(srcNodes: Node<A>[], canvasHeigth: number): void;
    hasEdges(): boolean;
    setDepth(depth: number): void;
}

type BezierPoints = {
    cp1: Vec;
    cp2: Vec;
};
type State = {
    clicked: boolean;
    mouseOver: boolean;
};
declare class Edge<A> {
    srcNode: Node<A>;
    destNode: Node<A>;
    bezierPoints: BezierPoints;
    state: State;
    constructor(srcNode: Node<A>, destNode: Node<A>, state?: State);
}

declare class Graph<A> {
    nodes: Map<string, Node<A>>;
    rootNodeKeys: string[];
    isDepthSet: Boolean;
    constructor();
    addNode(key: string, attributes?: A, dummyValues?: DummyValues<A>): Node<A>;
    addEdge(srcNodeKey: string, destNodeKey: string, sharedState?: State): void;
    initialize(rootNodeKeys: string[]): void;
    createDummyNodes(): void;
    removeEdge(srcNode: Node<A>, destNode: Node<A>): void;
    getDepth(): number;
    equalValues(graph: Graph<A>): boolean;
    equalStructure(graph: Graph<A>): boolean;
    getNodesAtDepth(depth: number): Node<A>[];
    setDepthNodes(): void;
    static clone<A>(graph: Graph<A>): Graph<A>;
}

declare class Drawer<A> {
    graph: Graph<A>;
    config: ConfigIntern<A>;
    context: CanvasRenderingContext2D;
    constructor(config: ConfigIntern<A>, canvas: HTMLCanvasElement);
    setBezierCurvePoints(): void;
    draw(graph?: Graph<A>): void;
    drawBackground(): void;
    drawNode(node: Node<A>): void;
    drawEdges(node: Node<A>): void;
}

declare class Positioner<A> {
    config: ConfigIntern<A>;
    drawer: Drawer<A>;
    constructor(config: ConfigIntern<A>, drawer: Drawer<A>);
    setPositions(inputGraph: Graph<A>): void;
    setCoordinates(graph: Graph<A>): void;
    getPositionsY(nodeCount: number): number[];
    setPositionY(graph: Graph<A>): void;
    setPositionX(graph: Graph<A>): void;
    ordering(graph: Graph<A>): Graph<A>;
    sweepLeftToRight(graph: Graph<A>): void;
    sweepRightToLeft(graph: Graph<A>): void;
    transpose(graph: Graph<A>): void;
    median(arr: number[]): number;
    /**
     * Calculates the optimal y position.
     * Function is minimizing the edge length from the incoming edges of a node.
     */
    optimalPositionY(node: Node<A>): number;
    linearCoefficient<A>(srcNode: Node<A>, destNode: Node<A>): number[];
    checkIntersection(edgeA: Edge<A>, edgeB: Edge<A>): boolean;
    crossingAdjacentLayers(depth: number, graph: Graph<A>): number;
    crossingsLayer(nodes: Node<A>[]): number;
    crossings(graph: Graph<A>): number;
}

type GraphMethods<G, A> = {
    getNodeKeys: (graph: G) => string[];
    getDestNodeKeys: (graph: G, nodeKey: string) => string[];
    getNodeAttribute?: (graph: G, nodeKey: string) => A;
};
type ConfigIntern<A> = {
    maxArrangements: number;
    maxIntersections: number;
    width: number;
    height: number;
    paddingGraph: number;
    nodeClick: (key: string, position: {
        x: number;
        y: number;
    }, event: MouseEvent, draw: () => void) => void;
    nodeHover: (key: string | null, position: {
        x: number;
        y: number;
    } | null, event: MouseEvent, draw: () => void) => void;
    edgeClick: (srcNodeKey: string, destNodeKey: string, event: MouseEvent, draw: () => void) => void;
    edgeHover: (srcNodeKey: string | null, destNodeKey: string | null, event: MouseEvent, draw: () => void) => void;
    nodeEventThreshold: number;
    edgeEventThreshold: number;
    backgroundColor: string;
    nodeRadius: ((key: string, attribute: A, clicked: boolean, mouseOver: boolean) => number) | number;
    nodeBorderWidth: ((key: string, attribute: A, clicked: boolean, mouseOver: boolean) => number) | number;
    nodeBorderColor: ((key: string, attribute: A, clicked: boolean, mouseOver: boolean) => string) | string;
    nodeColor: ((key: string, attribute: A, clicked: boolean, mouseOver: boolean) => string) | string;
    nodeHasText: boolean;
    nodeTextOffset: {
        x: number;
        y: number;
    };
    nodeFontColor: string;
    nodeFontSize: number;
    nodeFont: string;
    nodeText: ((key: string, attribute: A, clicked: boolean, mouseOver: boolean) => string) | string;
    edgeWidth: ((srcNodeKey: string, destNodeKey: string, srcAttribute: A, destNodeAttribute: A, clicked: boolean, mouseOver: boolean) => number) | number;
    edgeColor: ((srcNodeKey: string, destNodeKey: string, srcAttribute: A, destNodeAttribute: A, clicked: boolean, mouseOver: boolean) => string) | string;
    styleCanvas: Partial<CSSStyleDeclaration>;
};
type Config<A> = Partial<ConfigIntern<A>>;
declare class GraphDrawer<G, A = undefined> {
    graphMethods: GraphMethods<G, A>;
    config: ConfigIntern<A>;
    graph: Graph<A>;
    canvas: HTMLCanvasElement;
    drawer: Drawer<A>;
    positioner: Positioner<A>;
    constructor(graphMethods: GraphMethods<G, A>, container: HTMLElement, config: Partial<ConfigIntern<A>>);
    createCanvas(container: HTMLElement): HTMLCanvasElement;
    setupMouseMoveListener(): void;
    setupMouseClickListener(): void;
    distance(p1: Vec, p2: Vec): number;
    cubicBezier(t: number, P0: Vec, P1: Vec, P2: Vec, P3: Vec): Vec;
    edgeAtPosition(pos: Vec): Edge<A> | null;
    nodeAtPosition(pos: Vec): Node<A> | null;
    update(inputGraph: G, rootNodes: string[]): void;
}

export { type Config, type ConfigIntern, type GraphMethods, GraphDrawer as default };