@zephyr3d/scene 0.9.8 → 0.9.10

package/dist/index.d.ts

@@ -9719,6 +9719,50 @@ type NamedJointsSkeletalAnimationMaskOptions = SkeletalAnimationMaskCommonOption
 /** @public */
 type SkeletalAnimationMaskOptions = HumanoidSkeletalAnimationMaskOptions | NamedJointsSkeletalAnimationMaskOptions;
 
+/**
+ * How a new playback copies phase from an existing active playback.
+ *
+ * - `'normalized'`: copy the source playback's normalized phase and map it into the new clip.
+ * - `'time'`: copy the source playback's time in seconds.
+ *
+ * @public
+ */
+type AnimationPlaybackSyncMode = 'normalized' | 'time';
+/**
+ * Options for starting a playback at the same phase as another active playback.
+ *
+ * Use this when switching between matching locomotion clips, upper/lower body clips, or a
+ * layered setup and a full-body clip that must stay phase-aligned.
+ *
+ * @public
+ */
+type AnimationPlaybackSyncOptions = {
+    /**
+     * Active playback to synchronize with.
+     *
+     * The value is resolved as an active clip name first, then as an active playback id. Timeline
+     * `play` steps also resolve local `id` references before forwarding the options to
+     * `AnimationSet`.
+     */
+    target: string;
+    /**
+     * Synchronization mode. Defaults to `'normalized'`.
+     */
+    mode?: AnimationPlaybackSyncMode;
+    /**
+     * Optional phase offset.
+     *
+     * In `'normalized'` mode this is a normalized phase offset where 1 is one full cycle. In
+     * `'time'` mode this is an offset in seconds.
+     */
+    offset?: number;
+    /**
+     * Whether the synchronized time wraps into the destination clip or range. Defaults to true.
+     *
+     * Set to false to clamp the initial time to the destination clip or range.
+     */
+    wrap?: boolean;
+};
 /**
  * Options for playing an animation.
  *
@@ -9749,6 +9793,14 @@ type PlayAnimationOptions = {
      * Default is 0 (no fade-in).
      */
     fadeIn?: number;
+    /**
+     * Fade-out duration in seconds used after the playback completes naturally.
+     *
+     * When greater than 0, the playback emits `complete` at the authored end time but remains active
+     * for this duration while its weight fades to 0. This lets a following playback cross-fade from
+     * the completed pose instead of snapping after the completed clip is removed.
+     */
+    completionFadeOut?: number;
     /**
      * Weight of the animation clip.
      *
@@ -9756,6 +9808,37 @@ type PlayAnimationOptions = {
      * Default is the clip's configured weight.
      */
     weight?: number;
+    /**
+     * Optional stable playback id. Useful for blueprint/editor references.
+     */
+    id?: string;
+    /**
+     * Logical layer/channel name used by higher-level controllers.
+     */
+    layer?: string;
+    /**
+     * Priority used by higher-level interrupt policies.
+     */
+    priority?: number;
+    /**
+     * Whether higher-level controllers may interrupt this playback.
+     */
+    interruptible?: boolean;
+    /**
+     * Optional sub-range to play.
+     */
+    range?: {
+        start?: AnimationTimeRef;
+        end?: AnimationTimeRef;
+    };
+    /**
+     * Optional phase synchronization source used to choose the initial playback time.
+     *
+     * When omitted, playback starts at the range start (or clip start), and reverse playback starts
+     * at the range end (or clip end). When set, the new playback starts at the phase copied from the
+     * referenced active playback.
+     */
+    sync?: AnimationPlaybackSyncOptions;
 };
 /**
  * Options for stopping an animation.
@@ -9771,8 +9854,96 @@ type StopAnimationOptions = {
      * Default is 0 (immediate stop).
      */
     fadeOut?: number;
+    /**
+     * Stop reason reported by playback events.
+     */
+    reason?: AnimationStopReason;
+};
+/** @public */
+type AnimationPlaybackState = 'scheduled' | 'playing' | 'paused' | 'stopping' | 'stopped' | 'completed';
+/** @public */
+type AnimationStopReason = 'manual' | 'interrupted' | 'completed' | 'deleted' | 'replaced';
+/** @public */
+type AnimationPlaybackEvent = {
+    playback: AnimationPlayback;
+    animationSet: AnimationSet;
+    clip: AnimationClip;
+    time: number;
+    normalizedTime: number;
+};
+/** @public */
+type AnimationMarkerEvent = AnimationPlaybackEvent & {
+    marker: AnimationMarker;
+    direction: 1 | -1;
 };
 /** @public */
+type AnimationFrameEvent = AnimationPlaybackEvent & {
+    frame: number;
+};
+/** @public */
+type AnimationPlaybackStopEvent = AnimationPlaybackEvent & {
+    reason: AnimationStopReason;
+};
+/** @public */
+type AnimationPlaybackEventMap = {
+    start: [event: AnimationPlaybackEvent];
+    loop: [event: AnimationPlaybackEvent];
+    marker: [event: AnimationMarkerEvent];
+    frame: [event: AnimationFrameEvent];
+    complete: [event: AnimationPlaybackEvent];
+    stop: [event: AnimationPlaybackStopEvent];
+    pause: [event: AnimationPlaybackEvent];
+    resume: [event: AnimationPlaybackEvent];
+};
+/** @public */
+type AnimationSetEventMap = {
+    playbackstart: [event: AnimationPlaybackEvent];
+    playbackloop: [event: AnimationPlaybackEvent];
+    marker: [event: AnimationMarkerEvent];
+    frame: [event: AnimationFrameEvent];
+    playbackcomplete: [event: AnimationPlaybackEvent];
+    playbackstop: [event: AnimationPlaybackStopEvent];
+    playbackpause: [event: AnimationPlaybackEvent];
+    playbackresume: [event: AnimationPlaybackEvent];
+};
+/**
+ * Runtime handle for one playback of an AnimationClip.
+ * @public
+ */
+declare class AnimationPlayback extends Observable<AnimationPlaybackEventMap> {
+    constructor(animationSet: AnimationSet, clip: AnimationClip, options?: PlayAnimationOptions);
+    get id(): string;
+    get animationSet(): AnimationSet;
+    get clip(): AnimationClip;
+    get state(): AnimationPlaybackState;
+    get time(): number;
+    set time(value: number);
+    get normalizedTime(): number;
+    set normalizedTime(value: number);
+    get weight(): number;
+    set weight(value: number);
+    get speedRatio(): number;
+    set speedRatio(value: number);
+    get layer(): string;
+    get priority(): number;
+    get interruptible(): boolean;
+    play(): this;
+    pause(): this;
+    resume(): this;
+    stop(options?: StopAnimationOptions): this;
+    seek(time: number, options?: {
+        emitEvents?: boolean;
+        apply?: boolean;
+    }): this;
+    fadeTo(weight: number, duration: number): this;
+    crossFadeTo(name: string, options?: PlayAnimationOptions & {
+        duration?: number;
+    }): AnimationPlayback | null;
+    waitForComplete(): Promise<this>;
+    waitForMarker(idOrName: string): Promise<AnimationMarkerEvent | undefined>;
+    waitForFrame(frame: number): Promise<AnimationFrameEvent | undefined>;
+}
+/** @public */
 type HumanoidRootMotionMode = 'scaled' | 'copy' | 'locked' | 'none';
 /** @public */
 type HumanoidRootMotionScaleMode = 'legLength' | 'none' | number;
@@ -9811,27 +9982,287 @@ type CopyHumanoidAnimationOptions = {
      */
     jointTranslations?: 'skip' | 'preserve';
 };
-/**
- * Animation set
- *
- * Manages a collection of named animation clips for a model and orchestrates:
- * - Playback state (time, loops, speed, weights, fade-in/out).
- * - Blending across multiple tracks targeting the same property via weighted averages.
- * - Skeleton usage and application for clips that drive skeletal animation.
- * - Active track registration and cleanup as clips start/stop.
- *
- * Usage:
- * - Create or retrieve `AnimationClip`s by name.
- * - Start playback with `playAnimation(name, options)`.
- * - Advance animation with `update(deltaSeconds)`.
- * - Optionally adjust weight while playing with `setAnimationWeight(name, weight)`.
- *
- * Lifetime:
- * - Disposing the set releases references to the model, clips, and clears active state.
- *
- * @public
- */
-declare class AnimationSet extends Disposable implements IDisposable {
+declare const AnimationSet_base: (new (...args: any[]) => {
+    _listeners: Nullable<{
+        playbackstart?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackstart">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackloop?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackloop">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        marker?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "marker">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        frame?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "frame">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackcomplete?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackcomplete">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackstop?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackstop">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackpause?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackpause">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackresume?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackresume">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        dispose?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "dispose">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+    }>;
+    on<K extends "dispose" | keyof AnimationSetEventMap>(type: K, listener: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+        dispose: [];
+    }, K>, context?: unknown): void;
+    once<K extends "dispose" | keyof AnimationSetEventMap>(type: K, listener: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+        dispose: [];
+    }, K>, context?: unknown): void;
+    off<K extends "dispose" | keyof AnimationSetEventMap>(type: K, listener: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+        dispose: [];
+    }, K>, context?: unknown): void;
+    dispatchEvent<K extends "dispose" | keyof AnimationSetEventMap>(type: K, ...args: (AnimationSetEventMap & {
+        dispose: [];
+    })[K]): void;
+    _internalAddEventListener<K extends "dispose" | keyof AnimationSetEventMap>(listenerMap: Nullable<{
+        playbackstart?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackstart">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackloop?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackloop">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        marker?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "marker">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        frame?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "frame">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackcomplete?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackcomplete">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackstop?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackstop">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackpause?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackpause">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackresume?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackresume">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        dispose?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "dispose">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+    }>, type: K, listener: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+        dispose: [];
+    }, K>, options: _zephyr3d_base.REventHandlerOptions): Nullable<{
+        playbackstart?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackstart">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackloop?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackloop">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        marker?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "marker">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        frame?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "frame">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackcomplete?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackcomplete">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackstop?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackstop">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackpause?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackpause">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackresume?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackresume">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        dispose?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "dispose">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+    }>;
+    _internalRemoveEventListener<K extends "dispose" | keyof AnimationSetEventMap>(listenerMap: Nullable<{
+        playbackstart?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackstart">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackloop?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackloop">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        marker?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "marker">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        frame?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "frame">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackcomplete?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackcomplete">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackstop?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackstop">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackpause?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackpause">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        playbackresume?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "playbackresume">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+        dispose?: {
+            handler: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+                dispose: [];
+            }, "dispose">;
+            options: _zephyr3d_base.REventHandlerOptions;
+            removed: boolean;
+        }[] | undefined;
+    }>, type: K, listener: _zephyr3d_base.EventListener<AnimationSetEventMap & {
+        dispose: [];
+    }, K>, context: unknown): void;
+    _invokeLocalListeners<K extends "dispose" | keyof AnimationSetEventMap>(type: "dispose" | keyof AnimationSetEventMap, ...args: (AnimationSetEventMap & {
+        dispose: [];
+    })[K]): void;
+}) & typeof Disposable;
+declare class AnimationSet extends AnimationSet_base implements IDisposable {
     /**
      * Create an AnimationSet controlling the provided model.
      *
@@ -9927,6 +10358,22 @@ declare class AnimationSet extends Disposable implements IDisposable {
      * @param weight - New weight value used during blending.
      */
     setAnimationWeight(name: string, weight: number): void;
+    /**
+     * Create a playback handle without starting it.
+     */
+    createPlayback(name: string, options?: PlayAnimationOptions): AnimationPlayback | null;
+    /**
+     * Start an animation and return its playback handle.
+     */
+    play(name: string, options?: PlayAnimationOptions): AnimationPlayback | null;
+    /**
+     * Get currently active playbacks.
+     */
+    getPlaybacks(name?: string): AnimationPlayback[];
+    /**
+     * Get the currently active playback for a clip.
+     */
+    getPlayback(name: string): AnimationPlayback | null;
     /**
      * Start (or update) playback of an animation clip.
      *
@@ -9939,6 +10386,18 @@ declare class AnimationSet extends Disposable implements IDisposable {
      * @param options - Playback options (repeat, speedRatio, fadeIn).
      */
     playAnimation(name: string, options?: PlayAnimationOptions): void;
+    private resolvePlaybackSyncSource;
+    private resolveActivePlayback;
+    private computePlaybackInitialTime;
+    private getPlaybackEffectiveRange;
+    private constrainPlaybackTime;
+    private createPlaybackEvent;
+    private completePlayback;
+    private emitCrossedMarkers;
+    private emitCrossedFrames;
+    private getCrossedMarkers;
+    private crossedForward;
+    private crossedBackward;
     /**
      * Stop playback of an animation clip.
      *
@@ -10120,7 +10579,40 @@ declare abstract class AnimationTrack<StateType = unknown> {
 }
 
 /**
- * Animation clip
+ * A serializable reference to a point on an animation clip timeline.
+ * @public
+ */
+type AnimationTimeRef = number | {
+    time: number;
+} | {
+    frame: number;
+    fps?: number;
+} | {
+    marker: string;
+};
+/**
+ * Timeline marker metadata stored on an animation clip.
+ *
+ * Markers are data, not callbacks. Runtime systems may dispatch events when a
+ * playback cursor crosses the marker.
+ * @public
+ */
+type AnimationMarker = {
+    /** Stable marker id for editor and blueprint references. */
+    id?: string;
+    /** Display/event name. */
+    name: string;
+    /** Marker time in seconds. */
+    time?: number;
+    /** Marker frame. Converted with `fps` or the owning clip's `frameRate`. */
+    frame?: number;
+    /** Optional frame rate used for `frame` conversion. */
+    fps?: number;
+    /** Serializable user payload. */
+    payload?: unknown;
+};
+/**
+ * Animation clip
  *
  * Represents a named animation composed of multiple tracks targeting various objects/properties,
  * with an overall duration, weight, and optional auto-play behavior. Tracks may target different
@@ -10178,6 +10670,15 @@ declare class AnimationClip extends Disposable {
      */
     get skeletons(): Set<string>;
     set skeletons(val: Set<string>);
+    /**
+     * Default frame rate used to convert frame-based marker references.
+     */
+    get frameRate(): number;
+    set frameRate(val: number);
+    /**
+     * Timeline markers stored on this clip.
+     */
+    get markers(): AnimationMarker[];
     /**
      * Total time span of the clip in seconds.
      *
@@ -10185,6 +10686,29 @@ declare class AnimationClip extends Disposable {
      */
     get timeDuration(): number;
     set timeDuration(val: number);
+    /**
+     * Add a serializable marker to this clip.
+     *
+     * @param marker - Marker metadata. If `id` is omitted, `name` is used as the id.
+     * @returns The normalized marker.
+     */
+    addMarker(marker: AnimationMarker): AnimationMarker | null;
+    /**
+     * Remove markers matching the marker id or name.
+     */
+    removeMarker(idOrName: string): boolean;
+    /**
+     * Get the first marker matching the marker id or name.
+     */
+    getMarker(idOrName: string): AnimationMarker | null;
+    /**
+     * Resolve a marker to seconds on this clip's timeline.
+     */
+    resolveMarkerTime(marker: AnimationMarker): number | null;
+    /**
+     * Resolve a time reference to seconds on this clip's timeline.
+     */
+    resolveTimeRef(ref: AnimationTimeRef | null | undefined): number | null;
     /**
      * Add a skeleton used by this clip.
      *
@@ -10219,6 +10743,722 @@ declare class AnimationClip extends Disposable {
     addTrack(target: object, track: AnimationTrack): this;
 }
 
+/**
+ * How a response disposes of the timeline's currently active playbacks/steps.
+ * - `'stop'` (default): stop the active steps before running the response.
+ * - `'keep'`: leave the active steps running; the response runs concurrently.
+ * - `{ fadeOut }`: stop the active steps with a fade-out.
+ * @public
+ */
+type AnimationTimelineActiveDisposition = 'stop' | 'keep' | {
+    fadeOut: number;
+};
+/**
+ * Return target for controller state-transition responses.
+ *
+ * - `true`: return to the state that was active before the transition.
+ * - `string`: return to the named state.
+ *
+ * Only {@link AnimationController} state responses can perform the return; bare timeline runners
+ * report state-transition targets as unhandled so the controller can act on them.
+ * @public
+ */
+type AnimationTimelineStateReturnTarget = true | string;
+/**
+ * What a response does when its event fires. Exactly one variant applies.
+ * @public
+ */
+type AnimationTimelineEventTarget = {
+    /** Steps to run when the event is handled. */
+    steps: AnimationTimelineStep[];
+    /** Not used for step targets; keeps this union variant mutually exclusive. */
+    targetState?: undefined;
+    /** Not used for step targets; keeps this union variant mutually exclusive. */
+    returnTo?: undefined;
+    /** Not used for step targets; keeps this union variant mutually exclusive. */
+    returnTransition?: undefined;
+    /** Not used for step targets; keeps this union variant mutually exclusive. */
+    consume?: undefined;
+    /** Not used for step targets; keeps this union variant mutually exclusive. */
+    ignore?: undefined;
+} | {
+    /** Controller state name to transition to. */
+    targetState: string;
+    /**
+     * Optional state to enter when `targetState` completes.
+     *
+     * Use `true` to return to the state active before the transition, or a string to return to
+     * a specific named state. This is only applied by {@link AnimationController}.
+     */
+    returnTo?: AnimationTimelineStateReturnTarget;
+    /**
+     * Optional transition duration used when returning from `targetState`.
+     *
+     * If omitted, the return state's own transition setting is used.
+     */
+    returnTransition?: number;
+    /** Not used for state-transition targets; keeps this union variant mutually exclusive. */
+    steps?: undefined;
+    /** Not used for state-transition targets; keeps this union variant mutually exclusive. */
+    consume?: undefined;
+    /** Not used for state-transition targets; keeps this union variant mutually exclusive. */
+    ignore?: undefined;
+} | {
+    /** Consume the event without starting steps or changing state. */
+    consume: true;
+    /** Not used for consume targets; keeps this union variant mutually exclusive. */
+    steps?: undefined;
+    /** Not used for consume targets; keeps this union variant mutually exclusive. */
+    targetState?: undefined;
+    /** Not used for consume targets; keeps this union variant mutually exclusive. */
+    returnTo?: undefined;
+    /** Not used for consume targets; keeps this union variant mutually exclusive. */
+    returnTransition?: undefined;
+    /** Not used for consume targets; keeps this union variant mutually exclusive. */
+    ignore?: undefined;
+} | {
+    /** Explicitly ignore the event. */
+    ignore: true;
+    /** Not used for ignore targets; keeps this union variant mutually exclusive. */
+    steps?: undefined;
+    /** Not used for ignore targets; keeps this union variant mutually exclusive. */
+    targetState?: undefined;
+    /** Not used for ignore targets; keeps this union variant mutually exclusive. */
+    returnTo?: undefined;
+    /** Not used for ignore targets; keeps this union variant mutually exclusive. */
+    returnTransition?: undefined;
+    /** Not used for ignore targets; keeps this union variant mutually exclusive. */
+    consume?: undefined;
+};
+/**
+ * Resolved kind of action a dispatched event produced.
+ * @public
+ */
+type AnimationTimelineEventPolicy = 'none' | 'ignore' | 'consume' | 'steps' | 'enqueue' | 'transition';
+/**
+ * Result returned when a timeline or controller dispatches an event.
+ * @public
+ */
+type AnimationTimelineEventResult = {
+    /**
+     * Whether the event was consumed, converted into steps, enqueued, or accepted as a transition.
+     */
+    handled: boolean;
+    /**
+     * The action selected for the event.
+     */
+    policy: AnimationTimelineEventPolicy;
+    /**
+     * Dispatched event name.
+     */
+    event: string;
+    /**
+     * Optional payload supplied by the caller.
+     */
+    payload?: unknown;
+};
+/**
+ * A reaction to a gameplay event, declared on a timeline or a controller state.
+ *
+ * The model is orthogonal: `target` says *what* to do, `onActive` says what happens to the
+ * currently running steps, and `enqueue` defers `steps` instead of running them immediately.
+ * @public
+ */
+type AnimationTimelineEventResponse = {
+    /**
+     * Event name this response handles.
+     */
+    event: string;
+    /** What the event does. */
+    target: AnimationTimelineEventTarget;
+    /**
+     * Disposition of the currently active steps. Defaults to `'stop'`.
+     * Use `'keep'` with `target.steps` to run the new steps concurrently (true parallel branch).
+     * Ignored for `consume`/`ignore` targets.
+     */
+    onActive?: AnimationTimelineActiveDisposition;
+    /**
+     * When `true` and `target.steps` is set, the steps are appended to the queue and run after the
+     * current steps drain, instead of replacing/joining them. `onActive` is ignored.
+     */
+    enqueue?: boolean;
+};
+/**
+ * One executable instruction in an animation timeline.
+ * @public
+ */
+type AnimationTimelineStep = {
+    /** Start an animation clip playback. */
+    type: 'play';
+    /** Name of the animation clip to play from the owning AnimationSet. */
+    clip: string;
+    /**
+     * Optional local reference id used by later `target` fields in this runner.
+     *
+     * If a later step replaces the same logical playback and future responses should keep using
+     * this name, assign the same id again on the replacement `play` step.
+     */
+    id?: string;
+    /** Playback options passed to `AnimationSet.play`. */
+    options?: PlayAnimationOptions;
+    /**
+     * Whether to block the timeline on this playback before advancing to the next step.
+     * - `'complete'`: wait until the playback completes or is stopped.
+     * - `false` or omitted (default): start the playback and immediately continue.
+     *
+     * A clip that loops forever (`repeat: 0`) only completes when stopped, so combine
+     * `wait: 'complete'` with a finite `repeat`/`range` or an external stop.
+     */
+    wait?: 'complete' | false;
+} | {
+    /** Stop a playback owned by this runner. */
+    type: 'stop';
+    /**
+     * Optional playback target id.
+     *
+     * When omitted, all playbacks owned by the current runner are stopped.
+     */
+    target?: string;
+    /** Stop behavior passed to the matching playback or playbacks. */
+    options?: StopAnimationOptions;
+} | {
+    /** Wait for a fixed duration. */
+    type: 'wait';
+    /** Number of seconds to wait before continuing. */
+    seconds: number;
+} | {
+    /** Wait until a matching event is dispatched to the runner. */
+    type: 'waitEvent';
+    /** Event name that releases the wait. */
+    event: string;
+} | {
+    /** Wait until a playback crosses a marker. */
+    type: 'waitMarker';
+    /** Marker id or name to wait for. */
+    marker: string;
+    /** Optional playback target id; defaults to the current playback in scope. */
+    target?: string;
+} | {
+    /** Wait until a playback crosses a frame number. */
+    type: 'waitFrame';
+    /** Frame number to wait for. */
+    frame: number;
+    /** Optional playback target id; defaults to the current playback in scope. */
+    target?: string;
+} | {
+    /** Emit a timeline event through the runner. */
+    type: 'emit';
+    /** Event name emitted to runner listeners. */
+    event: string;
+    /** Optional payload emitted with the event. */
+    payload?: unknown;
+} | {
+    /** Execute child steps sequentially. */
+    type: 'sequence';
+    /** Child steps run in order. */
+    steps: AnimationTimelineStep[];
+} | {
+    /** Execute child steps as parallel branches. */
+    type: 'parallel';
+    /** Child steps that become isolated parallel branches. */
+    steps: AnimationTimelineStep[];
+};
+/**
+ * Serializable timeline definition.
+ * @public
+ */
+type AnimationTimelineDefinition = {
+    /**
+     * Root sequence of timeline steps.
+     */
+    steps: AnimationTimelineStep[];
+    /**
+     * Optional responses evaluated when dispatched events are not consumed by waiters.
+     */
+    responses?: AnimationTimelineEventResponse[];
+};
+/**
+ * Event map emitted by {@link AnimationTimelineRunner}.
+ * @public
+ */
+type AnimationTimelineRunnerEventMap = {
+    /**
+     * Emitted when the runner drains all main, concurrent, and queued work.
+     */
+    complete: [runner: AnimationTimelineRunner];
+    /**
+     * Emitted when an active runner is explicitly stopped.
+     */
+    stop: [runner: AnimationTimelineRunner];
+    /**
+     * Emitted by an `emit` timeline step.
+     */
+    emit: [event: string, payload: unknown];
+};
+/**
+ * Serializable snapshot of a runner's runtime state.
+ *
+ * References to playbacks are by id; restoring playbacks themselves is the caller's
+ * responsibility (replay should re-create the active playbacks before deserializing).
+ * @public
+ */
+type AnimationTimelineRunnerState = {
+    /**
+     * Serialized main control-flow stack.
+     */
+    stack: SerializedFrame[];
+    /**
+     * Serialized concurrent branches started with `keep` responses.
+     */
+    concurrent: SerializedFrame[];
+    /**
+     * Queued step batches waiting for the main stack to drain.
+     */
+    queued: AnimationTimelineStep[][];
+    /** Ids of playbacks owned by concurrent (keep-active) branches that have already drained. */
+    concurrentPlaybackIds: string[];
+    /**
+     * Runner-level playback references preserved after the frame that created them has drained.
+     */
+    playbackRefs?: Record<string, string>;
+    /**
+     * Whether the runner was stopped when the state was captured.
+     */
+    stopped: boolean;
+};
+/**
+ * A scope tracks the "current playback" and named refs for a sequence of steps. Parallel branches
+ * each own an isolated scope so their `waitMarker`/`waitFrame` resolve deterministically.
+ *
+ * `owner` records whether the scope belongs to the main control flow or a concurrent (keep-active)
+ * branch, so a main-flow replacement does not stop the independent concurrent tracks.
+ */
+type FrameScope = {
+    currentPlaybackId: string | null;
+    refs: Record<string, string>;
+    owner: 'main' | 'concurrent';
+};
+type SeqFrame = {
+    kind: 'seq';
+    steps: AnimationTimelineStep[];
+    index: number;
+    scope: FrameScope;
+    child: TimelineFrame | null;
+};
+type ParallelFrame = {
+    kind: 'parallel';
+    branches: TimelineFrame[];
+};
+type WaitFrame = {
+    kind: 'wait';
+    remaining: number;
+};
+type WaitEventFrame = {
+    kind: 'waitEvent';
+    event: string;
+};
+type WaitMarkerFrame = {
+    kind: 'waitMarker';
+    marker: string;
+    playbackId: string | null;
+    satisfied: boolean;
+};
+type WaitFrameFrame = {
+    kind: 'waitFrame';
+    frame: number;
+    playbackId: string | null;
+    satisfied: boolean;
+};
+type PlayWaitFrame = {
+    kind: 'playWait';
+    playbackId: string;
+};
+type TimelineFrame = SeqFrame | ParallelFrame | WaitFrame | WaitEventFrame | WaitMarkerFrame | WaitFrameFrame | PlayWaitFrame;
+/** Plain-data form of a frame (no live playback references), used by serialize/deserialize. */
+type SerializedFrame = TimelineFrame;
+/**
+ * Serializable animation timeline definition.
+ * @public
+ */
+declare class AnimationTimeline {
+    /**
+     * Root step sequence executed by runners created from this timeline.
+     */
+    readonly steps: AnimationTimelineStep[];
+    /**
+     * Event responses declared on this timeline.
+     */
+    readonly responses: AnimationTimelineEventResponse[];
+    /**
+     * Create a timeline from a definition object or a root step array.
+     *
+     * @param definition - Timeline definition, or a shorthand array used as the root steps.
+     */
+    constructor(definition: AnimationTimelineDefinition | AnimationTimelineStep[]);
+    /**
+     * Create a runtime runner for this timeline.
+     *
+     * @param animationSet - Animation set used to create and update playbacks.
+     * @returns A new stopped runner bound to this timeline and animation set.
+     */
+    createRunner(animationSet: AnimationSet): AnimationTimelineRunner;
+}
+/**
+ * Runtime interpreter for an AnimationTimeline.
+ *
+ * The interpreter is a synchronous frame-stack state machine advanced by {@link tick}, which is
+ * driven by `AnimationSet.update(dt)` on the same logical clock as the animations. There is no
+ * `async`/`await` in the control flow, so the runtime state can be serialized and replayed.
+ * @public
+ */
+declare class AnimationTimelineRunner extends Observable<AnimationTimelineRunnerEventMap> {
+    /**
+     * Animation set used to start, stop, and query animation playbacks.
+     */
+    readonly animationSet: AnimationSet;
+    /**
+     * Timeline definition interpreted by this runner.
+     */
+    readonly timeline: AnimationTimeline;
+    private _stack;
+    private _concurrent;
+    private readonly _queued;
+    private _pendingEvents;
+    private _stopped;
+    private _ticking;
+    private _lastCompletedPlaybackId;
+    private readonly _onTick;
+    /** Tracks playbacks created by this runner so `stop()` can tear them down. */
+    private readonly _ownedPlaybacks;
+    /** Local playback refs that survive after the sequence frame that declared them drains. */
+    private readonly _playbackRefs;
+    /** Ids of playbacks owned by concurrent (keep-active) branches; preserved across main-flow stops. */
+    private readonly _concurrentPlaybackIds;
+    /** Marker/frame crossings observed since the last tick, keyed by playback id. */
+    private readonly _crossedMarkers;
+    private readonly _crossedFrames;
+    /**
+     * Create a stopped runner for a timeline.
+     *
+     * @param animationSet - Animation set that owns clips and playbacks referenced by the timeline.
+     * @param timeline - Timeline definition to interpret.
+     */
+    constructor(animationSet: AnimationSet, timeline: AnimationTimeline);
+    /**
+     * Playback currently referenced by the active main-flow scope.
+     *
+     * @returns The current playback, or null when the main flow has no active playback reference.
+     */
+    get currentPlayback(): AnimationPlayback | null;
+    /**
+     * Whether this runner is stopped.
+     *
+     * @returns True when the runner is stopped; otherwise false.
+     */
+    get stopped(): boolean;
+    /**
+     * Playback id for the most recent playback that completed naturally.
+     *
+     * @returns The playback id, or null when no owned playback has completed.
+     */
+    get lastCompletedPlaybackId(): string | null;
+    /**
+     * Start or restart the runner from the beginning of the timeline.
+     *
+     * @returns This runner for chaining.
+     */
+    start(): this;
+    /**
+     * Stop the runner and all playbacks it owns.
+     *
+     * @param options - Optional stop behavior applied to owned playbacks.
+     * @returns This runner for chaining.
+     */
+    stop(options?: StopAnimationOptions): this;
+    /**
+     * Append a batch of steps to run after the main stack drains.
+     *
+     * If the runner has already completed, enqueueing steps revives it and registers it for ticking.
+     *
+     * @param steps - Steps to run as the next queued batch.
+     * @returns void
+     */
+    enqueue(steps: AnimationTimelineStep[]): void;
+    /**
+     * Run `steps` concurrently with the current control flow (a true parallel branch). Unlike
+     * {@link enqueue}, these do not wait for the main stack to drain.
+     *
+     * @param steps - Steps to run immediately in an independent concurrent branch.
+     * @returns void
+     * @public
+     */
+    runConcurrent(steps: AnimationTimelineStep[]): void;
+    /**
+     * Dispatch an event to this runner.
+     *
+     * Waiting `waitEvent` frames consume matching events first. If no waiter consumes the event,
+     * the timeline response table is evaluated.
+     *
+     * @param event - Event name to dispatch.
+     * @param payload - Optional payload returned in the result.
+     * @returns The resolved handling result for the event.
+     */
+    dispatch(event: string, payload?: unknown): AnimationTimelineEventResult;
+    /**
+     * Run pending non-blocking work synchronously (a zero-delta tick), without advancing any
+     * time-based waits. Lets `start()`/`dispatch()` take effect immediately while keeping all
+     * runtime state in the serializable frame stack.
+     *
+     * @returns This runner for chaining.
+     * @public
+     */
+    flush(): this;
+    /**
+     * Advance the timeline by `deltaInSeconds`. Called by `AnimationSet.update`.
+     *
+     * @param deltaInSeconds - Elapsed time in seconds for this tick.
+     * @returns void
+     * @public
+     */
+    tick(deltaInSeconds: number): void;
+    /**
+     * Export the runtime state as plain data.
+     *
+     * @returns A serializable snapshot of the runner state.
+     * @public
+     */
+    serialize(): AnimationTimelineRunnerState;
+    /**
+     * Restore runtime state previously produced by {@link serialize}.
+     *
+     * Re-create the relevant active playbacks on the AnimationSet before calling this so that
+     * playback-bound frames (play-wait, waitMarker, waitFrame) can re-attach by id.
+     *
+     * @param animationSet - Animation set containing any live playbacks referenced by the state.
+     * @param timeline - Timeline definition to bind to the restored runner.
+     * @param state - Serialized state previously returned by {@link serialize}.
+     * @returns A runner restored to the supplied runtime state.
+     * @public
+     */
+    static deserialize(animationSet: AnimationSet, timeline: AnimationTimeline, state: AnimationTimelineRunnerState): AnimationTimelineRunner;
+    private ensureTicking;
+    private makeSeqFrame;
+    /** The scope of the innermost active sequence on the main stack (for currentPlayback). */
+    private activeScope;
+    private deepestScope;
+    /**
+     * Advance a frame stack in place. The top frame runs until it blocks or completes; completed
+     * frames pop and the parent sequence advances. Returns when the stack blocks or empties.
+     */
+    private tickFrames;
+    /**
+     * Same as {@link tickFrames} but returns the time left unconsumed when the stack drains
+     * completely (so a parent sequence can hand it to its next step).
+     */
+    private tickFramesWithLeftover;
+    private tickFrame;
+    private tickSeq;
+    private tickParallel;
+    /**
+     * Execute a non-blocking step immediately and return null, or return a frame to block on.
+     */
+    private beginStep;
+    private resolvePlayOptions;
+    private resolvePlaybackRef;
+    private tickWaitMarker;
+    private tickWaitFrame;
+    private tickPlayWait;
+    private attachPlayback;
+    private detachPlayback;
+    private forgetPlayback;
+    /**
+     * Cleanup when an owned playback ends (externally or naturally). Only touches runner-local
+     * bookkeeping, so it is safe to run inside `AnimationSet.update`'s playback loop. Frames blocked
+     * on this playback observe its absence on the next tick and unblock.
+     */
+    private readonly onPlaybackEnd;
+    private readonly onPlaybackComplete;
+    private readonly onPlaybackMarker;
+    private readonly onPlaybackFrame;
+    private resolvePlayback;
+    private forgetPlaybackRefs;
+    private scopeCurrentPlayback;
+    private hasWaiterFor;
+    /** Stop only the main control flow (used when a response replaces it). */
+    private stopMainFlow;
+    private collectScopePlaybackIds;
+    private cloneFrame;
+    private reattachPlaybacks;
+    private collectAllPlaybackIds;
+    private findLivePlayback;
+}
+
+/**
+ * Definition of a named animation controller state.
+ * @public
+ */
+type AnimationControllerStateDefinition = {
+    /**
+     * Timeline executed when the controller enters this state.
+     */
+    timeline: AnimationTimelineDefinition;
+    /**
+     * Optional state-local responses evaluated after the active timeline does not handle a
+     * dispatched event.
+     */
+    responses?: AnimationTimelineEventResponse[];
+    /**
+     * Default cross-fade duration (seconds) applied when transitioning *into* this state.
+     * The outgoing state fades out and this state's first `play` step fades in over this time.
+     */
+    transition?: number;
+};
+/**
+ * Options used when switching the controller to another state.
+ * @public
+ */
+type AnimationControllerSetStateOptions = {
+    /** Cross-fade duration (seconds). Overrides the target state's own `transition`. */
+    transition?: number;
+    /**
+     * Optional phase synchronization source applied to entry play steps that do not already define
+     * their own `options.sync`.
+     */
+    sync?: AnimationPlaybackSyncOptions;
+    /** Re-enter the state even if it is already current. Defaults to false (no-op on same state). */
+    force?: boolean;
+    /** Stop options for the outgoing state when no cross-fade is used. */
+    stop?: StopAnimationOptions;
+    /**
+     * Optional state to enter when the target state completes.
+     *
+     * Use `true` to return to the state active before this transition, or a string to return to a
+     * specific named state.
+     */
+    returnTo?: AnimationTimelineStateReturnTarget;
+    /**
+     * Optional transition duration used when returning from the target state.
+     *
+     * If omitted, the return state's own transition setting is used.
+     */
+    returnTransition?: number;
+};
+/**
+ * Event map emitted by {@link AnimationController}.
+ * @public
+ */
+type AnimationControllerEventMap = {
+    /**
+     * Emitted after the current state changes.
+     *
+     * The first argument is the new state name, or null when stopped. The second argument is the
+     * previous state name, or null when there was no previous state.
+     */
+    statechange: [state: string | null, previousState: string | null];
+    /**
+     * Emitted when the active state's timeline runner drains all main, concurrent, and queued work.
+     */
+    statecomplete: [state: string];
+    /** Forwarded from the active state's timeline runner, so listeners need not rebind per state. */
+    emit: [event: string, payload: unknown];
+    /**
+     * Emitted for every call to {@link AnimationController.dispatch} with the resolved event result.
+     */
+    event: [event: string, payload: unknown, result: AnimationTimelineEventResult];
+};
+/**
+ * Event-driven animation state controller.
+ *
+ * Each state owns one serializable timeline. External gameplay events are dispatched to the
+ * current timeline first, then to the current state's response table, so different states can
+ * respond to the same event differently.
+ * @public
+ */
+declare class AnimationController extends Observable<AnimationControllerEventMap> {
+    /**
+     * Animation set used to create playbacks for all state timelines.
+     */
+    readonly animationSet: AnimationSet;
+    private readonly _states;
+    private _currentState;
+    private _runner;
+    private _onRunnerComplete;
+    private _onRunnerEmit;
+    /**
+     * Create a controller for an animation set.
+     *
+     * @param animationSet - Animation set that owns the clips and active playbacks.
+     */
+    constructor(animationSet: AnimationSet);
+    /**
+     * Current state name.
+     *
+     * @returns The active state name, or null when the controller is stopped or has not entered a state.
+     */
+    get currentState(): string | null;
+    /**
+     * Current timeline runner.
+     *
+     * @returns The active timeline runner, or null when no state is running.
+     */
+    get runner(): AnimationTimelineRunner | null;
+    /**
+     * Register or replace a named state definition.
+     *
+     * @param name - Unique state name.
+     * @param definition - Timeline and event response configuration for the state.
+     * @returns This controller for chaining.
+     */
+    addState(name: string, definition: AnimationControllerStateDefinition): this;
+    /**
+     * Test whether a state has been registered.
+     *
+     * @param name - State name to look up.
+     * @returns True if the controller contains a state with the given name; otherwise false.
+     */
+    hasState(name: string): boolean;
+    /**
+     * Enter a registered state.
+     *
+     * If the requested state is already current and `options.force` is not set, this returns the
+     * existing runner without restarting the timeline. When a transition duration is provided, the
+     * previous runner fades out while the entry plays of the new state fade in.
+     *
+     * @param name - State name to enter.
+     * @param options - Optional transition, re-entry, and stop behavior.
+     * @returns The active runner for the entered state, or null if the state does not exist.
+     */
+    setState(name: string, options?: AnimationControllerSetStateOptions): AnimationTimelineRunner | null;
+    /**
+     * Dispatch a gameplay event to the active state.
+     *
+     * The active timeline receives the event first. If it does not handle the event, the current
+     * state's response table may consume it, enqueue or run steps, or transition to another state.
+     *
+     * @param event - Event name to dispatch.
+     * @param payload - Optional event payload passed through result notifications.
+     * @returns The resolved handling result for the event.
+     */
+    dispatch(event: string, payload?: unknown): AnimationTimelineEventResult;
+    /**
+     * Stop the active state and clear the current state.
+     *
+     * @param options - Optional stop behavior applied to playbacks owned by the active runner.
+     * @returns void
+     */
+    stop(options?: StopAnimationOptions): void;
+    /**
+     * Stop playback and remove all registered states.
+     *
+     * @returns void
+     */
+    dispose(): void;
+    private emitResult;
+    private resolveReturnTarget;
+    private attachRunner;
+    private detachRunner;
+}
+
 /**
  * Translate animation track
  * @public
@@ -26387,4 +27627,4 @@ declare const ATMOSPHERIC_FOG_BIT: number;
  */
 declare const HEIGHT_FOG_BIT: number;
 
-export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, type AngleLimitConfig, AnimationClip, AnimationSet, AnimationTrack, AnyConditionNode, type AppCreationOptions, type AppOptions, Application, type ApplyResultOutput, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, type AssetAnimationData, type AssetAnimationTrack, type AssetFixedGeometryCacheAnimationTrack, type AssetGeometryCacheAnimationTrack, type AssetGeometryCacheFrame, AssetHierarchyNode, type AssetImageInfo, type AssetJointDynamicsChain, type AssetJointDynamicsCollider, type AssetJointDynamicsFlatPlane, type AssetJointDynamicsSpringBone, type AssetMToonMaterial, AssetManager, type AssetMaterial, type AssetMaterialClearcoat, type AssetMaterialCommon, type AssetMaterialIridescence, type AssetMaterialSheen, type AssetMaterialTransmission, type AssetMeshData, type AssetMorphTargetBinding, type AssetMorphTargetGroup, type AssetPBRMaterialCommon, type AssetPBRMaterialMR, type AssetPBRMaterialSG, type AssetPCAGeometryCacheAnimationTrack, type AssetPrimitiveInfo, type AssetRotationTrack, type AssetSamplerInfo, type AssetScaleTrack, AssetScene, type AssetSkeletalAnimationTrack, AssetSkeleton, type AssetSpringBone, type AssetSpringBoneCollider, type AssetSpringBoneColliderGroup, type AssetSpringBoneColliderShape, type AssetSpringBoneJoint, type AssetSubMeshData, type AssetTextureInfo, type AssetTranslationTrack, type AssetUnlitMaterial, type AssetVertexBufferInfo, type AvatarBindMode, type AvatarBodyRegionTarget, type AvatarBodyRegions, type AvatarEquipOptions, type AvatarFitMode, type AvatarJointMap, AvatarOutfitInstance, type AvatarOutfitSource, type AvatarOutfitValidation, type AvatarSlotId, type AvatarSlotOptions, AvatarWardrobe, type AvatarWardrobeOptions, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, type BaseFetchOptions, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, type BatchDrawable, BatchGroup, BillboardMatrixNode, type BlendMode, BlinnMaterial, type BlitType, Blitter, Bloom, type BluePrintEditorState, type BluePrintUniformTexture, type BluePrintUniformValue, type BlueprintDAG, type BoneNode, BoundingBox, type BoundingVolume, type BoxCreationOptions, BoxFilterBlitter, BoxFrameShape, BoxShape, CCDSolver, type CachedBindGroup, Camera, type CameraHistoryData, CameraNearFarNode, type CameraOITMode, CameraPositionNode, CameraVectorNode, type CapsuleCollider, type CapsuleCreationOptions, CapsuleShape, CeilNode, ClampNode, ClipmapTerrain, ClipmapTerrainMaterial, ColliderForce, type ColliderR, type ColliderRW, type CollisionResult, ColorAdjust, type ColoredEdge, type ColoredLineEdge, type ColoredQuadraticEdge, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, type ComparisonMode, Compositor, type CompositorContext, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, type Constraint, type ConstraintBuildOptions, ConstraintType, type ControllerConfig, type ControllerConfigUpdate, CopyBlitter, type CopyHumanoidAnimationOptions, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, type CylinderCreationOptions, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, type DrawContext, type Drawable, type DrawableInstanceInfo, EPSILON, type EdgeColor, type EditorMode, ElapsedTimeNode, type EmitterBehavior, type EmitterShape, Engine, EnvConstantAmbient, EnvHemisphericAmbient, type EnvLightType, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, type ExtractMixinReturnType, type ExtractMixinType, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, type FPSCameraControllerOptions, FWidthNode, FXAA, FaceForwardNode, type FixedGeometryCacheFrame, type FixedGeometryCacheState, FixedGeometryCacheTrack, type FlatPlane, FloorNode, FmaNode, type FogType, FontAsset, type FontAssetFetchOptions, type FontAssetMSDFAtlasSettings, type FontMetrics, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GPUClothSystem, type GPUClothSystemOptions, type GPUClothWrapBindingData, type GPUClothWrapBindingTarget, GaussianBlurBlitter, GenericMathNode, type GeometryCacheFrame, type GeometryCacheMeshBinding, type GeometryCacheState, GerstnerWaveGenerator, type GlyphContour, type GlyphData, type GlyphPoint, type GrabberR, type GrabberRW, GraphNode, type GraphNodeInput, type GraphNodeOutput, type GraphStructure, type GrassInstanceInfo, GrassLayer, GrassMaterial, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, HistoryResourceManager, type Host, HumanoidBodyRig, HumanoidHandRig, type HumanoidJointMapping, type HumanoidRetargetAxisLocks, type HumanoidRootMotionMode, type HumanoidRootMotionScaleMode, type HumanoidSkeletalAnimationMaskOptions, type HumanoidSkeletalAnimationMaskPreset, type IAttachedScript, type IBaseEvent, type IControllerKeyboardEvent, type IControllerKeydownEvent, type IControllerKeypressEvent, type IControllerKeyupEvent, type IControllerMouseEvent, type IControllerPointerCancelEvent, type IControllerPointerDownEvent, type IControllerPointerMoveEvent, type IControllerPointerUpEvent, type IControllerWheelEvent, type IGraphNode, IKAngleConstraint, IKChain, IKConstraint, type IKJoint, IKModifier, IKSolver, type IMixinAlbedoColor, type IMixinBlinnPhong, type IMixinFoliage, type IMixinLambert, type IMixinLight, type IMixinPBRBluePrint, type IMixinPBRCommon, type IMixinPBRMetallicRoughness, type IMixinPBRSpecularGlossiness, type IMixinVertexColor, type IModKey, type IRUniformTexture, type IRUniformValue, type IRenderHook, type IRenderable, type InputEventHandler, InputManager, InstanceBindGroupAllocator, type InstanceData, InstanceIndexNode, type InstanceUniformType, type InterChainConstraint, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, type JointChainConfig, type JointDynamicSystemConfig, type JointDynamicsColliderHandle, type JointDynamicsColliderSnapshot, type JointDynamicsFlatPlaneHandle, type JointDynamicsFlatPlaneSnapshot, type JointDynamicsGrabberHandle, type JointDynamicsGrabberSnapshot, JointDynamicsModifier, JointDynamicsSystem, JointDynamicsSystemController, type JointNameMatcher, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, type LineCollisionResult, Log2Node, type LogMode, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, type MSDFBitmap, type MSDFOptions, type MSDFShape, MSDFText, MSDFTextAtlasManager, MSDFTextSprite, MToonMaterial, type MToonOutlineWidthMode, MakeVectorNode, Material, MaterialBlueprintIR, type MaterialBlueprintIRBehaviors, type MaterialTextureInfo, MaterialVaryingFlags, MaxNode, Mesh$1 as Mesh, MeshMaterial, type MeshUpdateCallback, type Metadata$1 as Metadata, MinNode, MixNode, ModNode, type ModelFetchOptions, type ModelInfo, type ModelLoader, type MorphBoundingInfo, type MorphData, type MorphInfo, type MorphState, MorphTargetTrack, MultiChainSpringSystem, type MultiChainSpringSystemOptions, type NamedJointsSkeletalAnimationMaskOptions, NamedObject, type NearestPointsResult, type NodeConnection, NodeEulerRotationTrack, type NodeIterateFunc, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, type OIT, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, type OrbitCameraControllerOptions, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, type PBRBlueprintOutputName, PBRMetallicRoughnessMaterial, type PBRReflectionMode, PBRSpecularGlossinessMaterial, type PCAGeometryCacheState, PCAGeometryCacheTrack, type PCAGeometryCacheTrackData, type PairAdjustment, PannerNode, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, type PhysicsCurves, type PickResult, type PickTarget, PixelNormalNode, PixelWorldPositionNode, type PlaneCollider, type PlaneCreationOptions, PlaneShape, type PlayAnimationOptions, type PointInit, PointLight, type PointR, type PointRW, type PointTransform, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, type PropEdit, type PropertyAccessor, type PropertyAccessorOptions, type PropertySceneNodeOptions, type PropertyToType, PropertyTrack, type PropertyType, type PropertyValue, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, Radians2DegreesNode, RaycastVisitor, RectLight, ReflectNode, RefractNode, type RenderFunc, type RenderItemList, type RenderItemListBundle, type RenderItemListInfo, RenderPass, type RenderPath, RenderQueue, type RenderQueueItem, type RenderQueueRef, RenderTarget, type ResolutionTransform, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RotateAboutAxisNode, RuntimeScript, type RuntimeScriptArrayDeclaration, type RuntimeScriptArrayElementDeclaration, type RuntimeScriptConfig, type RuntimeScriptObjectDeclaration, type RuntimeScriptObjectFieldDeclaration, type RuntimeScriptPropertyDeclaration, type RuntimeScriptPropertyInfo, type RuntimeScriptPropertyOptions, type RuntimeScriptPropertyType, type RuntimeScriptValueDeclaration, type RuntimeScriptValueType, SAO, type SSSDebugView, type SSSQualityPreset, type SSSResolvedSettings, type SamplerType, SaturateNode, type SaveOptions, Scene, type SceneMorphTargetBinding, type SceneMorphTargetGroup, SceneNode, type SceneNodeVisible, ScreenAdapter, type ScreenConfig, ScreenRenderTarget, type ScreenScaleMode, ScriptAttachment, type ScriptAttachmentConfig, ScriptRegistry, ScriptingSystem, type ScriptingSystemOptions, SelectionNode, type SerializableClass, type SerializedMorphTargetBinding, type SerializedMorphTargetGroup, ShaderHelper, ShadowMapPass, ShadowMapper, type ShadowMode, type ShadowQualityPreset, ShadowRegion, Shape, type ShapeCreationOptions, type ShapeOptionType, type ShapeType, SharedModel, SignNode, SimplexNoise2DNode, type SimulationParams, SinHNode, SinNode, type SkeletalAnimationMaskCommonOptions, type SkeletalAnimationMaskOptions, type SkeletalAnimationMaskRootMotionMode, type SkeletalAnimationMaskUnsupportedTrackMode, Skeleton, type SkeletonBindPose, SkeletonModifier, SkeletonRig, type SkeletonRigOptions, SkinBinding, type SkinnedBoundingBox, SkyEnvTextureNode, SkyRenderer, type SkyType, SmoothStepNode, type SphereCollider, type SphereCreationOptions, SphereShape, SpotLight, SpringChain, type SpringCollider, type SpringConstraint, SpringModifier, type SpringParticle, SpringSystem, type SpringSystemOptions, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, type StopAnimationOptions, SubsurfaceProfile, type SubsurfaceProfilePreset, type SurfaceCheckResult, SwizzleNode, TanHNode, TanNode, type TerrainDebugMode, type TetrahedronCreationOptions, TetrahedronFrameShape, TetrahedronShape, TextSprite, type TextureFetchOptions, type TextureMixinInstanceTypes, type TextureMixinTypes, type TextureProp, type TexturePropUniforms, TextureSampleGrad, TextureSampleNode, type ToMixedTextureType, Tonemap, type TorusCreationOptions, TorusShape, type TransformAccess, TransformNode, type TwistConstraint, TwoBoneIKSolver, UnlitMaterial, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexIndexNode, VertexNormalNode, VertexOutputNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, type Visitor, Water, type WaveGenerator, WeightedBlendedOIT, applyAngleLimits, applyMaterialMixins, applyResult, applyRuntimeScriptConfig, buildConstraints, buildMSDFShape, buildSurfaceFaces, checkSurfaceCollision, collisionDetection, collisionDetectionCapsule, collisionDetectionSphere, computeMaxDepth, computeNearestPoints, createCapsuleCollider, createGPUClothWrapBindingData, createGeometryCacheState, createPlaneCollider, createSphereCollider, createSpringConstraint, createSpringParticle, createTransformAccess, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, ensureGeometryCacheMeshBinding, fetchSampler, gammaToLinear, generateMSDF, getApp, getDevice, getEngine, getInput, getRuntimeScriptProperties, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, interleavedGradientNoise, isGPUClothSupported, linearToGamma, mixGeometryCacheBoundingBox, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, noise3D, normalizeRuntimeScriptConfig, normalizeScriptAttachmentConfig, normalizeScriptAttachments, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, pushInCollisionDetection, pushInFromCapsule, pushInFromCollider, pushInFromSphere, pushoutFromCapsule, pushoutFromCollider, pushoutFromSphere, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, restoreGeometryCacheMeshBinding, scriptProp, simulate, smoothNoise3D, sortRootPointsByProximity, temporalResolve, tryGetApp, updateColliderFromNode, valueNoise, whiteNoise, worleyFBM, worleyNoise };
+export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, type AngleLimitConfig, AnimationClip, AnimationController, type AnimationControllerEventMap, type AnimationControllerSetStateOptions, type AnimationControllerStateDefinition, type AnimationFrameEvent, type AnimationMarker, type AnimationMarkerEvent, AnimationPlayback, type AnimationPlaybackEvent, type AnimationPlaybackEventMap, type AnimationPlaybackState, type AnimationPlaybackStopEvent, type AnimationPlaybackSyncMode, type AnimationPlaybackSyncOptions, AnimationSet, type AnimationSetEventMap, type AnimationStopReason, type AnimationTimeRef, AnimationTimeline, type AnimationTimelineActiveDisposition, type AnimationTimelineDefinition, type AnimationTimelineEventPolicy, type AnimationTimelineEventResponse, type AnimationTimelineEventResult, type AnimationTimelineEventTarget, AnimationTimelineRunner, type AnimationTimelineRunnerEventMap, type AnimationTimelineRunnerState, type AnimationTimelineStateReturnTarget, type AnimationTimelineStep, AnimationTrack, AnyConditionNode, type AppCreationOptions, type AppOptions, Application, type ApplyResultOutput, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, type AssetAnimationData, type AssetAnimationTrack, type AssetFixedGeometryCacheAnimationTrack, type AssetGeometryCacheAnimationTrack, type AssetGeometryCacheFrame, AssetHierarchyNode, type AssetImageInfo, type AssetJointDynamicsChain, type AssetJointDynamicsCollider, type AssetJointDynamicsFlatPlane, type AssetJointDynamicsSpringBone, type AssetMToonMaterial, AssetManager, type AssetMaterial, type AssetMaterialClearcoat, type AssetMaterialCommon, type AssetMaterialIridescence, type AssetMaterialSheen, type AssetMaterialTransmission, type AssetMeshData, type AssetMorphTargetBinding, type AssetMorphTargetGroup, type AssetPBRMaterialCommon, type AssetPBRMaterialMR, type AssetPBRMaterialSG, type AssetPCAGeometryCacheAnimationTrack, type AssetPrimitiveInfo, type AssetRotationTrack, type AssetSamplerInfo, type AssetScaleTrack, AssetScene, type AssetSkeletalAnimationTrack, AssetSkeleton, type AssetSpringBone, type AssetSpringBoneCollider, type AssetSpringBoneColliderGroup, type AssetSpringBoneColliderShape, type AssetSpringBoneJoint, type AssetSubMeshData, type AssetTextureInfo, type AssetTranslationTrack, type AssetUnlitMaterial, type AssetVertexBufferInfo, type AvatarBindMode, type AvatarBodyRegionTarget, type AvatarBodyRegions, type AvatarEquipOptions, type AvatarFitMode, type AvatarJointMap, AvatarOutfitInstance, type AvatarOutfitSource, type AvatarOutfitValidation, type AvatarSlotId, type AvatarSlotOptions, AvatarWardrobe, type AvatarWardrobeOptions, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, type BaseFetchOptions, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, type BatchDrawable, BatchGroup, BillboardMatrixNode, type BlendMode, BlinnMaterial, type BlitType, Blitter, Bloom, type BluePrintEditorState, type BluePrintUniformTexture, type BluePrintUniformValue, type BlueprintDAG, type BoneNode, BoundingBox, type BoundingVolume, type BoxCreationOptions, BoxFilterBlitter, BoxFrameShape, BoxShape, CCDSolver, type CachedBindGroup, Camera, type CameraHistoryData, CameraNearFarNode, type CameraOITMode, CameraPositionNode, CameraVectorNode, type CapsuleCollider, type CapsuleCreationOptions, CapsuleShape, CeilNode, ClampNode, ClipmapTerrain, ClipmapTerrainMaterial, ColliderForce, type ColliderR, type ColliderRW, type CollisionResult, ColorAdjust, type ColoredEdge, type ColoredLineEdge, type ColoredQuadraticEdge, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, type ComparisonMode, Compositor, type CompositorContext, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, type Constraint, type ConstraintBuildOptions, ConstraintType, type ControllerConfig, type ControllerConfigUpdate, CopyBlitter, type CopyHumanoidAnimationOptions, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, type CylinderCreationOptions, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, type DrawContext, type Drawable, type DrawableInstanceInfo, EPSILON, type EdgeColor, type EditorMode, ElapsedTimeNode, type EmitterBehavior, type EmitterShape, Engine, EnvConstantAmbient, EnvHemisphericAmbient, type EnvLightType, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, type ExtractMixinReturnType, type ExtractMixinType, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, type FPSCameraControllerOptions, FWidthNode, FXAA, FaceForwardNode, type FixedGeometryCacheFrame, type FixedGeometryCacheState, FixedGeometryCacheTrack, type FlatPlane, FloorNode, FmaNode, type FogType, FontAsset, type FontAssetFetchOptions, type FontAssetMSDFAtlasSettings, type FontMetrics, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GPUClothSystem, type GPUClothSystemOptions, type GPUClothWrapBindingData, type GPUClothWrapBindingTarget, GaussianBlurBlitter, GenericMathNode, type GeometryCacheFrame, type GeometryCacheMeshBinding, type GeometryCacheState, GerstnerWaveGenerator, type GlyphContour, type GlyphData, type GlyphPoint, type GrabberR, type GrabberRW, GraphNode, type GraphNodeInput, type GraphNodeOutput, type GraphStructure, type GrassInstanceInfo, GrassLayer, GrassMaterial, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, HistoryResourceManager, type Host, HumanoidBodyRig, HumanoidHandRig, type HumanoidJointMapping, type HumanoidRetargetAxisLocks, type HumanoidRootMotionMode, type HumanoidRootMotionScaleMode, type HumanoidSkeletalAnimationMaskOptions, type HumanoidSkeletalAnimationMaskPreset, type IAttachedScript, type IBaseEvent, type IControllerKeyboardEvent, type IControllerKeydownEvent, type IControllerKeypressEvent, type IControllerKeyupEvent, type IControllerMouseEvent, type IControllerPointerCancelEvent, type IControllerPointerDownEvent, type IControllerPointerMoveEvent, type IControllerPointerUpEvent, type IControllerWheelEvent, type IGraphNode, IKAngleConstraint, IKChain, IKConstraint, type IKJoint, IKModifier, IKSolver, type IMixinAlbedoColor, type IMixinBlinnPhong, type IMixinFoliage, type IMixinLambert, type IMixinLight, type IMixinPBRBluePrint, type IMixinPBRCommon, type IMixinPBRMetallicRoughness, type IMixinPBRSpecularGlossiness, type IMixinVertexColor, type IModKey, type IRUniformTexture, type IRUniformValue, type IRenderHook, type IRenderable, type InputEventHandler, InputManager, InstanceBindGroupAllocator, type InstanceData, InstanceIndexNode, type InstanceUniformType, type InterChainConstraint, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, type JointChainConfig, type JointDynamicSystemConfig, type JointDynamicsColliderHandle, type JointDynamicsColliderSnapshot, type JointDynamicsFlatPlaneHandle, type JointDynamicsFlatPlaneSnapshot, type JointDynamicsGrabberHandle, type JointDynamicsGrabberSnapshot, JointDynamicsModifier, JointDynamicsSystem, JointDynamicsSystemController, type JointNameMatcher, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, type LineCollisionResult, Log2Node, type LogMode, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, type MSDFBitmap, type MSDFOptions, type MSDFShape, MSDFText, MSDFTextAtlasManager, MSDFTextSprite, MToonMaterial, type MToonOutlineWidthMode, MakeVectorNode, Material, MaterialBlueprintIR, type MaterialBlueprintIRBehaviors, type MaterialTextureInfo, MaterialVaryingFlags, MaxNode, Mesh$1 as Mesh, MeshMaterial, type MeshUpdateCallback, type Metadata$1 as Metadata, MinNode, MixNode, ModNode, type ModelFetchOptions, type ModelInfo, type ModelLoader, type MorphBoundingInfo, type MorphData, type MorphInfo, type MorphState, MorphTargetTrack, MultiChainSpringSystem, type MultiChainSpringSystemOptions, type NamedJointsSkeletalAnimationMaskOptions, NamedObject, type NearestPointsResult, type NodeConnection, NodeEulerRotationTrack, type NodeIterateFunc, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, type OIT, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, type OrbitCameraControllerOptions, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, type PBRBlueprintOutputName, PBRMetallicRoughnessMaterial, type PBRReflectionMode, PBRSpecularGlossinessMaterial, type PCAGeometryCacheState, PCAGeometryCacheTrack, type PCAGeometryCacheTrackData, type PairAdjustment, PannerNode, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, type PhysicsCurves, type PickResult, type PickTarget, PixelNormalNode, PixelWorldPositionNode, type PlaneCollider, type PlaneCreationOptions, PlaneShape, type PlayAnimationOptions, type PointInit, PointLight, type PointR, type PointRW, type PointTransform, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, type PropEdit, type PropertyAccessor, type PropertyAccessorOptions, type PropertySceneNodeOptions, type PropertyToType, PropertyTrack, type PropertyType, type PropertyValue, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, Radians2DegreesNode, RaycastVisitor, RectLight, ReflectNode, RefractNode, type RenderFunc, type RenderItemList, type RenderItemListBundle, type RenderItemListInfo, RenderPass, type RenderPath, RenderQueue, type RenderQueueItem, type RenderQueueRef, RenderTarget, type ResolutionTransform, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RotateAboutAxisNode, RuntimeScript, type RuntimeScriptArrayDeclaration, type RuntimeScriptArrayElementDeclaration, type RuntimeScriptConfig, type RuntimeScriptObjectDeclaration, type RuntimeScriptObjectFieldDeclaration, type RuntimeScriptPropertyDeclaration, type RuntimeScriptPropertyInfo, type RuntimeScriptPropertyOptions, type RuntimeScriptPropertyType, type RuntimeScriptValueDeclaration, type RuntimeScriptValueType, SAO, type SSSDebugView, type SSSQualityPreset, type SSSResolvedSettings, type SamplerType, SaturateNode, type SaveOptions, Scene, type SceneMorphTargetBinding, type SceneMorphTargetGroup, SceneNode, type SceneNodeVisible, ScreenAdapter, type ScreenConfig, ScreenRenderTarget, type ScreenScaleMode, ScriptAttachment, type ScriptAttachmentConfig, ScriptRegistry, ScriptingSystem, type ScriptingSystemOptions, SelectionNode, type SerializableClass, type SerializedMorphTargetBinding, type SerializedMorphTargetGroup, ShaderHelper, ShadowMapPass, ShadowMapper, type ShadowMode, type ShadowQualityPreset, ShadowRegion, Shape, type ShapeCreationOptions, type ShapeOptionType, type ShapeType, SharedModel, SignNode, SimplexNoise2DNode, type SimulationParams, SinHNode, SinNode, type SkeletalAnimationMaskCommonOptions, type SkeletalAnimationMaskOptions, type SkeletalAnimationMaskRootMotionMode, type SkeletalAnimationMaskUnsupportedTrackMode, Skeleton, type SkeletonBindPose, SkeletonModifier, SkeletonRig, type SkeletonRigOptions, SkinBinding, type SkinnedBoundingBox, SkyEnvTextureNode, SkyRenderer, type SkyType, SmoothStepNode, type SphereCollider, type SphereCreationOptions, SphereShape, SpotLight, SpringChain, type SpringCollider, type SpringConstraint, SpringModifier, type SpringParticle, SpringSystem, type SpringSystemOptions, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, type StopAnimationOptions, SubsurfaceProfile, type SubsurfaceProfilePreset, type SurfaceCheckResult, SwizzleNode, TanHNode, TanNode, type TerrainDebugMode, type TetrahedronCreationOptions, TetrahedronFrameShape, TetrahedronShape, TextSprite, type TextureFetchOptions, type TextureMixinInstanceTypes, type TextureMixinTypes, type TextureProp, type TexturePropUniforms, TextureSampleGrad, TextureSampleNode, type ToMixedTextureType, Tonemap, type TorusCreationOptions, TorusShape, type TransformAccess, TransformNode, type TwistConstraint, TwoBoneIKSolver, UnlitMaterial, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexIndexNode, VertexNormalNode, VertexOutputNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, type Visitor, Water, type WaveGenerator, WeightedBlendedOIT, applyAngleLimits, applyMaterialMixins, applyResult, applyRuntimeScriptConfig, buildConstraints, buildMSDFShape, buildSurfaceFaces, checkSurfaceCollision, collisionDetection, collisionDetectionCapsule, collisionDetectionSphere, computeMaxDepth, computeNearestPoints, createCapsuleCollider, createGPUClothWrapBindingData, createGeometryCacheState, createPlaneCollider, createSphereCollider, createSpringConstraint, createSpringParticle, createTransformAccess, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, ensureGeometryCacheMeshBinding, fetchSampler, gammaToLinear, generateMSDF, getApp, getDevice, getEngine, getInput, getRuntimeScriptProperties, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, interleavedGradientNoise, isGPUClothSupported, linearToGamma, mixGeometryCacheBoundingBox, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, noise3D, normalizeRuntimeScriptConfig, normalizeScriptAttachmentConfig, normalizeScriptAttachments, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, pushInCollisionDetection, pushInFromCapsule, pushInFromCollider, pushInFromSphere, pushoutFromCapsule, pushoutFromCollider, pushoutFromSphere, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, restoreGeometryCacheMeshBinding, scriptProp, simulate, smoothNoise3D, sortRootPointsByProximity, temporalResolve, tryGetApp, updateColliderFromNode, valueNoise, whiteNoise, worleyFBM, worleyNoise };