export default DelaunayTriangulation;
declare class DelaunayTriangulation {
    /**
     * Comparison for sorting points by y, then by x.
     * @private
     *
     * TODO: Do we need to reverse the x sort? "If our edge is horizontal, the ending point with smaller x coordinate https://github.com/phetsims/dot/issues/96
     *       is considered as the upper point"?
     *
     * @param {Vertex} a
     * @param {Vertex} b
     * @returns {number}
     */
    private static vertexComparison;
    /**
     * Returns the cross product of (aVertex-sharedVertex) and (bVertex-sharedVertex)
     * @private
     *
     * @param {Vertex} sharedVertex
     * @param {Vertex} aVertex
     * @param {Vertex} bVertex
     * @returns {number}
     */
    private static vertexProduct;
    /**
     * @public
     *
     * @param {Array.<Vector2>} points
     * @param {Array.<Array.<number>>} constraints - Pairs of indices into the points that should be treated as
     *                                               constrained edges.
     * @param {Object} [options]
     */
    constructor(points: Array<Vector2>, constraints: Array<Array<number>>, options?: Object | undefined);
    points: Vector2[];
    constraints: number[][];
    triangles: any[];
    edges: any[];
    convexHull: any[];
    vertices: any[] | undefined;
    bottomVertex: any;
    remainingVertices: any[] | undefined;
    artificialMinVertex: any;
    artificialMaxVertex: any;
    firstFrontEdge: any;
    firstHullEdge: any;
    /**
     * Moves the triangulation forward by a vertex.
     * @private
     */
    private step;
    /**
     * Builds a triangle between two vertices.
     * @private
     *
     * @param {Edge} firstEdge
     * @param {Edge} secondEdge
     * @param {Vertex} firstSideVertex
     * @param {Vertex} middleVertex
     * @param {Vertex} secondSideVertex
     * @returns {Edge} - The newly created edge
     */
    private fillBorderTriangle;
    /**
     * Disconnects a section of front edges, and connects a new section.
     * @private
     *
     * Disconnects:
     * <nextEdge> (cut) <oldLeftEdge> ..... <oldRightEdge> (cut) <previousEdge>
     *
     * Connects:
     * <nextEdge> (join) <newLeftEdge> ..... <newRightEdge> (join) <previousEdge>
     *
     * If previousEdge is null, we'll need to set our firstFrontEdge to the newRightEdge.
     *
     * @param {Edge} oldRightEdge
     * @param {Edge} oldLeftEdge
     * @param {Edge} newRightEdge
     * @param {Edge} newLeftEdge
     */
    private reconnectFrontEdges;
    /**
     * Tries to fill in acute angles with triangles after we add a vertex into the front.
     * @private
     *
     * @param {Edge} rightFrontEdge
     * @param {Edge} leftFrontEdge
     */
    private addHalfPiHeuristic;
    /**
     * Handles any "edge events" that delete intersecting edges, creating the new edge, and filling in (all only if
     * necessary).
     * @private
     *
     * @param {Vertex} vertex
     * @param {Edge} rightFrontEdge
     * @param {Edge} leftFrontEdge
     */
    private constrainEdges;
    /**
     * Creates edges/triangles to triangulate a simple polygon.
     * @private
     *
     * @param {Array.<Edge>} edges - Should be in counterclockwise order
     */
    private triangulatePolygon;
    /**
     * Should be called when there are no more remaining vertices left to be processed.
     * @private
     */
    private finalize;
    /**
     * Checks an edge to see whether its two adjacent triangles satisfy the delaunay condition (the far point of one
     * triangle should not be contained in the other triangle's circumcircle), and if it is not satisfied, flips the
     * edge so the condition is satisfied.
     * @private
     *
     * @param {Edge} edge
     */
    private legalizeEdge;
}
import Vector2 from './Vector2.js';
//# sourceMappingURL=DelaunayTriangulation.d.ts.map