import { Point } from '../../..';
import { Polyline } from '../../../math/geometry';
import { PolylinePoint } from '../../../math/geometry/polylinePoint';
import { RectangleNode } from '../../../math/geometry/RTree/RectangleNode';
import { PointPairMap } from '../../../utils/pointPairMap';
import { PointSet } from '../../../utils/PointSet';
import { BundlingSettings } from '../../BundlingSettings';
import { MetroGraphData } from './MetroGraphData';
import { Metroline } from './MetroLine';
import { Station } from './Station';
import { TupleMap } from './tupleMap';
export declare class NodePositionsAdjuster {
    bundlingSettings: BundlingSettings;
    metroGraphData: MetroGraphData;
    constructor(metroGraphData: MetroGraphData, bundlingSettings: BundlingSettings);
    static FixRouting(metroGraphData: MetroGraphData, bundlingSettings: BundlingSettings): void;
    GlueConflictingNodes(): boolean;
    GetCirclesHierarchy(): RectangleNode<Station, Point>;
    GetCurrentHubRadius(node: Station): number;
    TryToGlueNodes(i: Station, j: Station, gluingMap: Map<Station, Station>, gluedDomain: Set<Station>): void;
    TryGlueOrdered(i: Station, j: Station, gluedDomain: Set<Station>, gluingMap: Map<Station, Station>): boolean;
    Map(i: Station, j: Station, gluedDomain: Set<Station>, gluingMap: Map<Station, Station>): void;
    NodeGluingIsAllowed(i: Station, j: Station, gluingMap: Map<Station, Station>): boolean;
    ComputeCostDeltaAfterNodeGluing(i: Station, j: Station, gluingMap: Map<Station, Station>): number;
    RegenerateEdge(gluingMap: Map<Station, Station>, edgeIndex: number): void;
    static GluedPolyline(metroline: Station[], gluedMap: Map<Station, Station>): Array<Point>;
    static Glued(i: Station, gluedMap: Map<Station, Station>): Station;
    ink: number;
    polylineLength: Map<Metroline, number>;
    UnglueEdgesFromBundleToSaveInk(alwaysExecuteSA: boolean): boolean;
    TrySeparateOnPolyline(metroline: Metroline, segsToPolylines: PointPairMap<Set<Metroline>>, affectedPoints: PointSet, obstaclesAllowedToIntersect: Set<Polyline>): boolean;
    TryShortcutPolypoint(pp: PolylinePoint, segsToPolylines: PointPairMap<Set<Metroline>>, affectedPoints: PointSet, obstaclesAllowedToIntersect: Set<Polyline>): boolean;
    SeparationShortcutAllowed(pp: PolylinePoint, segsToPolylines: PointPairMap<Set<Metroline>>, obstaclesAllowedToIntersect: Set<Polyline>): boolean;
    GetInkgain(pp: PolylinePoint, segsToPolylines: PointPairMap<Set<Metroline>>, a: Point, b: Point, c: Point): number;
    RemoveShortcuttedPolypoint(pp: PolylinePoint, segsToPolylines: PointPairMap<Set<Metroline>>): void;
    FindPolylines(pp: PolylinePoint, segsToPolylines: PointPairMap<Set<Metroline>>): [Set<Metroline>, Set<Metroline>, Set<Metroline>];
    RemovePolypoint(p: PolylinePoint): void;
    GlueCollinearNeighbors(step: number): boolean;
    GlueCollinearNeighborsSPN(node: Station, affectedPoints: PointSet, step: number): boolean;
    TryToGlueEdges(node: Station, a: Station, b: Station, gluedEdges: TupleMap<Station, Station, Point>, step: number): void;
    ConstructGluingPoint(node: Station, a: Station, b: Station): Point;
    EdgeGluingIsAllowedSSS(node: Station, a: Station, b: Station): boolean;
    EdgeGluingIsAllowedSSSP(node: Station, a: Station, b: Station, gluingPoint: Point): boolean;
    ComputeCostDeltaAfterEdgeGluing(node: Station, a: Station, b: Station, newp: Point): number;
    AddEdgeToGlue(node: Station, b: Station, a: Station, newp: Point, gluedEdges: TupleMap<Station, Station, Point>): void;
    GlueEdge(keyValuePair: [Station, Station, Point]): void;
    SplitPolylinePoint(node: PolylinePoint, pointToInsert: Point): void;
    RelaxConstrainedEdges(): boolean;
    RelaxConstrainedEdge(a: Station, b: Station, affectedPoints: PointSet): boolean;
    RemoveDoublePathCrossings(): boolean;
}
