/**
 * Semi-implicit Euler velocity integration for a single rigid body.
 *
 * For Dynamic bodies:
 *  - gravity (scaled by `gravityScale`) and the accumulated force are converted
 *    to a velocity delta via `1/mass`,
 *  - accumulated torque is converted to angular acceleration via the
 *    world-frame inverse inertia (R · diag(I_local) · R^T applied to τ),
 *  - linear and angular damping are applied as a stable implicit decay
 *    `v *= 1 / (1 + d·dt)` (Box2D / Bullet recipe — never goes negative, no
 *    `exp()` call on the hot path),
 *  - the force / torque accumulators are zeroed afterwards.
 *
 * Kinematic and Static bodies are skipped — their velocity is the
 * user / animation system's responsibility.
 *
 * @param {RigidBody} rb
 * @param {Transform} transform  used to rotate body-frame inertia into world
 * @param {number} gx world gravity x
 * @param {number} gy world gravity y
 * @param {number} gz world gravity z
 * @param {number} dt step size in seconds
 */
export function integrate_velocity(rb: RigidBody, transform: Transform, gx: number, gy: number, gz: number, dt: number): void;
/**
 * Apply the accumulated force / torque to velocity over a step `dt`, then
 * zero the accumulators. Gravity and damping are NOT applied here.
 *
 * The "once per outer step" half of the TGS integrator: a user force is a
 * per-frame budget that must land in full exactly once, independent of
 * substep count. Gravity is the continuous field re-applied every substep
 * by {@link integrate_velocity_gravity}.
 *
 * @param {RigidBody} rb
 * @param {Transform} transform  used to rotate body-frame inertia into world
 * @param {number} dt full outer-step size in seconds
 */
export function integrate_velocity_forces(rb: RigidBody, transform: Transform, dt: number): void;
/**
 * Apply gravity and velocity damping over a (sub)step `dt`. Does NOT touch
 * the force / torque accumulators (consumed once by
 * {@link integrate_velocity_forces}).
 *
 * The "every substep" half of the TGS integrator. Per substep the body sees
 * only `g·h` of gravity, which the per-substep contact warm-start + solve
 * cancels exactly — keeping a resting stack at zero velocity. Damping is the
 * stable implicit decay `v *= 1/(1 + d·dt)` applied at the substep `dt`.
 *
 * Velocity (and the damping it applies) lives in the data-oriented
 * {@link SolverBodyState} for the duration of the substep loop; this reads and
 * writes that span by `base`. The body's configuration (kind / gravityScale /
 * damping coefficients) is still read from the `RigidBody` — cheap, once per
 * body per substep, and unchanged across the step.
 *
 * @param {Float64Array} ss solver-body-state data array
 * @param {number} base `body_index * SBS_STRIDE`
 * @param {RigidBody} rb
 * @param {number} gx
 * @param {number} gy
 * @param {number} gz world gravity
 * @param {number} dt sub-step size in seconds
 */
export function integrate_velocity_gravity(ss: Float64Array, base: number, rb: RigidBody, gx: number, gy: number, gz: number, dt: number): void;
//# sourceMappingURL=integrate_velocity.d.ts.map