export default Face;
declare class Face {
    static pool: Pool<typeof Face>;
    /**
     * @public (kite-internal)
     *
     * NOTE: Use Face.pool.create for most usage instead of using the constructor directly.
     *
     * @param {Boundary|null} boundary - Null if it's the unbounded face
     */
    constructor(boundary: Boundary | null);
    id: number;
    /**
     * Similar to a usual constructor, but is set up so it can be called multiple times (with dispose() in-between) to
     * support pooling.
     * @private
     *
     * @param {Boundary} boundary
     * @returns {Face} - This reference for chaining
     */
    private initialize;
    boundary: any;
    holes: any;
    windingMap: any;
    filled: any;
    /**
     * Returns an object form that can be turned back into a segment with the corresponding deserialize method.
     * @public
     *
     * @returns {Object}
     */
    public serialize(): Object;
    /**
     * Removes references (so it can allow other objects to be GC'ed or pooled), and frees itself to the pool so it
     * can be reused.
     * @public
     */
    public dispose(): void;
    /**
     * Marks all half-edges on the boundary as belonging to this face.
     * @public
     *
     * @param {Boundary} boundary
     */
    public addBoundaryFaceReferences(boundary: Boundary): void;
    /**
     * Processes the boundary-graph for a given outer boundary, and turns it into holes for this face.
     * @public
     *
     * In the graph, every outer boundary in each connected component will be holes for the single inner boundary
     * (which will be, in this case, our face's boundary). Since it's a tree, we can walk the tree recursively to add
     * all necessary holes.
     *
     * @param {Boundary} outerBoundary
     */
    public recursivelyAddHoles(outerBoundary: Boundary): void;
    freeToPool(): void;
}
import Pool from '../../../phet-core/js/Pool.js';
//# sourceMappingURL=Face.d.ts.map