import { Point, Rectangle, Vert } from 'webcola';
export interface NodeAccessor<Node> {
    getChildren(v: Node): number[];
    getBounds(v: Node): WCRectangle;
}
export interface GridLine {
    nodes: WCNodeWrapper[];
    pos: number;
}
export declare class WCRectangle {
    x: number;
    X: number;
    y: number;
    Y: number;
    constructor(x: number, X: number, y: number, Y: number);
    static empty(): WCRectangle;
    cx(): number;
    cy(): number;
    overlapX(r: WCRectangle): number;
    overlapY(r: WCRectangle): number;
    setXCentre(cx: number): void;
    setYCentre(cy: number): void;
    width(): number;
    height(): number;
    union(r: WCRectangle): WCRectangle;
    /**
     * return any intersection points between the given line and the sides of this rectangle
     * @method lineIntersection
     * @param x1 number first x coord of line
     * @param y1 number first y coord of line
     * @param x2 number second x coord of line
     * @param y2 number second y coord of line
     * @return any intersection points found
     */
    lineIntersections(x1: number, y1: number, x2: number, y2: number): Array<Point>;
    /**
     * return any intersection points between a line extending from the centre of this rectangle to the given point,
     *  and the sides of this rectangle
     * @method lineIntersection
     * @param x2 number second x coord of line
     * @param y2 number second y coord of line
     * @return any intersection points found
     */
    rayIntersection(x2: number, y2: number): Point | null;
    vertices(): Point[];
    static lineIntersection(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): Point | null;
    inflate(pad: number): WCRectangle;
}
export type WCNodeID = number;
export interface WCGridRouterRoot {
    id: 'root';
    children: WCNodeID[];
}
export declare class WCNodeWrapperPartial {
    leaf: boolean;
    ports: Vert[];
    children: number[];
    rect: Rectangle;
    id: number;
    constructor(id: number, rect: Rectangle, children: number[]);
}
export declare class WCNodeWrapper {
    id: number;
    rect: Rectangle;
    children: number[];
    leaf: boolean;
    ports: Vert[];
    parent: WCNodeWrapper | WCGridRouterRoot;
    constructor(partial: WCNodeWrapperPartial, parent: WCNodeWrapper | WCGridRouterRoot);
}
export interface WCEdge {
    source: WCNodeID;
    target: WCNodeID;
    length: number;
}
export declare class WCGridRouter<Node = any> {
    leaves: WCNodeWrapper[];
    groups: WCNodeWrapper[];
    nodes: WCNodeWrapper[];
    cols: GridLine[];
    rows: GridLine[];
    root: WCGridRouterRoot;
    verts: Vert[];
    edges: WCEdge[];
    backToFront: WCNodeWrapper[];
    obstacles?: any[];
    passableEdges?: WCEdge[];
    originalnodes: Node[];
    groupPadding: number;
    assembleNodes(originalnodes: Node[], accessor: NodeAccessor<Node>): {
        nodes: WCNodeWrapper[];
        root: WCGridRouterRoot;
    };
    constructor(originalnodes: Node[], accessor: NodeAccessor<Node>, groupPadding?: number);
    avg(a: number[]): number;
    clamp(val: number, min: number, max: number): number;
    getGridLines(axis: 'x' | 'y'): {
        nodes: WCNodeWrapper[];
        pos: number;
    }[];
    getDepth(node: WCNodeWrapper): number;
    midPoints(a: number[]): number[];
    findLineage(node: WCNodeWrapper): (WCNodeWrapper | WCGridRouterRoot)[];
    findAncestorPathBetween(a: WCNodeWrapper, b: WCNodeWrapper): {
        commonAncestor: WCNodeWrapper | WCGridRouterRoot;
        lineages: (WCNodeWrapper | WCGridRouterRoot)[];
    };
    siblingObstacles(a: WCNodeWrapper, b: WCNodeWrapper): WCNodeWrapper[];
    static getSegmentSets(routes: Point[][][], x: keyof Point, y: string): {
        pos: number;
        segments: any[];
    }[];
    static nudgeSegs(x: keyof Point, y: string, routes: Point[][][], segments: any[], leftOf: (e1: number, e2: number) => boolean, gap: number): void;
    static nudgeSegments(routes: Point[][][], x: keyof Point, y: string, leftOf: (e1: number, e2: number) => boolean, gap: number): void;
    routeEdges<Edge>(edges: Edge[], nudgeGap: number, source: (e: Edge) => number, target: (e: Edge) => number): Point[][][];
    static unreverseEdges(routes: Point[][][], routePaths: Point[][]): void;
    static angleBetween2Lines(line1: Point[], line2: Point[]): number;
    static isLeft(a: Point, b: Point, c: Point): boolean;
    static getOrder(pairs: {
        l: number;
        r: number;
    }[]): (l: number, r: number) => boolean;
    static orderEdges(edges: Point[][]): (l: number, r: number) => boolean;
    static makeSegments(path: Point[]): Point[][];
    route(s: number, t: number): Point[];
    static getRoutePath(route: Point[][], cornerradius: number, arrowwidth: number, arrowheight: number): {
        routepath: string;
        arrowpath: string;
    };
}