@holoscript/engine 6.0.3 → 6.0.4

package/dist/index-CmYtNiI-.d.cts

@@ -0,0 +1,953 @@
+/**
+ * AnimationClip.ts
+ *
+ * Keyframe-based animation clip: multi-track keyframes,
+ * interpolation modes, animation events, looping, and blending.
+ *
+ * @module animation
+ */
+type InterpolationMode = 'step' | 'linear' | 'cubic' | 'slerp';
+interface ClipKeyframe {
+    time: number;
+    value: number | number[];
+    inTangent?: number;
+    outTangent?: number;
+}
+interface ClipTrack {
+    id: string;
+    targetPath: string;
+    property: string;
+    component?: string;
+    interpolation: InterpolationMode;
+    keyframes: ClipKeyframe[];
+}
+interface ClipEvent {
+    time: number;
+    name: string;
+    data: Record<string, unknown>;
+}
+declare class AnimClip {
+    readonly id: string;
+    readonly name: string;
+    private tracks;
+    private events;
+    private _duration;
+    private loop;
+    private speed;
+    private wrapMode;
+    constructor(id: string, name: string, duration: number);
+    setLoop(loop: boolean): void;
+    isLooping(): boolean;
+    setSpeed(speed: number): void;
+    getSpeed(): number;
+    setWrapMode(mode: typeof this.wrapMode): void;
+    getWrapMode(): string;
+    getDuration(): number;
+    addTrack(track: ClipTrack): void;
+    getTrack(id: string): ClipTrack | undefined;
+    getTracks(): ClipTrack[];
+    getTrackCount(): number;
+    addEvent(time: number, name: string, data?: Record<string, unknown>): void;
+    getEventsInRange(fromTime: number, toTime: number): ClipEvent[];
+    getEvents(): ClipEvent[];
+    sample(time: number): Map<string, number>;
+    private sampleTrack;
+    private wrapTime;
+    static blend(a: Map<string, number>, b: Map<string, number>, weight: number): Map<string, number>;
+}
+
+/**
+ * AnimationEngine.ts
+ *
+ * Core animation system for HoloScript+.
+ * Provides keyframe interpolation, easing functions,
+ * and a centralized update loop for all active animations.
+ */
+type EasingFn = (t: number) => number;
+declare const Easing: {
+    readonly linear: (t: number) => number;
+    readonly easeInQuad: (t: number) => number;
+    readonly easeOutQuad: (t: number) => number;
+    readonly easeInOutQuad: (t: number) => number;
+    readonly easeInCubic: (t: number) => number;
+    readonly easeOutCubic: (t: number) => number;
+    readonly easeInOutCubic: (t: number) => number;
+    readonly easeInExpo: (t: number) => number;
+    readonly easeOutExpo: (t: number) => number;
+    readonly easeInOutExpo: (t: number) => number;
+    readonly easeOutBack: (t: number) => number;
+    readonly easeOutElastic: (t: number) => number;
+    readonly easeOutBounce: (t: number) => number;
+};
+interface Keyframe$1<T = number> {
+    time: number;
+    value: T;
+    easing?: EasingFn;
+}
+interface AnimationClip$1 {
+    id: string;
+    property: string;
+    keyframes: Keyframe$1[];
+    duration: number;
+    loop: boolean;
+    pingPong: boolean;
+    delay: number;
+    onComplete?: () => void;
+}
+interface ActiveAnimation {
+    clip: AnimationClip$1;
+    elapsed: number;
+    isPlaying: boolean;
+    isPaused: boolean;
+    direction: 1 | -1;
+    loopCount: number;
+}
+declare class AnimationEngine {
+    private animations;
+    private propertySetters;
+    /**
+     * Register an animation clip and start playing it.
+     */
+    play(clip: AnimationClip$1, setter: (value: number) => void): void;
+    /**
+     * Stop and remove an animation.
+     */
+    stop(clipId: string): void;
+    /**
+     * Pause an animation.
+     */
+    pause(clipId: string): void;
+    /**
+     * Resume a paused animation.
+     */
+    resume(clipId: string): void;
+    /**
+     * Check if an animation is active.
+     */
+    isActive(clipId: string): boolean;
+    /**
+     * Get all active animation IDs.
+     */
+    getActiveIds(): string[];
+    /**
+     * Update all active animations. Call this every frame.
+     */
+    update(delta: number): void;
+    /**
+     * Stop all animations.
+     */
+    clear(): void;
+}
+
+/**
+ * AnimationGraph.ts
+ *
+ * State machine-driven animation blending system.
+ * Supports weighted transitions, blend trees, and animation layers.
+ *
+ * @module animation
+ */
+interface AnimationClip {
+    id: string;
+    name: string;
+    duration: number;
+    loop: boolean;
+    speed: number;
+    tracks: AnimationTrack[];
+}
+interface AnimationTrack {
+    targetProperty: string;
+    keyframes: Keyframe[];
+    interpolation: 'linear' | 'step' | 'cubic';
+}
+interface Keyframe {
+    time: number;
+    value: number;
+    inTangent?: number;
+    outTangent?: number;
+}
+interface AnimationState {
+    id: string;
+    clipId: string;
+    speed: number;
+    loop: boolean;
+    currentTime: number;
+    weight: number;
+    isPlaying: boolean;
+}
+interface AnimationTransition {
+    id: string;
+    fromState: string;
+    toState: string;
+    duration: number;
+    condition: TransitionCondition;
+    interruptible: boolean;
+}
+type TransitionCondition = {
+    type: 'parameter';
+    name: string;
+    comparator: '>' | '<' | '==' | '!=';
+    value: number | boolean;
+} | {
+    type: 'finished';
+} | {
+    type: 'trigger';
+    name: string;
+};
+interface BlendNode {
+    type: 'clip' | 'blend1d' | 'blend2d';
+    clipId?: string;
+    parameter?: string;
+    children?: {
+        position: number;
+        node: BlendNode;
+    }[];
+    children2D?: {
+        position: {
+            x: number;
+            y: number;
+        };
+        node: BlendNode;
+    }[];
+}
+interface AnimationLayer {
+    id: string;
+    weight: number;
+    blendMode: 'override' | 'additive';
+    mask?: string[];
+    graph: AnimationGraphInstance;
+}
+interface AnimationGraphInstance {
+    states: Map<string, AnimationState>;
+    transitions: AnimationTransition[];
+    currentState: string;
+    parameters: Map<string, number | boolean>;
+    activeTransition: {
+        from: string;
+        to: string;
+        progress: number;
+        duration: number;
+    } | null;
+}
+declare class AnimationGraph {
+    private clips;
+    private layers;
+    private defaultGraph;
+    constructor();
+    addClip(clip: AnimationClip): void;
+    getClip(id: string): AnimationClip | undefined;
+    removeClip(id: string): boolean;
+    getClipIds(): string[];
+    addState(id: string, clipId: string, options?: Partial<{
+        speed: number;
+        loop: boolean;
+    }>): AnimationState;
+    getState(id: string): AnimationState | undefined;
+    getCurrentState(): string;
+    addTransition(transition: AnimationTransition): void;
+    setParameter(name: string, value: number | boolean): void;
+    getParameter(name: string): number | boolean | undefined;
+    setTrigger(name: string): void;
+    update(dt: number): Map<string, number>;
+    addLayer(layer: AnimationLayer): void;
+    getLayers(): AnimationLayer[];
+    private evaluateCondition;
+    private sampleTrack;
+}
+
+/**
+ * SpringAnimator.ts
+ *
+ * Physics-based spring dynamics for smooth, natural-feeling animations.
+ * Implements a critically-damped spring model for responsive UI motion.
+ */
+interface SpringConfig {
+    stiffness: number;
+    damping: number;
+    mass: number;
+    precision: number;
+}
+declare const SpringPresets: Record<string, SpringConfig>;
+declare class SpringAnimator {
+    private current;
+    private target;
+    private velocity;
+    private config;
+    private atRest;
+    private onUpdate?;
+    private onRest?;
+    constructor(initialValue: number, config?: Partial<SpringConfig>, onUpdate?: (value: number) => void, onRest?: () => void);
+    /**
+     * Set a new target value. The spring will animate towards it.
+     */
+    setTarget(target: number): void;
+    /**
+     * Instantly jump to a value (no animation).
+     */
+    setValue(value: number): void;
+    /**
+     * Apply an impulse (instant velocity change).
+     */
+    impulse(force: number): void;
+    /**
+     * Step the spring simulation forward.
+     * Uses semi-implicit Euler integration.
+     */
+    update(delta: number): number;
+    /**
+     * Get current value.
+     */
+    getValue(): number;
+    /**
+     * Check if the spring has settled.
+     */
+    isAtRest(): boolean;
+    /**
+     * Change spring configuration dynamically.
+     */
+    setConfig(config: Partial<SpringConfig>): void;
+}
+declare class Vec3SpringAnimator {
+    x: SpringAnimator;
+    y: SpringAnimator;
+    z: SpringAnimator;
+    constructor(initial: {
+        x: number;
+        y: number;
+        z: number;
+    }, config?: Partial<SpringConfig>, onUpdate?: (value: {
+        x: number;
+        y: number;
+        z: number;
+    }) => void);
+    setTarget(target: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    update(delta: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    getValue(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    isAtRest(): boolean;
+}
+
+/**
+ * AnimationTrait.ts
+ *
+ * Declarative animation attachment for HoloScript+ nodes.
+ * Allows any node to have animations defined as traits.
+ *
+ * @trait animate
+ */
+
+interface HSPlusNode {
+    id?: string;
+    properties?: Record<string, unknown>;
+}
+interface TraitHandler<TConfig> {
+    name: string;
+    defaultConfig: TConfig;
+    onAttach(node: HSPlusNode, config: TConfig, context: unknown): void;
+    onDetach(node: HSPlusNode, config: TConfig, context: unknown): void;
+    onUpdate(node: HSPlusNode, config: TConfig, context: unknown, delta: number): void;
+}
+interface AnimationTraitConfig {
+    clips?: AnimationClipDef[];
+    springs?: SpringDef[];
+    autoPlay: boolean;
+}
+interface AnimationClipDef {
+    property: string;
+    keyframes: Array<{
+        time: number;
+        value: number;
+        easing?: string;
+    }>;
+    duration: number;
+    loop?: boolean;
+    pingPong?: boolean;
+    delay?: number;
+}
+interface SpringDef {
+    property: string;
+    target: number;
+    preset?: string;
+    config?: Partial<SpringConfig>;
+}
+declare function getSharedAnimationEngine(): AnimationEngine;
+declare const animationTraitHandler: TraitHandler<AnimationTraitConfig>;
+
+/**
+ * AnimationTransitions.ts
+ *
+ * Ragdoll ? Animation blending system.
+ * Enables seamless transitions between physics-driven ragdoll and keyframed animation.
+ *
+ * @module animation
+ */
+interface IVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface BonePose {
+    boneId: string;
+    position: IVector3;
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+}
+interface TransitionConfig {
+    duration: number;
+    curve: 'linear' | 'ease_in' | 'ease_out' | 'ease_in_out';
+    settleThreshold: number;
+}
+type TransitionDirection$1 = 'animation_to_ragdoll' | 'ragdoll_to_animation';
+interface BlendState {
+    direction: TransitionDirection$1;
+    progress: number;
+    duration: number;
+    sourcePose: BonePose[];
+    isComplete: boolean;
+}
+declare class AnimationTransitionSystem {
+    private config;
+    private activeBlends;
+    constructor(config?: Partial<TransitionConfig>);
+    startAnimToRagdoll(entityId: string, currentPose: BonePose[]): void;
+    startRagdollToAnim(entityId: string, currentPose: BonePose[]): void;
+    update(dt: number, ragdollPoses: Map<string, BonePose[]>, animPoses: Map<string, BonePose[]>): Map<string, BonePose[]>;
+    isTransitioning(entityId: string): boolean;
+    getBlendProgress(entityId: string): number;
+    clearTransition(entityId: string): void;
+    getActiveTransitionCount(): number;
+    private applyCurve;
+    private lerpVec3;
+    private slerpQuat;
+}
+
+/**
+ * IKSolver.ts
+ *
+ * Inverse Kinematics: two-bone IK, CCD chain solver,
+ * pole target, foot placement, and constraint limits.
+ *
+ * @module animation
+ */
+interface IKBone {
+    id: string;
+    position: [number, number, number];
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+        w: number;
+    };
+    length: number;
+    minAngle?: number;
+    maxAngle?: number;
+}
+interface IKChain {
+    id: string;
+    bones: IKBone[];
+    target: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    poleTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    weight: number;
+    iterations: number;
+}
+interface FootPlacementConfig {
+    rayHeight: number;
+    rayLength: number;
+    footOffset: number;
+    blendSpeed: number;
+    enabled: boolean;
+}
+declare class IKSolver {
+    private chains;
+    private footConfig;
+    private footPositions;
+    addChain(chain: IKChain): void;
+    removeChain(id: string): boolean;
+    getChain(id: string): IKChain | undefined;
+    getChainCount(): number;
+    setTarget(chainId: string, x: number, y: number, z: number): void;
+    setPoleTarget(chainId: string, x: number, y: number, z: number): void;
+    setWeight(chainId: string, weight: number): void;
+    solveTwoBone(chainId: string): boolean;
+    solveCCD(chainId: string): boolean;
+    setFootPlacement(config: Partial<FootPlacementConfig>): void;
+    getFootPlacement(): FootPlacementConfig;
+    updateFootPlacement(footId: string, groundHeight: number, dt: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    solveAll(): void;
+}
+
+/**
+ * BoneSystem.ts
+ *
+ * Skeletal bone hierarchy: bind pose, joint transforms,
+ * world-space chain computation, and pose application.
+ *
+ * @module animation
+ */
+interface BoneTransform {
+    tx: number;
+    ty: number;
+    tz: number;
+    rx: number;
+    ry: number;
+    rz: number;
+    rw: number;
+    sx: number;
+    sy: number;
+    sz: number;
+}
+interface Bone {
+    id: string;
+    name: string;
+    parentId: string | null;
+    local: BoneTransform;
+    world: BoneTransform;
+    bindInverse: BoneTransform;
+    childIds: string[];
+}
+declare class BoneSystem {
+    private bones;
+    private roots;
+    private dirty;
+    addBone(id: string, name: string, parentId: string | null, local?: Partial<BoneTransform>): void;
+    getBone(id: string): Bone | undefined;
+    getBoneCount(): number;
+    getRoots(): string[];
+    setLocalTransform(id: string, transform: Partial<BoneTransform>): void;
+    updateWorldTransforms(): void;
+    private updateBoneChain;
+    captureBindPose(): void;
+    getSkinningMatrix(id: string): BoneTransform | null;
+    private combineTransforms;
+    private invertTransform;
+    getWorldPosition(id: string): {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+    getChain(leafId: string): string[];
+}
+
+/**
+ * AvatarController.ts
+ *
+ * Maps VR input sources (HMD, Controllers) to IK Solver targets.
+ * Handles calibration and VRIK logic (spine handling, shoulder offsets).
+ *
+ * @module animation
+ */
+
+interface AvatarInput {
+    head: {
+        position: [number, number, number];
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    };
+    leftHand: {
+        position: [number, number, number];
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    };
+    rightHand: {
+        position: [number, number, number];
+        rotation: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    };
+    height: number;
+}
+declare class AvatarController {
+    private solver;
+    private bones;
+    private calibrated;
+    private config;
+    constructor(solver: IKSolver, bones: BoneSystem);
+    /**
+     * Calibrate avatar scale based on user height
+     */
+    calibrate(_userHeight: number): void;
+    /**
+     * Update IK targets from VR input
+     */
+    update(input: AvatarInput): void;
+}
+
+/**
+ * CutsceneTimeline.ts
+ *
+ * Sequenced animation/event timeline for cutscenes.
+ * Supports parallel tracks, timed events, camera control, and dialogue cues.
+ *
+ * @module animation
+ */
+type TimelineEventType = 'animation' | 'camera' | 'dialogue' | 'audio' | 'effect' | 'wait' | 'callback';
+interface TimelineEvent {
+    id: string;
+    type: TimelineEventType;
+    startTime: number;
+    duration: number;
+    data: Record<string, unknown>;
+}
+interface TimelineTrack {
+    id: string;
+    name: string;
+    targetEntity?: string;
+    events: TimelineEvent[];
+    muted: boolean;
+}
+interface CutsceneDefinition {
+    id: string;
+    name: string;
+    duration: number;
+    tracks: TimelineTrack[];
+    loop: boolean;
+}
+interface CutsceneState {
+    definition: CutsceneDefinition;
+    currentTime: number;
+    isPlaying: boolean;
+    isPaused: boolean;
+    speed: number;
+    activeEvents: Set<string>;
+    completedEvents: Set<string>;
+    triggeredCallbacks: string[];
+}
+declare class CutsceneTimeline {
+    private cutscenes;
+    private callbacks;
+    load(definition: CutsceneDefinition): string;
+    play(id: string, startTime?: number): boolean;
+    pause(id: string): void;
+    resume(id: string): void;
+    stop(id: string): void;
+    setSpeed(id: string, speed: number): void;
+    seek(id: string, time: number): void;
+    registerCallback(callbackId: string, fn: () => void): void;
+    unregisterCallback(callbackId: string): void;
+    update(dt: number): Map<string, TimelineEvent[]>;
+    getState(id: string): CutsceneState | undefined;
+    isPlaying(id: string): boolean;
+    getCurrentTime(id: string): number;
+    getProgress(id: string): number;
+    removeCutscene(id: string): boolean;
+}
+declare class CutsceneBuilder {
+    private tracks;
+    private eventCounter;
+    private id;
+    private name;
+    constructor(id: string, name: string);
+    addTrack(name: string, targetEntity?: string): CutsceneBuilder;
+    addEvent(trackIndex: number, type: TimelineEventType, startTime: number, duration: number, data?: Record<string, unknown>): CutsceneBuilder;
+    build(): CutsceneDefinition;
+}
+
+/**
+ * MorphTargets.ts
+ *
+ * Blend shapes / morph targets: named targets with delta vertices,
+ * weight interpolation, presets, and batch application.
+ *
+ * @module animation
+ */
+interface MorphDelta {
+    vertexIndex: number;
+    dx: number;
+    dy: number;
+    dz: number;
+}
+interface MorphTarget {
+    name: string;
+    deltas: MorphDelta[];
+    weight: number;
+}
+interface MorphPreset {
+    name: string;
+    weights: Map<string, number>;
+}
+declare class MorphTargetSystem {
+    private targets;
+    private presets;
+    private vertexCount;
+    constructor(vertexCount: number);
+    addTarget(name: string, deltas: MorphDelta[]): void;
+    removeTarget(name: string): void;
+    setWeight(name: string, weight: number): void;
+    getWeight(name: string): number;
+    addPreset(name: string, weights: Map<string, number>): void;
+    applyPreset(name: string): void;
+    computeDeformedPositions(basePositions: Float32Array): Float32Array;
+    lerpWeights(targetWeights: Map<string, number>, t: number): void;
+    getTargetCount(): number;
+    getActiveTargets(): string[];
+    getVertexCount(): number;
+}
+
+/**
+ * SkeletalBlender.ts
+ *
+ * Multi-clip animation blending: layer weights,
+ * additive/override modes, crossfade, and pose mixing.
+ *
+ * @module animation
+ */
+interface AnimPose {
+    boneId: string;
+    tx: number;
+    ty: number;
+    tz: number;
+    sx: number;
+    sy: number;
+    sz: number;
+}
+interface AnimLayer {
+    id: string;
+    poses: AnimPose[];
+    weight: number;
+    mode: 'override' | 'additive';
+    mask?: Set<string>;
+}
+declare class SkeletalBlender {
+    private layers;
+    private blendedPoses;
+    addLayer(layer: AnimLayer): void;
+    removeLayer(id: string): void;
+    setLayerWeight(id: string, weight: number): void;
+    getLayerWeight(id: string): number;
+    blend(): Map<string, AnimPose>;
+    crossfade(fromId: string, toId: string, t: number): void;
+    private lerpPose;
+    getLayerCount(): number;
+    getBlendedPose(boneId: string): AnimPose | undefined;
+}
+
+/**
+ * Timeline.ts
+ *
+ * Sequential and parallel animation group orchestration.
+ * Enables complex choreographed animation sequences.
+ */
+
+type TimelineMode = 'sequential' | 'parallel';
+interface TimelineEntry {
+    clip: AnimationClip$1;
+    setter: (value: number) => void;
+    startOffset?: number;
+}
+interface TimelineConfig {
+    mode: TimelineMode;
+    loop: boolean;
+    loopCount: number;
+    pingPong: boolean;
+    delay: number;
+    onComplete?: () => void;
+    onLoop?: (count: number) => void;
+}
+declare class Timeline {
+    private entries;
+    private config;
+    private engine;
+    private elapsed;
+    private isPlaying;
+    private isPaused;
+    private currentLoop;
+    private direction;
+    private totalDuration;
+    constructor(config?: Partial<TimelineConfig>, engine?: AnimationEngine);
+    /**
+     * Add an animation to the timeline.
+     */
+    add(clip: AnimationClip$1, setter: (value: number) => void, startOffset?: number): Timeline;
+    /**
+     * Start playing the timeline.
+     */
+    play(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    /**
+     * Update the timeline. Call every frame.
+     */
+    update(delta: number): void;
+    private updateSequential;
+    private updateParallel;
+    private handleCompletion;
+    private recalcDuration;
+    /**
+     * Get total duration of the timeline.
+     */
+    getDuration(): number;
+    /**
+     * Get current elapsed time.
+     */
+    getElapsed(): number;
+    /**
+     * Get normalized progress (0-1).
+     */
+    getProgress(): number;
+}
+
+/**
+ * TransitionSystem.ts
+ *
+ * Pre-built UI transition patterns using the AnimationEngine.
+ * Provides fade, scale, slide, and combined transitions.
+ */
+
+type TransitionDirection = 'in' | 'out';
+interface TransitionOptions {
+    duration?: number;
+    easing?: EasingFn;
+    delay?: number;
+    onComplete?: () => void;
+}
+declare class TransitionSystem {
+    private engine;
+    constructor(engine?: AnimationEngine);
+    getEngine(): AnimationEngine;
+    /**
+     * Fade in/out (opacity 0 <-> 1)
+     */
+    fade(nodeId: string, direction: TransitionDirection, setter: (opacity: number) => void, options?: TransitionOptions): void;
+    /**
+     * Scale in/out (scale 0 <-> 1)
+     */
+    scale(nodeId: string, direction: TransitionDirection, setter: (scale: number) => void, options?: TransitionOptions): void;
+    /**
+     * Slide from a direction (e.g., slide up from below)
+     */
+    slide(nodeId: string, direction: TransitionDirection, axis: 'x' | 'y' | 'z', distance: number, setter: (offset: number) => void, options?: TransitionOptions): void;
+    /**
+     * Combined: Scale + Fade (common for dialogs/menus)
+     */
+    popIn(nodeId: string, scaleSetter: (s: number) => void, opacitySetter: (o: number) => void, options?: TransitionOptions): void;
+    /**
+     * Combined: Scale + Fade out
+     */
+    popOut(nodeId: string, scaleSetter: (s: number) => void, opacitySetter: (o: number) => void, options?: TransitionOptions): void;
+    /**
+     * Update all transitions. Must be called every frame.
+     */
+    update(delta: number): void;
+}
+
+type index_ActiveAnimation = ActiveAnimation;
+type index_AnimClip = AnimClip;
+declare const index_AnimClip: typeof AnimClip;
+type index_AnimLayer = AnimLayer;
+type index_AnimPose = AnimPose;
+type index_AnimationClipDef = AnimationClipDef;
+type index_AnimationEngine = AnimationEngine;
+declare const index_AnimationEngine: typeof AnimationEngine;
+type index_AnimationGraph = AnimationGraph;
+declare const index_AnimationGraph: typeof AnimationGraph;
+type index_AnimationGraphInstance = AnimationGraphInstance;
+type index_AnimationLayer = AnimationLayer;
+type index_AnimationState = AnimationState;
+type index_AnimationTrack = AnimationTrack;
+type index_AnimationTraitConfig = AnimationTraitConfig;
+type index_AnimationTransition = AnimationTransition;
+type index_AnimationTransitionSystem = AnimationTransitionSystem;
+declare const index_AnimationTransitionSystem: typeof AnimationTransitionSystem;
+type index_AvatarController = AvatarController;
+declare const index_AvatarController: typeof AvatarController;
+type index_AvatarInput = AvatarInput;
+type index_BlendNode = BlendNode;
+type index_BlendState = BlendState;
+type index_Bone = Bone;
+type index_BonePose = BonePose;
+type index_BoneSystem = BoneSystem;
+declare const index_BoneSystem: typeof BoneSystem;
+type index_BoneTransform = BoneTransform;
+type index_ClipEvent = ClipEvent;
+type index_ClipKeyframe = ClipKeyframe;
+type index_ClipTrack = ClipTrack;
+type index_CutsceneBuilder = CutsceneBuilder;
+declare const index_CutsceneBuilder: typeof CutsceneBuilder;
+type index_CutsceneDefinition = CutsceneDefinition;
+type index_CutsceneState = CutsceneState;
+type index_CutsceneTimeline = CutsceneTimeline;
+declare const index_CutsceneTimeline: typeof CutsceneTimeline;
+declare const index_Easing: typeof Easing;
+type index_EasingFn = EasingFn;
+type index_FootPlacementConfig = FootPlacementConfig;
+type index_HSPlusNode = HSPlusNode;
+type index_IKBone = IKBone;
+type index_IKChain = IKChain;
+type index_IKSolver = IKSolver;
+declare const index_IKSolver: typeof IKSolver;
+type index_IVector3 = IVector3;
+type index_InterpolationMode = InterpolationMode;
+type index_MorphDelta = MorphDelta;
+type index_MorphPreset = MorphPreset;
+type index_MorphTarget = MorphTarget;
+type index_MorphTargetSystem = MorphTargetSystem;
+declare const index_MorphTargetSystem: typeof MorphTargetSystem;
+type index_SkeletalBlender = SkeletalBlender;
+declare const index_SkeletalBlender: typeof SkeletalBlender;
+type index_SpringAnimator = SpringAnimator;
+declare const index_SpringAnimator: typeof SpringAnimator;
+type index_SpringConfig = SpringConfig;
+type index_SpringDef = SpringDef;
+declare const index_SpringPresets: typeof SpringPresets;
+type index_Timeline = Timeline;
+declare const index_Timeline: typeof Timeline;
+type index_TimelineConfig = TimelineConfig;
+type index_TimelineEntry = TimelineEntry;
+type index_TimelineEvent = TimelineEvent;
+type index_TimelineEventType = TimelineEventType;
+type index_TimelineMode = TimelineMode;
+type index_TimelineTrack = TimelineTrack;
+type index_TraitHandler<TConfig> = TraitHandler<TConfig>;
+type index_TransitionCondition = TransitionCondition;
+type index_TransitionConfig = TransitionConfig;
+type index_TransitionOptions = TransitionOptions;
+type index_TransitionSystem = TransitionSystem;
+declare const index_TransitionSystem: typeof TransitionSystem;
+type index_Vec3SpringAnimator = Vec3SpringAnimator;
+declare const index_Vec3SpringAnimator: typeof Vec3SpringAnimator;
+declare const index_animationTraitHandler: typeof animationTraitHandler;
+declare const index_getSharedAnimationEngine: typeof getSharedAnimationEngine;
+declare namespace index {
+  export { type index_ActiveAnimation as ActiveAnimation, index_AnimClip as AnimClip, type index_AnimLayer as AnimLayer, type index_AnimPose as AnimPose, type index_AnimationClipDef as AnimationClipDef, index_AnimationEngine as AnimationEngine, type Keyframe$1 as AnimationEngineKeyframe, index_AnimationGraph as AnimationGraph, type index_AnimationGraphInstance as AnimationGraphInstance, type index_AnimationLayer as AnimationLayer, type index_AnimationState as AnimationState, type index_AnimationTrack as AnimationTrack, type index_AnimationTraitConfig as AnimationTraitConfig, type index_AnimationTransition as AnimationTransition, index_AnimationTransitionSystem as AnimationTransitionSystem, index_AvatarController as AvatarController, type index_AvatarInput as AvatarInput, type index_BlendNode as BlendNode, type index_BlendState as BlendState, type index_Bone as Bone, type index_BonePose as BonePose, index_BoneSystem as BoneSystem, type index_BoneTransform as BoneTransform, type index_ClipEvent as ClipEvent, type index_ClipKeyframe as ClipKeyframe, type index_ClipTrack as ClipTrack, index_CutsceneBuilder as CutsceneBuilder, type index_CutsceneDefinition as CutsceneDefinition, type index_CutsceneState as CutsceneState, index_CutsceneTimeline as CutsceneTimeline, index_Easing as Easing, type index_EasingFn as EasingFn, type AnimationClip$1 as EngineAnimationClip, type index_FootPlacementConfig as FootPlacementConfig, type AnimationClip as GraphAnimationClip, type Keyframe as GraphKeyframe, type index_HSPlusNode as HSPlusNode, type index_IKBone as IKBone, type index_IKChain as IKChain, index_IKSolver as IKSolver, type index_IVector3 as IVector3, type index_InterpolationMode as InterpolationMode, type index_MorphDelta as MorphDelta, type index_MorphPreset as MorphPreset, type index_MorphTarget as MorphTarget, index_MorphTargetSystem as MorphTargetSystem, type TransitionDirection$1 as RagdollTransitionDirection, index_SkeletalBlender as SkeletalBlender, index_SpringAnimator as SpringAnimator, type index_SpringConfig as SpringConfig, type index_SpringDef as SpringDef, index_SpringPresets as SpringPresets, index_Timeline as Timeline, type index_TimelineConfig as TimelineConfig, type index_TimelineEntry as TimelineEntry, type index_TimelineEvent as TimelineEvent, type index_TimelineEventType as TimelineEventType, type index_TimelineMode as TimelineMode, type index_TimelineTrack as TimelineTrack, type index_TraitHandler as TraitHandler, type index_TransitionCondition as TransitionCondition, type index_TransitionConfig as TransitionConfig, type index_TransitionOptions as TransitionOptions, index_TransitionSystem as TransitionSystem, type TransitionDirection as UiTransitionDirection, index_Vec3SpringAnimator as Vec3SpringAnimator, index_animationTraitHandler as animationTraitHandler, index_getSharedAnimationEngine as getSharedAnimationEngine };
+}
+
+export { Timeline as $, AnimationEngine as A, type BlendNode as B, type ClipEvent as C, CutsceneTimeline as D, Easing as E, type EasingFn as F, type AnimationClip$1 as G, type FootPlacementConfig as H, type AnimationClip as I, type Keyframe as J, type Keyframe$1 as K, type HSPlusNode as L, type IKBone as M, type IKChain as N, IKSolver as O, type IVector3 as P, type InterpolationMode as Q, type MorphDelta as R, type MorphPreset as S, type MorphTarget as T, MorphTargetSystem as U, type TransitionDirection$1 as V, SkeletalBlender as W, SpringAnimator as X, type SpringConfig as Y, type SpringDef as Z, SpringPresets as _, type ActiveAnimation as a, type TimelineConfig as a0, type TimelineEntry as a1, type TimelineEvent as a2, type TimelineEventType as a3, type TimelineMode as a4, type TimelineTrack as a5, type TraitHandler as a6, type TransitionCondition as a7, type TransitionConfig as a8, type TransitionOptions as a9, TransitionSystem as aa, type TransitionDirection as ab, Vec3SpringAnimator as ac, animationTraitHandler as ad, getSharedAnimationEngine as ae, AnimClip as b, type AnimLayer as c, type AnimPose as d, type AnimationClipDef as e, AnimationGraph as f, type AnimationGraphInstance as g, type AnimationLayer as h, index as i, type AnimationState as j, type AnimationTrack as k, type AnimationTraitConfig as l, type AnimationTransition as m, AnimationTransitionSystem as n, AvatarController as o, type AvatarInput as p, type BlendState as q, type Bone as r, type BonePose as s, BoneSystem as t, type BoneTransform as u, type ClipKeyframe as v, type ClipTrack as w, CutsceneBuilder as x, type CutsceneDefinition as y, type CutsceneState as z };