import { BSplineCurve3d } from "../../bspline/BSplineCurve";
import { BSplineCurve3dH } from "../../bspline/BSplineCurve3dH";
import { RecurseToCurvesGeometryHandler } from "../../geometry3d/GeometryHandler";
import { Plane3dByOriginAndUnitNormal } from "../../geometry3d/Plane3dByOriginAndUnitNormal";
import { Point3d, Vector3d } from "../../geometry3d/Point3dVector3d";
import { Arc3d } from "../Arc3d";
import { CurveChainWithDistanceIndex } from "../CurveChainWithDistanceIndex";
import { CurveLocationDetailPair } from "../CurveLocationDetail";
import { AnyCurve } from "../CurveTypes";
import { GeometryQuery } from "../GeometryQuery";
import { LineSegment3d } from "../LineSegment3d";
import { LineString3d } from "../LineString3d";
/**
 * Handler class for XYZ intersections between _geometryB and another geometry.
 * * Instances are initialized and called from CurveCurve.
 * * geometryB is saved for later reference.
 * @internal
 */
export declare class CurveCurveIntersectXYZ extends RecurseToCurvesGeometryHandler {
    private _extendA0;
    private _extendA1;
    private _geometryB;
    private _extendB0;
    private _extendB1;
    private _results;
    private static _workVector2dA;
    private static _workPointAA0;
    private static _workPointAA1;
    private static _workPointBB0;
    private static _workPointBB1;
    /**
     * @param extendA flag to enable using extension of the other geometry.
     * @param geometryB second curve for intersection.  Saved for reference by specific handler methods.
     * @param extendB flag for extension of geometryB.
     */
    constructor(extendA: boolean, geometryB: AnyCurve, extendB: boolean);
    /** Reset the geometry, leaving all other parts unchanged (and preserving accumulated intersections). */
    resetGeometry(geometryB: AnyCurve): void;
    /**
     * Return the results structure for the intersection calculation, structured as an array of CurveLocationDetailPair.
     * @param reinitialize if true, a new results structure is created for use by later calls.
     */
    grabPairedResults(reinitialize?: boolean): CurveLocationDetailPair[];
    /** Accept the fraction if it falls inside (possibly extended) fraction range. */
    private acceptFraction;
    /**
     * Compute intersection of two line segments.
     * Filter by extension rules.
     * Reject if evaluated points do not match coordinates (e.g. close approach point).
     * Record with fraction mapping.
     */
    private recordPointWithLocalFractions;
    /**
     * Compute intersection of two line segments.
     * Filter by extension rules.
     * Record with fraction mapping.
     */
    private computeSegmentSegment3D;
    private dispatchSegmentSegment;
    /**
     * Create a plane whose normal is the "better" cross product: `vectorA.crossProduct(vectorB)` or
     * `vectorA.crossProduct(vectorC)`
     * * The heuristic for "better" is:
     *   * first choice is cross product with `vectorB`, if `vectorA` and `vectorB` are sufficiently far from parallel
     * (or anti-parallel).
     *   * otherwise use vectorC
     * @param origin plane origin
     * @param vectorA vector which must be in the plane.
     * @param cosineValue largest cosine of the angle theta between vectorA and vectorB to prefer their cross product, e.g.
     * passing 0.94 ~ cos(20deg) will switch to using vectorC in the cross product if theta < ~20deg or theta > ~160deg.
     * @param vectorB first candidate for additional in-plane vector
     * @param vectorC second candidate for additional in-plane vector
     */
    createPlaneWithPreferredPerpendicular(origin: Point3d, vectorA: Vector3d, cosineValue: number, vectorB: Vector3d, vectorC: Vector3d): Plane3dByOriginAndUnitNormal | undefined;
    private dispatchSegmentArc;
    private dispatchArcArcInPlane;
    private dispatchArcArc;
    private dispatchArcBsplineCurve3d;
    private dispatchBSplineCurve3dBSplineCurve3d;
    private dispatchSegmentBsplineCurve;
    /** Low level dispatch of linestring with (beziers of) a bspline curve */
    dispatchLineStringBSplineCurve(_lsA: LineString3d, _extendA0: boolean, _extendA1: boolean, _curveB: BSplineCurve3d, _extendB0: boolean, _extendB1: boolean, _reversed: boolean): any;
    /** Detail computation for segment intersecting linestring. */
    computeSegmentLineString(lsA: LineSegment3d, extendA0: boolean, extendA1: boolean, lsB: LineString3d, extendB0: boolean, extendB1: boolean, reversed: boolean): any;
    /** Detail computation for arc intersecting linestring. */
    computeArcLineString(arcA: Arc3d, extendA0: boolean, extendA1: boolean, lsB: LineString3d, extendB0: boolean, extendB1: boolean, reversed: boolean): any;
    /** Detail computation for linestring intersecting linestring. */
    private computeLineStringLineString;
    /**
     * Low level dispatch of curve collection.
     * We take care of extend variables of geometry's children here if geometry is Path or Loop.
     */
    private dispatchCurveCollection;
    /**
     * Low level dispatch of CurveChainWithDistanceIndex.
     * We take care of extend variables of geometry's children here if geometry.path is Path or Loop.
     */
    private dispatchCurveChainWithDistanceIndex;
    /**
   * Invoke `child.dispatchToGeometryHandler(this)` for each child in the array returned by the query `g.children`.
   * We take care of extend variables of geometry's children here if geometry is Path or Loop.
   */
    handleChildren(g: GeometryQuery): any;
    /** Double dispatch handler for strongly typed segment. */
    handleLineSegment3d(segmentA: LineSegment3d): any;
    /** double dispatch handler for strongly typed linestring. */
    handleLineString3d(lsA: LineString3d): any;
    /** Double dispatch handler for strongly typed arc. */
    handleArc3d(arc0: Arc3d): any;
    /** Double dispatch handler for strongly typed bspline curve. */
    handleBSplineCurve3d(curve: BSplineCurve3d): any;
    /** Double dispatch handler for strongly typed CurveChainWithDistanceIndex. */
    handleCurveChainWithDistanceIndex(chain: CurveChainWithDistanceIndex): any;
    /** Double dispatch handler for strongly typed homogeneous bspline curve. */
    handleBSplineCurve3dH(_curve: BSplineCurve3dH): any;
}
//# sourceMappingURL=CurveCurveIntersectXYZ.d.ts.map