import { MatN } from '../math/matn.js';
import { TransformN } from '../math/transform.js';
import { VecN } from '../math/vecn.js';
/**
 * A camera in ℝⁿ: a pose (position + orthonormal frame) from which the
 * scene is viewed before projection.
 *
 * Conventions generalize three.js: the camera looks down its **negative
 * last axis** (−z for n = 3, −w for n = 4). `viewTransform()` returns the
 * world→view rigid transform; feed view-space geometry to a `Projection`
 * (whose viewpoint sits on the positive hidden axes) or a slice.
 *
 * The rotation matrix's columns are the camera's axes expressed in world
 * coordinates; the last column is the "backward" direction (from target
 * toward camera).
 */
export declare class CameraN {
    readonly dim: number;
    position: VecN;
    rotation: MatN;
    /**
     * Creates a camera in Rⁿ. Its pose is inverted to a view transform and
     * composed before projection, exactly as at n = 3.
     *
     * @param dim - Ambient dimension the camera observes.
     * @param position - Eye position. Defaults to the origin.
     * @param rotation - Orientation as an orthonormal frame whose last axis
     * points backward, generalising the convention by which a three.js camera
     * looks down its own −z. Defaults to the identity, so the camera looks
     * along −e\_{n−1}.
     *
     * @example
     * Prefer `lookAt` over supplying a frame by hand; it completes the frame
     * and keeps roll continuous across successive calls.
     * ```ts
     * const camera = new CameraN(4, new VecN([0, 0, 0, 4]));
     * camera.lookAt(new VecN(4));
     * ```
     */
    constructor(dim: number, position?: VecN, rotation?: MatN);
    /**
     * Aims the camera at `target`: the last camera axis becomes the unit
     * vector from target to position ("backward", as in three.js), and the
     * remaining axes are completed from the current frame by modified
     * Gram–Schmidt — so successive lookAt calls change orientation
     * continuously instead of snapping roll. Falls back to standard basis
     * vectors when the current frame degenerates, and flips the first axis
     * if needed to keep the frame orientation-preserving (det +1).
     */
    lookAt(target: VecN): this;
    /** The camera pose as a transform (view → world). */
    poseTransform(): TransformN;
    /**
     * The world → view transform: compose with object transforms before
     * projecting, e.g. `camera.viewTransform().compose(objectTransform)`.
     */
    viewTransform(): TransformN;
}
//# sourceMappingURL=camera.d.ts.map