/**
 * Why an exact point--simplex decision could not be published as finite
 * Float64 evidence.
 *
 * Exact arithmetic is an implementation detail.  Callers receive one
 * coherent Float64 witness plus outward-rounded Float64 error bounds.
 */
export type PointSimplexPublicationReason = 'weight-underflow' | 'value-overflow' | 'value-underflow' | 'accuracy-bound-overflow';
interface PointSimplexCommonErrorBounds {
    /** Absolute error bound for each source-ordered barycentric weight. */
    readonly weightAbsoluteErrorBound: readonly number[];
    /** Absolute error bound for each coordinate of the published point. */
    readonly pointAbsoluteErrorBound: readonly number[];
    /** Absolute error bound for the published squared distance. */
    readonly squaredDistanceErrorBound: number;
}
/** Error evidence for an exact-zero point--simplex result. */
export interface PointSimplexZeroErrorBounds extends PointSimplexCommonErrorBounds {
}
/** Error evidence for a positive point--simplex distance. */
export interface PointSimplexProjectedErrorBounds extends PointSimplexCommonErrorBounds {
    /** Euclidean error radius enclosing the published unit direction. */
    readonly directionErrorBound: number;
}
/** Coherent Float64 witness for an exact-zero result. */
export interface PointSimplexZeroWitness {
    /** Source-ordered barycentric weights, summing to one in Float64. */
    readonly weights: readonly number[];
    /** Permutation-invariant residual-weight anchor slot. */
    readonly anchorSlot: number;
    /** Point reconstructed from `weights` by the documented affine algorithm. */
    readonly point: readonly number[];
}
/** Coherent Float64 witness for a positive point--simplex distance. */
export interface PointSimplexProjectedWitness extends PointSimplexZeroWitness {
    /** Euclidean distance derived from the published displacement. */
    readonly distance: number;
    /** Squared Euclidean distance derived from the published displacement. */
    readonly squaredDistance: number;
    /** Unit direction from the published simplex point toward the query point. */
    readonly direction: readonly number[];
}
/** Certified positive-distance projection. */
export interface PointSimplexProjectedResult {
    /** Positive exact distance with a successfully published Float64 witness. */
    readonly status: 'projected';
    /** Exact affine rank of the supplied Float64 simplex. */
    readonly exactRank: number;
    /** Slots whose exact barycentric weights are strictly positive. */
    readonly activeSlots: readonly number[];
    /** Coherent Float64 closest-point, distance, and direction evidence. */
    readonly witness: PointSimplexProjectedWitness;
    /** Outward absolute error bounds for every published approximation. */
    readonly error: PointSimplexProjectedErrorBounds;
}
/** Certified exact-zero projection. */
export interface PointSimplexZeroResult {
    /** Exact zero distance with a successfully published Float64 witness. */
    readonly status: 'zero';
    /** Exact affine rank of the supplied Float64 simplex. */
    readonly exactRank: number;
    /** Slots whose exact barycentric weights are strictly positive. */
    readonly activeSlots: readonly number[];
    /** Coherent Float64 point and barycentric source-coordinate evidence. */
    readonly witness: PointSimplexZeroWitness;
    /** Outward absolute error bounds for every published approximation. */
    readonly error: PointSimplexZeroErrorBounds;
}
/** The supplied simplex is exactly affine-rank deficient. */
export interface PointSimplexRankDeficientResult {
    /** The supplied vertices do not span the simplex dimension they claim. */
    readonly status: 'rank-deficient';
    /** Exact affine rank of the supplied Float64 vertices. */
    readonly exactRank: number;
}
/** The exact decision exists but cannot be published by this Float64 surface. */
export interface PointSimplexUncertifiedResult {
    /** The exact decision cannot be represented by the supported Float64 surface. */
    readonly status: 'uncertified';
    /** Exact affine rank, already proved full before publication failed. */
    readonly exactRank: number;
    /** Machine-readable recovery class for the failed publication. */
    readonly reason: PointSimplexPublicationReason;
    /** Human-readable location and mechanism of the failed publication. */
    readonly detail: string;
}
/** Complete result of an exact-on-supplied-Float64 point--simplex query. */
export type PointSimplexResult = PointSimplexProjectedResult | PointSimplexZeroResult | PointSimplexRankDeficientResult | PointSimplexUncertifiedResult;
/**
 * Evaluate a point against a nondegenerate simplex exactly on the supplied
 * Float64 geometry.
 *
 * Exact dyadic arithmetic decides affine rank, the closest active face, and
 * whether the distance is zero.  A successful result contains one coherent
 * Float64 witness: its point, distance, and direction are all derived from the
 * same published barycentric weights.  Every accuracy field is rounded
 * outward, and every returned object and array is frozen.  Caller-owned inputs
 * are neither frozen nor mutated.
 *
 * This is deliberately not a generic simplex-pair query and has no tolerance
 * knobs. It supports simplex dimensions 1 through 3 in ambient R1 or higher.
 */
export declare function evaluateExactPointSimplexResult(point: ArrayLike<number>, simplex: ArrayLike<number>, dimension: number): PointSimplexResult;
export {};
//# sourceMappingURL=exact-point-simplex-distance.d.ts.map