/** Baked Motion manifest parsing and parameter-grid sampling (DOM/WebCodecs free). */
export declare const BAKED_MOTION_TYPE = "utsubo-utsbv";
export declare const BAKED_MOTION_VERSION = 3;
export declare const BAKED_MOTION_MANIFEST_MAX_BYTES: number;
export declare const BAKED_MOTION_MAX_INDEX_ENTRIES = 100000;
export type BakedMotionMode = 'timeline' | 'tilt' | 'rotation';
export type BakedMotionOrder = 'rowMajor' | 'serpentine';
export interface BakedMotionFrameRate {
    numerator: number;
    denominator: number;
}
export interface BakedMotionAxis {
    param: string;
    unit: string;
    min: number;
    max: number;
    count: number;
    wrap: boolean;
}
export type BakedMotionAxes = [BakedMotionAxis] | [BakedMotionAxis, BakedMotionAxis];
interface BakedMotionCameraBase {
    radius: number;
    near: number;
    far: number;
}
export interface BakedMotionOrthographicCamera extends BakedMotionCameraBase {
    type: 'orthographic';
    orthoScale: number;
}
export interface BakedMotionPerspectiveCamera extends BakedMotionCameraBase {
    type: 'perspective';
    fov: number;
}
export type BakedMotionCamera = BakedMotionOrthographicCamera | BakedMotionPerspectiveCamera;
export interface BakedMotionBounds {
    center: [number, number, number];
    size: [number, number, number];
    radius: number;
}
interface BakedMotionTrackBase {
    /** Flat projection of the selected resource, for consumers that want one track. */
    file: string;
    width?: number;
    height?: number;
    codec?: string;
}
export interface BakedMotionAlbedoTrack extends BakedMotionTrackBase {
    colorSpace: 'srgb';
}
/** Per-frame occupied depth interval in camera-space world units. */
export type BakedMotionDepthFrameRange = [minimum: number, maximum: number];
export interface BakedMotionDepthTrack extends BakedMotionTrackBase {
    colorSpace: 'none';
    range: 'full';
    encoding: 'linear01';
    near: number;
    far: number;
    depthScale: number;
    parallaxScale: number;
    frameRanges?: BakedMotionDepthFrameRange[];
}
export interface BakedMotionPointer {
    tiltRange: number;
    invertY: boolean;
    ease: number;
}
/** `[absolute byte offset, byte length, keyframe flag]` from the outer startup index. */
export type BakedMotionFrameIndexEntry = [offset: number, length: number, keyframe: 0 | 1];
export interface BakedMotionSegment {
    firstFrame: number;
    frameCount: number;
    offset: number;
    length: number;
    sha256: string;
}
export interface BakedMotionIndexedStream {
    codec: string;
    description?: string;
    gop: number;
    frames: BakedMotionFrameIndexEntry[];
    segments: BakedMotionSegment[];
}
export interface BakedMotionIndexedResourceBase {
    file: string;
    /** Whole `.af` resource length, including its embedded JSON manifest and 4-byte trailer. */
    byteLength: number;
    /** Encoded-body length and embedded-manifest offset stored by the `.af` trailer. */
    bodyByteLength: number;
    sha256: string;
}
export interface BakedMotionAlbedoResource extends BakedMotionIndexedResourceBase {
    streams: {
        color: BakedMotionIndexedStream;
        alpha?: BakedMotionIndexedStream;
    };
}
export interface BakedMotionDepthResource extends BakedMotionIndexedResourceBase {
    streams: {
        depth: BakedMotionIndexedStream;
    };
}
export interface BakedMotionIndexedRendition {
    id: string;
    width: number;
    height: number;
    networkMode: 'full' | 'segments';
    resources: {
        albedo: BakedMotionAlbedoResource;
        depth?: BakedMotionDepthResource;
    };
}
export type BakedMotionRendition = BakedMotionIndexedRendition;
export interface BakedMotionGenerator extends Record<string, unknown> {
    tool: string;
    version: string;
    projectVersion: number;
}
interface BakedMotionManifestCommon {
    type: typeof BAKED_MOTION_TYPE;
    /** Floating compatibility projection; rational `frameRate` is authoritative. */
    fps: number;
    frameRate: BakedMotionFrameRate;
    frameCount: number;
    order: BakedMotionOrder;
    camera: BakedMotionCamera;
    bounds: BakedMotionBounds;
    tracks: {
        albedo: BakedMotionAlbedoTrack;
        depth?: BakedMotionDepthTrack;
    };
}
/**
 * Every manifest has one shape: renditions of per-view tracks, where one decoded video frame is
 * one camera view. The version records the wire contract generation only.
 */
interface BakedMotionManifestIndexedFields {
    version: typeof BAKED_MOTION_VERSION;
    renditions: BakedMotionIndexedRendition[];
    coarse?: BakedMotionCoarse;
    generator: BakedMotionGenerator;
}
/** One still image of the coarse atlas, hash-pinned like every other package resource. */
export interface BakedMotionCoarseResource {
    readonly file: string;
    readonly byteLength: number;
    readonly sha256: string;
}
/**
 * All-view thumbnail atlas. Every stored view is one `tile`x`tile` cell laid out in the package's
 * own frame order, so a tile index IS a frame index. It exists so a corner that has not finished
 * decoding still has evidence at its own pose instead of forcing a stale binding on screen.
 */
export interface BakedMotionCoarse {
    readonly tile: number;
    readonly grid: readonly [number, number];
    readonly resources: {
        readonly albedo: BakedMotionCoarseResource;
        readonly depth?: BakedMotionCoarseResource;
    };
}
type BakedMotionManifestVersionFields = BakedMotionManifestIndexedFields;
export type TimelineBakedMotionManifest = BakedMotionManifestCommon & BakedMotionManifestVersionFields & {
    mode: 'timeline';
    axes: [BakedMotionAxis];
};
export type TiltBakedMotionManifest = BakedMotionManifestCommon & BakedMotionManifestVersionFields & {
    mode: 'tilt';
    axes: [BakedMotionAxis, BakedMotionAxis];
    pointer: BakedMotionPointer;
};
export type RotationBakedMotionManifest = BakedMotionManifestCommon & BakedMotionManifestVersionFields & {
    mode: 'rotation';
    axes: BakedMotionAxes;
};
export type BakedMotionManifest = TimelineBakedMotionManifest | TiltBakedMotionManifest | RotationBakedMotionManifest;
export type BakedMotionIndexedManifest = BakedMotionManifest & BakedMotionManifestIndexedFields;
export type BakedMotionParameterValues = number | number[] | Record<string, number>;
export interface BakedMotionFrameSample1D {
    dimension: 1;
    frame: number;
}
export interface BakedMotionFrameSample2D {
    dimension: 2;
    coordinate: [number, number];
    indices: [number, number, number, number];
    weights: [number, number, number, number];
}
export type BakedMotionFrameSample = BakedMotionFrameSample1D | BakedMotionFrameSample2D;
export interface BakedMotionVector3Like {
    x: number;
    y: number;
    z: number;
}
/** Parse, validate, normalize, and freeze a Baked Motion manifest. */
export declare function parseBakedMotionManifest(input: unknown): BakedMotionManifest;
/** Map a parameter value to a fractional stored-sample coordinate. */
export declare function axisCoordinate(axis: BakedMotionAxis, value: unknown): number;
/** Flatten one integer grid coordinate using the manifest's row/serpentine order. */
export declare function flattenBakedMotionIndex(manifest: BakedMotionManifest, x: number, y?: number): number;
/** Inverse of {@link flattenBakedMotionIndex}: temporal frame index → integer grid coordinate. */
export declare function unflattenBakedMotionIndex(manifest: BakedMotionManifest, index: number): {
    x: number;
    y: number;
};
/**
 * Convert one/two semantic parameters to the temporal AF frame(s). One-dimensional clips
 * return a fractional `frame`; two-dimensional clips return four indices + bilinear weights.
 */
export declare function paramToFrame(manifest: BakedMotionManifest, values: BakedMotionParameterValues): BakedMotionFrameSample;
/** Convert a three.js Y-up target→camera direction to azimuth/elevation parameters. */
export declare function viewToBakedMotionParameters(manifest: BakedMotionManifest, cameraPosition: BakedMotionVector3Like): {
    azimuth: number;
    elevation?: number;
};
/** Convert pointer NDC to the tilt parameter pair recorded by the manifest. */
export declare function pointerToBakedMotionParameters(manifest: TiltBakedMotionManifest, x: number, y: number): {
    tiltX: number;
    tiltY: number;
};
export {};