/** @packageDocumentation
 * @module Bspline
 */
import { Point3d } from "../geometry3d/Point3dVector3d";
import { BSplineWrapMode, KnotVector } from "./KnotVector";
/**
 * Knots and poles for a B-spline function mapping R to R^n.
 * * The "pole" (aka control point) of this class is a block of `poleLength` numbers.
 * * Derived classes (not this class) assign meaning such as x,y,z,w.
 * * For instance, an instance of this class with `poleLength===3` does not know if its poles are x,y,z or
 * weighted 2D x,y,w.
 * @public
 */
export declare class BSpline1dNd {
    /** Knots of the bspline. */
    knots: KnotVector;
    /** Poles packed in blocks of `poleLength` doubles. */
    packedData: Float64Array;
    /** The number of numeric values per pole. */
    poleLength: number;
    /** (property accessor) Return the degree of the polynomials. */
    get degree(): number;
    /** (property accessor) Return the order (one more than degree) of the polynomials. */
    get order(): number;
    /** (property accessor) Return the number of bezier spans (including null spans at multiple knots). */
    get numSpan(): number;
    /** (property accessor) Return the number of poles. */
    get numPoles(): number;
    /**
     * Copy 3 values of pole `i` into a point.
     * * The calling class is responsible for knowing if this is an appropriate access to the blocked data.
     */
    getPoint3dPole(i: number, result?: Point3d): Point3d | undefined;
    /**
     * Values of the `order` relevant B-spline basis functions at a parameter.
     * * Preallocated to length `order` in the constructor and used as a temporary in evaluations.
     */
    basisBuffer: Float64Array;
    /**
     * Derivatives of the `order` relevant B-spline basis functions at a parameter.
     * * Preallocated to length `order` in the constructor and used as a temporary in evaluations.
     */
    basisBuffer1: Float64Array;
    /**
     * Second derivatives of the `order` relevant B-spline basis functions at a parameter.
     * * Preallocated to length `order` in the constructor and used as a temporary in evaluations.
     */
    basisBuffer2: Float64Array;
    /**
     * Temporary to hold a single point.
     * * Preallocated to length `poleLength` in the constructor.
     */
    poleBuffer: Float64Array;
    /**
     * Temporary to hold a single derivative vector.
     * * Preallocated to length `poleLength` in the constructor.
     */
    poleBuffer1: Float64Array;
    /**
     * Temporary to hold a single second derivative vector.
     * * Preallocated to length `poleLength` in the constructor.
     */
    poleBuffer2: Float64Array;
    /**
     * Initialize arrays for given spline dimensions.
     * @param numPoles number of poles.
     * @param poleLength number of coordinates per pole (e.g.. 3 for 3D unweighted, 4 for 3d weighted, 2 for 2d unweighted,
     * 3 for 2d weighted).
     * @param order number of poles defining a Bezier segment of the B-spline function.
     * @param knots the KnotVector. This is captured, not cloned.
     */
    protected constructor(numPoles: number, poleLength: number, order: number, knots: KnotVector);
    /**
     * Create a `BSpline1dNd`.
     * @param numPoles number of poles.
     * @param poleLength number of coordinates per pole (e.g.. 3 for 3D unweighted, 4 for 3d weighted, 2 for 2d unweighted,
     * 3 for 2d weighted).
     * @param order number of poles defining a Bezier segment of the B-spline function.
     * @param knots the KnotVector. This is captured, not cloned.
     */
    static create(numPoles: number, poleLength: number, order: number, knots: KnotVector): BSpline1dNd;
    /** Map a span index and span fraction to knot value. */
    spanFractionToKnot(spanIndex: number, spanFraction: number): number;
    /**
     * Evaluate the `order` basis functions (and optionally one or two derivatives) at a given fractional position within
     * indexed span.
     * @returns true if and only if output arrays are sufficiently sized.
    */
    evaluateBasisFunctionsInSpan(spanIndex: number, spanFraction: number, f: Float64Array, df?: Float64Array, ddf?: Float64Array): boolean;
    /**
     * Compute the linear combination of the given span's poles and the weights in `basisBuffer`, and store this point
     * in `poleBuffer`.
     */
    sumPoleBufferForSpan(spanIndex: number): void;
    /**
     * Compute the linear combination of the given span's poles and the weights in `basisBuffer1`, and store this
     * derivative vector in `poleBuffer1`.
     */
    sumPoleBuffer1ForSpan(spanIndex: number): void;
    /**
     * Compute the linear combination of the given span's poles and the weights in `basisBuffer2`, and store this
     * second derivative vector in `poleBuffer2`.
     */
    sumPoleBuffer2ForSpan(spanIndex: number): void;
    /**
     * * Evaluate the basis functions at spanIndex and fraction.
     *   * Evaluations are stored in the preallocated `this.basisBuffer`.
     * * Immediately do the summations of the basis values times the respective poles.
     *   * Summations are stored in the preallocated `this.poleBuffer`
     * */
    evaluateBuffersInSpan(spanIndex: number, spanFraction: number): void;
    /**
     * * Evaluate the basis functions and one derivative at spanIndex and fraction.
     *   * Function evaluations are stored in the preallocated `this.basisBuffer`; derivative evaluations in `this.basisBuffer1`.
     * * Immediately do the summations of the basis values times the respective poles.
     *   * Summations are stored in the preallocated `this.poleBuffer` and `this.poleBuffer1`
     * */
    evaluateBuffersInSpan1(spanIndex: number, spanFraction: number): void;
    /**
     * Evaluate the B-spline function and optional derivatives at the given parameter in knot space.
     * * Function value is stored in `poleBuffer`; optional derivative vectors in `poleBuffer1` and `poleBuffer2`.
     */
    evaluateBuffersAtKnot(u: number, numDerivative?: number): void;
    /** Reverse the instance poles and knots in place. */
    reverseInPlace(): void;
    /**
     * Test if the leading and trailing polygon coordinates are replicated in the manner of a "closed" bspline polygon
     * which has been expanded to act as a normal bspline.
     * @returns true if `degree` leading and trailing polygon blocks match.
     * @deprecated in 4.2.1 - will not be removed until after 2026-06-13. Use `testClosablePolygon` instead.
     */
    testCloseablePolygon(mode?: BSplineWrapMode): boolean;
    /**
     * Test if the leading and trailing poles are replicated in the manner of a "closed" B-spline function with wraparound
     * control polygon.
     * @param mode wrap mode, indicating the number of wraparound poles to check. If undefined, `knots.wrappable` is used.
     * @returns true if the expected leading and trailing poles match, according to `mode`.
     */
    testClosablePolygon(mode?: BSplineWrapMode): boolean;
    /**
     * Insert the knot and resulting pole into the instance, optionally multiple times.
     * @param knot the knot to be inserted (may already exist in the KnotVector).
     * @param totalMultiplicity the total multiplicity of the knot on return.
     */
    addKnot(knot: number, totalMultiplicity: number): boolean;
}
//# sourceMappingURL=BSpline1dNd.d.ts.map