import '../../../assert/js/assert.js';
import '../../../globals.js';
/**
 * A region of two segments that intersects (contains static functions for segment intersection).
 *
 * BoundsIntersection.intersect( a, b ) should be used for most general intersection routines as a fallback.
 * Other segment-specific routines may be much faster.
 *
 * @author Jonathan Olson <jonathan.olson@colorado.edu>
 */
import Vector2 from '../../../dot/js/Vector2.js';
import Pool from '../../../phet-core/js/Pool.js';
import { Segment, SegmentIntersection } from '../imports.js';
export default class BoundsIntersection {
    a: Segment | null;
    b: Segment | null;
    atMin: number;
    atMax: number;
    btMin: number;
    btMax: number;
    aMin: Vector2 | null;
    aMax: Vector2 | null;
    bMin: Vector2 | null;
    bMax: Vector2 | null;
    /**
     * @param a
     * @param b
     * @param atMin - Lower t value for the region of the 'a' segment
     * @param atMax - Higher t value for the region of the 'a' segment
     * @param btMin - Lower t value for the region of the 'b' segment
     * @param btMax - Higher t value for the region of the 'b' segment
     * @param aMin - Location of the lower t value for the 'a' segment's region
     * @param aMax - Location of the higher t value for the 'a' segment's region
     * @param bMin - Location of the lower t value for the 'b' segment's region
     * @param bMax - Location of the higher t value for the 'b' segment's region
     */
    constructor(a: Segment, b: Segment, atMin: number, atMax: number, btMin: number, btMax: number, aMin: Vector2, aMax: Vector2, bMin: Vector2, bMax: Vector2);
    /**
     * @param a
     * @param b
     * @param atMin - Lower t value for the region of the 'a' segment
     * @param atMax - Higher t value for the region of the 'a' segment
     * @param btMin - Lower t value for the region of the 'b' segment
     * @param btMax - Higher t value for the region of the 'b' segment
     * @param aMin - Location of the lower t value for the 'a' segment's region
     * @param aMax - Location of the higher t value for the 'a' segment's region
     * @param bMin - Location of the lower t value for the 'b' segment's region
     * @param bMax - Location of the higher t value for the 'b' segment's region
     * @returns -  This reference for chaining
     */
    initialize(a: Segment, b: Segment, atMin: number, atMax: number, btMin: number, btMax: number, aMin: Vector2, aMax: Vector2, bMin: Vector2, bMax: Vector2): BoundsIntersection;
    /**
     * Handles subdivision of the regions into 2 for the 'a' segment and 2 for the 'b' segment, then pushes any
     * intersecting bounding box regions (between 'a' and 'b') to the array.
     */
    private pushSubdivisions;
    /**
     * A measure of distance between this and another intersection.
     */
    distance(otherIntersection: BoundsIntersection): number;
    /**
     * Removes references (so it can allow other objects to be GC'ed or pooled)
     */
    clean(): void;
    /**
     * Determine (finite) points of intersection between two arbitrary segments.
     *
     * Does repeated subdivision and excludes a-b region pairs that don't intersect. Doing this repeatedly narrows down
     * intersections, to the point that they can be combined for a fairly accurate answer.
     */
    static intersect(a: Segment, b: Segment): SegmentIntersection[];
    /**
     * Given two segments, returns an array of candidate intersection ranges.
     */
    private static getIntersectionRanges;
    /**
     * Given the endpoints of two monotone segment regions, returns whether their bounding boxes intersect.
     */
    private static boxIntersects;
    /**
     * Since we'll burn through a lot of pooled instances, we only remove external references fully once the full
     * process is done.
     */
    private static cleanPool;
    freeToPool(): void;
    static readonly pool: Pool<typeof BoundsIntersection>;
}
//# sourceMappingURL=BoundsIntersection.d.ts.map