import { TransformN } from '../math/transform.js';
/**
 * A node in an N-dimensional scene hierarchy.
 *
 * Each node carries a local rigid transform (rotation backend +
 * translation); world transforms compose down the tree by the rigid
 * group law
 *
 *   R_w = R_p · R_c,   t_w = R_p(t_c) + t_p,
 *
 * i.e. `parent.world.compose(child.local)`. On the Rotor4 backend the
 * rotation composition is a rotor product, so deep hierarchies stay on
 * the fast path and never touch dense matrices.
 *
 * There is deliberately no scale: a non-uniform scale in R⁴ breaks the
 * orthonormality every rotation backend and render product assumes
 * (and makes decomposition ill-posed). Rigid motions compose closed;
 * anything else belongs in geometry, not in the transform.
 *
 * `updateWorld()` recomputes the subtree's world transforms in one
 * traversal — call it once per frame on the root, as three.js does
 * with `updateMatrixWorld`. Render products then consume
 * `node.world` directly.
 */
export declare class ObjectN {
    readonly dim: number;
    /** Local transform, freely mutable between updates. */
    local: TransformN;
    /** World transform as of the last `updateWorld` traversal. */
    world: TransformN;
    parent: ObjectN | null;
    readonly children: ObjectN[];
    constructor(dim: number, local?: TransformN);
    add(child: ObjectN): this;
    remove(child: ObjectN): this;
    /** Depth-first visit of this node and all descendants. */
    traverse(visit: (node: ObjectN) => void): void;
    /**
     * Recomputes world transforms for this subtree. When called on a
     * parented node, the parent's `world` is trusted as-is; roots compose
     * against identity.
     */
    updateWorld(): void;
}
/** A root node: the conventional entry point of a hierarchy. */
export declare class SceneN extends ObjectN {
}
//# sourceMappingURL=object-n.d.ts.map