/** @packageDocumentation
 * @module Curve
 */
import { IStrokeHandler } from "../../geometry3d/GeometryHandler";
import { Point3d, Vector3d } from "../../geometry3d/Point3dVector3d";
import { VariantCurveExtendParameter } from "../CurveExtendMode";
import { CurveLocationDetail } from "../CurveLocationDetail";
import { CurvePrimitive } from "../CurvePrimitive";
import { NewtonRtoRStrokeHandler } from "./NewtonRtoRStrokeHandler";
/**
 * Context for searching for the closest point to a CurvePrimitive.
 * @internal
 */
export declare class ClosestPointStrokeHandler extends NewtonRtoRStrokeHandler implements IStrokeHandler {
    private _curve;
    private _closestPoint;
    private _spacePoint;
    private _extend;
    private _fractionA;
    private _functionA;
    private _fractionB;
    private _functionB;
    private _numThisCurve;
    private _workPoint;
    private _workRay;
    private _newtonSolver;
    /** Constructor */
    constructor(spacePoint: Point3d, extend?: VariantCurveExtendParameter, result?: CurveLocationDetail);
    claimResult(): CurveLocationDetail | undefined;
    needPrimaryGeometryForStrokes(): boolean;
    startCurvePrimitive(curve: CurvePrimitive | undefined): void;
    endCurvePrimitive(): void;
    announceIntervalForUniformStepStrokes(cp: CurvePrimitive, numStrokes: number, fraction0: number, fraction1: number): void;
    private announceCandidate;
    announceSegmentInterval(cp: CurvePrimitive, point0: Point3d, point1: Point3d, _numStrokes: number, fraction0: number, fraction1: number): void;
    /**
     * Given a function `f` and (unordered) fractions `a` and `b`, search for and announce a root of `f` in this
     * fractional interval.
     * * This method searches for a root of `f` if and only if the stroke segment defined by `(a, f(a))` and
     * `(b, f(b))` has a root. This is a HEURISTIC: given continuous `f` between `a` and `b`, a root of the stroke
     * segment implies a root of `f`, but not vice-versa. Therefore, if the strokes are not sufficiently dense,
     * this method can miss a root of `f`.
     */
    private searchInterval;
    private announceSolutionFraction;
    /**
     * Evaluate the univariate real-valued function for which we are finding roots.
     * * For finding the closest point to curve X from point Q, this function is `f(t) := Q-X(t) dot X'(t)`.
     * * Either `pointAndDerivative` must be defined, or both `fraction` and `curve`.
     * @param pointAndDerivative pre-evaluated curve
     * @param fraction fraction at which to evaluate `curve`
     * @param curve curve to evaluate at `fraction`
     */
    private evaluateFunction;
    evaluate(fraction: number): boolean;
    private announceRay;
    announcePointTangent(point: Point3d, fraction: number, tangent: Vector3d): void;
}
//# sourceMappingURL=ClosestPointStrokeHandler.d.ts.map