import type { Euler, EulerOrder, Mat3Like, Quat, QuatLike } from './types'; export type { Euler, EulerOrder }; /** Create an Euler, defaulting to (0, 0, 0, 'XYZ'). */ export declare function create(): Euler; /** Allocate a new Euler copy. */ export declare function clone(a: Euler): Euler; /** out.x/y/z/order = inputs; returns out (in-place). */ export declare function set(out: Euler, x: number, y: number, z: number, order: EulerOrder): Euler; /** * out (Quat) = quaternion from euler. Returns out. * * Routes directly to quat.fromEuler (D-P2 + 6-order coverage already implemented inside quat). * * @example * ```ts * euler.toQuat(quatBuf, eulerInstance); * ``` */ export declare function toQuat(out: Quat, e: Euler): Quat; /** * out (Euler) = euler angles from quaternion in given order. Returns out. * * Implementation path: quat → 3x3 column-major rotation matrix → fromRotationMatrix(order). * This concentrates the 6-order formulas in fromRotationMatrix and avoids dual maintenance. * * @degrade gimbal lock (pitch ≈ ±π/2, sin/cos critical) → set yaw to 0 and let roll absorb the * full rotation (registry #16; same equivalent-branch semantics as Three.js; no throw). * * @example * ```ts * euler.fromQuat(out, q, 'XYZ'); * ``` */ export declare function fromQuat(out: Euler, q: QuatLike, order: EulerOrder): Euler; /** * out (Euler) = euler from a 3x3 rotation matrix m (column-major, length 9) in `order`. Returns out. * * Uses the Three.js Euler.setFromRotationMatrix formulas (intrinsic rotation + Hamilton convention). * Each of the 6 orders has an analytic formula; near gimbal-lock (middle axis sin/cos near ±1) * an equivalent branch is selected. * * @degrade gimbal lock → middle axis is fixed at ±π/2; the remaining two axes degenerate * (one is set to 0; the other absorbs the rotation). * * @example * ```ts * euler.fromRotationMatrix(out, mat3InstanceColumnMajor, 'XYZ'); * ``` */ export declare function fromRotationMatrix(out: Euler, m: Mat3Like, order: EulerOrder): Euler; //# sourceMappingURL=euler.d.ts.map