import { type ConstraintImpulseState4, type ConstraintRow4 } from './constraint-row4.js';
export type ConstraintBlockRankPolicy4 = 'reject' | 'minimum-norm';
export type ConstraintBlockProjection4 = {
    readonly kind: 'equality';
} | {
    readonly kind: 'one-bounded';
};
/** One coupled block of one to six rigid-Jacobian rows. */
export interface ConstraintBlock4 {
    /** Must be unique within a solver; persistent IDs retain warm impulses. */
    readonly id: string;
    readonly rows: readonly ConstraintRow4[];
    /** Equality by default; bounded projection must be requested explicitly. */
    readonly projection?: ConstraintBlockProjection4;
}
export interface ConstraintBlockSolver4Options {
    /** Block Gauss--Seidel passes. Default 8. */
    readonly iterations?: number;
    /** Fraction of the block-error norm corrected per step. Default 0.2. */
    readonly baumgarte?: number;
    /** Block-error norm ignored by velocity-level bias. Default 0.001. */
    readonly positionSlop?: number;
    /** Upper bound on the complete bias-vector norm. Default 2. */
    readonly maxBiasSpeed?: number;
    /** Apply coherent impulses retained from the previous solve. Default true. */
    readonly warmStart?: boolean;
    /** Relative eigenvalue threshold against `trace(K) / k`. Default 1e-10. */
    readonly rankTolerance?: number;
    /** Refuse rank loss by default; minimum-norm solving must be explicit. */
    readonly rankPolicy?: ConstraintBlockRankPolicy4;
}
export interface ConstraintBlockResult4 {
    readonly id: string;
    readonly rowCount: number;
    readonly projection: ConstraintBlockProjection4['kind'];
    /** Row-major `J M^-1 J^T`. */
    readonly response: Float64Array;
    /** Row-major inverse or explicitly requested spectral pseudoinverse. */
    readonly effectiveMass: Float64Array;
    readonly responseEigenvalues: Float64Array;
    readonly rankThreshold: number;
    readonly effectiveRank: number;
    readonly initialPositionError: Float64Array;
    readonly initialSpeed: Float64Array;
    readonly velocityTarget: Float64Array;
    readonly biasSpeed: Float64Array;
    readonly targetSpeed: Float64Array;
    readonly warmStartedImpulse: Float64Array;
    readonly accumulatedImpulse: Float64Array;
    readonly finalSpeed: Float64Array;
    readonly residualSpeed: Float64Array;
    readonly residualNorm: number;
    /** Norm of residuals in the unbounded equality subspace. */
    readonly equalityResidualNorm: number;
    readonly boundedCoordinate: ConstraintBlockBoundedCoordinateResult4 | null;
}
export interface ConstraintBlockBoundedCoordinateResult4 {
    readonly rowIndex: number;
    /** Scalar response after eliminating the equality coordinates. */
    readonly schurResponse: number;
    readonly minForce: number;
    readonly maxForce: number;
    readonly minImpulse: number;
    readonly maxImpulse: number;
    readonly impulseState: ConstraintImpulseState4;
    /** Reduced projected fixed-point residual; zero is the bounded KKT condition. */
    readonly projectedResidualSpeed: number;
}
export interface ConstraintBlockSolveResult4 {
    readonly blocks: readonly ConstraintBlockResult4[];
    readonly retiredIds: readonly string[];
    readonly iterations: number;
    /** Sum of Euclidean coordinate-impulse norms; diagnostic only. */
    readonly sumCoordinateImpulseNorms: number;
    readonly maxResidualNorm: number;
    readonly maxEqualityResidualNorm: number;
    readonly maxProjectedResidualSpeed: number;
    readonly maxPositionErrorNorm: number;
}
/**
 * Warm-started block solver for one to six R4 rigid-Jacobian rows.
 *
 * Bias limiting and warm-start projection operate on the complete coordinate
 * vector for equality blocks. A `one-bounded` block exactly eliminates its
 * equality subspace before projecting the one force-limited coordinate.
 */
export declare class ConstraintBlockSolver4 {
    readonly iterations: number;
    readonly baumgarte: number;
    readonly positionSlop: number;
    readonly maxBiasSpeed: number;
    readonly warmStart: boolean;
    readonly rankTolerance: number;
    readonly rankPolicy: ConstraintBlockRankPolicy4;
    private cache;
    constructor(options?: ConstraintBlockSolver4Options);
    solve(blocks: readonly ConstraintBlock4[], dt: number): ConstraintBlockSolveResult4;
    reset(): void;
    private prepare;
    private applyWarmStart;
    private solveBlock;
}
/** Row-major symmetric response for coherent R4 rigid-Jacobian rows. */
export declare function constraintBlockResponseMatrix4(rows: readonly ConstraintRow4[]): Float64Array;
//# sourceMappingURL=constraint-block4.d.ts.map