/**
 * Apply the world-frame inverse inertia tensor of a rigid body to a world-space
 * vector and write the result.
 *
 * Body-frame inverse inertia is supplied as a diagonal in principal axes
 * (a Vector3-like with `.x .y .z`). World inverse inertia is
 * `I_w⁻¹ = R · diag · R^T` where `R` is the body's orientation. We compute
 * `result = R · diag · R^T · v` without materialising the full 3x3 matrix:
 *
 *   1. `v_body = R^T · v`   (rotate v into body frame)
 *   2. scale component-wise by the diagonal
 *   3. `result = R · v_body_scaled`
 *
 * Quaternion-rotate-vector uses the standard `q · v · q*` identity. Inverse
 * rotation uses the conjugate quaternion.
 *
 * Sphere short-circuit: if the inverse inertia is isotropic (ix === iy === iz),
 * the rotation cancels and `result = ix * v`. Skip the trig and save the work.
 *
 * Decoupled from RigidBody / Transform on purpose — callers pass only what
 * is actually read. Lets `compute_penetration` and other standalone
 * geometry helpers reuse this without manufacturing a body.
 *
 * @param {number[]|Float64Array} result length >= 3
 * @param {number} result_offset
 * @param {{x: number, y: number, z: number}} inv_inertia_local
 *        Body-frame inverse inertia diagonal (typically `rb.inverseInertiaLocal`).
 * @param {{x: number, y: number, z: number, w: number}} rotation
 *        Body orientation as a unit quaternion (typically `transform.rotation`).
 * @param {number} vx
 * @param {number} vy
 * @param {number} vz
 */
export function world_inverse_inertia_apply(result: number[] | Float64Array, result_offset: number, inv_inertia_local: {
    x: number;
    y: number;
    z: number;
}, rotation: {
    x: number;
    y: number;
    z: number;
    w: number;
}, vx: number, vy: number, vz: number): void;
/**
 * Raw-float counterpart of {@link world_inverse_inertia_apply}: the same
 * `I_w⁻¹ = R · diag · R^T` application, with the inverse-inertia diagonal and
 * orientation quaternion passed as scalars rather than read off
 * `{x,y,z}` / `{x,y,z,w}` objects. The data-oriented contact / joint solver
 * reads these straight out of its `SolverBodyState` typed array, avoiding the
 * per-impulse object dereference on the hot path. The arithmetic is identical
 * to the object version (same operation order), so results are bit-identical.
 *
 * @param {number[]|Float64Array} result length >= 3
 * @param {number} result_offset
 * @param {number} ix
 * @param {number} iy
 * @param {number} iz Body-frame inverse inertia diagonal.
 * @param {number} qx
 * @param {number} qy
 * @param {number} qz
 * @param {number} qw Body orientation as a unit quaternion.
 * @param {number} vx
 * @param {number} vy
 * @param {number} vz
 */
export function world_inverse_inertia_apply_raw(result: number[] | Float64Array, result_offset: number, ix: number, iy: number, iz: number, qx: number, qy: number, qz: number, qw: number, vx: number, vy: number, vz: number): void;
//# sourceMappingURL=world_inverse_inertia.d.ts.map