bard-legends-framework 1.6.0 → 1.7.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as actions_lib from 'actions-lib';
-import { IDAttachable, Attachable, AttachmentID, IdleSingleEvent, IdleSequence, Sequence, SingleNotifier, Notifier, SingleEvent, Variable, Reducer, Action, ClassID, NotifierCallbackFunction, IAttachment } from 'actions-lib';
-import { Vector, Radian, Rectangle, Vec2, RGBColor, Grid, GridNeighborType, Line } from 'helpers-lib';
+import { IDAttachable, Attachable, AttachmentID, IdleSingleEvent, IdleSequence, Variable, Reducer, Sequence, SingleNotifier, Notifier, SingleEvent, Action, ClassID, NotifierCallbackFunction, IAttachment } from 'actions-lib';
+import { Vector, DynamicID, Vec2, RGBColor, Radian, Rectangle, Grid, GridNeighborType, Line } from 'helpers-lib';
 import p2$1 from 'p2';
 import * as Pixi from 'pixi.js';
 
@@ -96,7 +96,6 @@ declare abstract class Scene<InputType, OutputType> extends IDAttachable {
     readonly onClose: actions_lib.PersistentSingleNotifier<OutputType>;
     constructor();
     close(...args: void extends OutputType ? (OutputType extends void ? [] : [OutputType]) : [OutputType]): IdleSingleEvent<OutputType>;
-    private animateAndClose;
     protected abstract init(input: InputType): IdleSingleEvent;
     protected abstract update(time: number, delta: number): void;
     protected abstract prepareToClose(): IdleSingleEvent;
@@ -144,6 +143,250 @@ declare abstract class View extends IDAttachable {
     update(time: number, delta: number): void;
 }
 
+type AudioAppearTransitionType = 'ease' | 'instant';
+declare const SOUND_TRANSITION_DURATION = 800;
+declare class Audio {
+    private constructor();
+    setVolumes(volumes: {
+        master: number;
+        music: number;
+        sound: number;
+    }): void;
+    appear(on: boolean, type?: AudioAppearTransitionType): IdleSingleEvent;
+}
+
+interface FocusingNewTargetInfo {
+    time: number;
+    duration: number;
+    position: Vector;
+    roundPosition: boolean;
+    roundPositionThreshold: number;
+    focusingAnimation: FocusingAnimation;
+}
+declare class CameraEntity extends SingletonEntity {
+    readonly position: Variable<Vector>;
+    readonly offset: Variable<Vector>;
+    readonly targetPosition: Variable<Vector | undefined>;
+    readonly focusingNewTargetInfo: Variable<FocusingNewTargetInfo | undefined>;
+}
+
+declare class CameraService {
+    createCamera(): CameraEntity;
+    getCameraPosition(): Vector;
+    setPosition(position: Vector): void;
+    setTransition(options: FocusingOptions): void;
+    update(time: number, delta: number): void;
+}
+
+declare enum CameraLayer {
+    BackgroundScreen = "backgroundScreen",
+    Background = "background",
+    Main = "main",
+    Foreground = "foreground",
+    ForegroundScreen = "foregroundScreen"
+}
+declare enum FocusingAnimation {
+    Instant = 1,
+    EaseInOut = 2,
+    EaseOut = 3
+}
+interface FocusingOptions {
+    duration?: number;
+    animation?: FocusingAnimation;
+    roundPosition?: boolean;
+    roundPositionThreshold?: number;
+}
+type CameraAppearTransitionType = 'alpha' | 'pureBlack' | 'instant';
+
+declare class CameraController {
+    constructor(_cameraService: CameraService);
+    createCamera(): number;
+    update(time: number, delta: number): void;
+    setPosition(position: Vector): void;
+    setTransition(options: FocusingOptions): void;
+    getCameraPosition(): Vector;
+}
+
+declare const CameraGateway_base: new () => CameraController;
+declare class CameraGateway extends CameraGateway_base {
+}
+
+declare class Camera {
+    readonly layers: Record<CameraLayer, number>;
+    get position(): Vector;
+    constructor();
+    setPosition(position: Vector): void;
+    setTransition(options: FocusingOptions): void;
+    appear(on: boolean, type?: CameraAppearTransitionType, delay?: number): IdleSingleEvent;
+    screenPositonToStagePosition(screenPosition: Vector): Vector;
+}
+
+declare const DEFAULT_SHADER_RESOLUTION = 2;
+interface AssetDefinition<T = string> {
+    readonly id: T;
+    readonly url: string;
+}
+declare enum BlendMode {
+    Normal = 0,
+    Add = 1,
+    Screen = 3,
+    Luminosity = 16,
+    ColorDodge = 7
+}
+interface SpriteIDRegistry {
+}
+type SpriteID = DynamicID<SpriteIDRegistry, 'SpriteID'>;
+interface SpriteDefinition {
+    readonly id: SpriteID;
+    readonly scale: number;
+    readonly anchor: Vec2;
+    readonly size: Vec2;
+    readonly boundingShapes?: PolygonDefinition | undefined;
+    readonly destroyAssetOnDestroy?: boolean | undefined;
+}
+interface GlowingShapeDefinition {
+    readonly color: RGBColor;
+    readonly shapeAlpha: number;
+    readonly glowAlpha: number;
+    readonly glowOptions: GlowOptions;
+    readonly shapes: PolygonDefinition;
+}
+type PolygonDefinition = readonly (readonly Vec2[])[];
+interface GlowOptions {
+    readonly color: RGBColor;
+    readonly blurRadius: number | Vector;
+    readonly expand: number;
+    readonly blendMode: BlendMode;
+}
+type GlowEffectOptions = Partial<GlowOptions> & {
+    glowAlpha?: number;
+};
+interface SoundIDRegistry {
+}
+type SoundID = DynamicID<SoundIDRegistry, 'SoundID'>;
+interface SoundDefinition {
+    readonly id: SoundID;
+    readonly duration: number;
+    readonly loop?: {
+        readonly from: number;
+        readonly to: number;
+    };
+}
+
+interface GameConfiguration {
+    readonly screenResolution: {
+        readonly width: number;
+        readonly height: number;
+    } | undefined;
+    readonly maxScreenResolution: {
+        readonly width: number;
+        readonly height: number;
+    } | undefined;
+    readonly devMode: boolean;
+    readonly backgroundColor: RGBColor;
+    readonly antialias: boolean;
+    readonly resolution: number;
+}
+interface GameSetupOptions {
+    readonly spriteAssetDefinitions: readonly AssetDefinition<SpriteID>[];
+    readonly spriteDefinitions: Readonly<Record<SpriteID, SpriteDefinition>>;
+    readonly fontAssetDefinitions: readonly AssetDefinition[];
+    readonly soundAssetDefinitions: readonly AssetDefinition<SoundID>[];
+    readonly soundDefinitions: Readonly<Record<SoundID, SoundDefinition>>;
+}
+declare class Game {
+    static get instance(): Game;
+    static readonly pause: Reducer<boolean, boolean>;
+    static readonly freeze: Reducer<boolean, boolean>;
+    static get camera(): Camera;
+    static get audio(): Audio;
+    static appear(on: boolean, options?: {
+        camera?: CameraAppearTransitionType;
+        audio?: AudioAppearTransitionType;
+    }): IdleSingleEvent;
+    static get time(): number;
+    readonly renderer: Pixi.Renderer;
+    readonly _screenSize: Variable<Vector>;
+    readonly screenSize: actions_lib.PersistentNotifier<Vector>;
+    readonly _screenSizeCenter: Variable<Vector>;
+    readonly screenSizeCenter: actions_lib.PersistentNotifier<Vector>;
+    readonly devMode: boolean;
+    constructor(partialConfiguration?: Partial<GameConfiguration>);
+    setup(setupOptions: GameSetupOptions): Promise<void>;
+    setResolution(resolution: number): void;
+}
+
+interface SoundOptions {
+    readonly offset?: number;
+}
+declare class Sound extends IDAttachable {
+    static createByName(soundName: SoundID, options?: SoundOptions): Sound;
+    protected _source: AudioBufferSourceNode;
+    protected _gain: GainNode;
+    protected _head: AudioNode;
+    protected _soundDefinition: SoundDefinition;
+    protected _start: number;
+    get volume(): number;
+    set volume(value: number);
+    setVolume(value: number): this;
+    constructor(soundDefinition: SoundDefinition, options?: SoundOptions);
+    destroy(): void;
+    protected _play(offset: number): void;
+    protected _stop(): void;
+}
+
+interface AdvancedSoundOptions extends SoundOptions {
+    readonly fade?: number;
+    readonly muffle?: number;
+}
+declare class AdvancedSound extends Sound {
+    static createByName(soundName: SoundID, options?: AdvancedSoundOptions): AdvancedSound;
+    readonly time: actions_lib.PersistentNotifier<number>;
+    constructor(soundDefinition: SoundDefinition, options?: AdvancedSoundOptions);
+    close(): IdleSingleEvent;
+    /**
+     * @param time in seconds
+     * @returns IdleSingleEvent that resolves in the given time
+     */
+    notifyOnTime(targetTime: number): IdleSingleEvent;
+    setFade(strength: number): void;
+    fade(strength: number, transitionDuration?: number): IdleSingleEvent;
+    setMuffle(strength: number): void;
+    muffle(strength: number, transitionDuration?: number): IdleSingleEvent;
+    destroy(): void;
+}
+
+interface MusicOptions extends SoundOptions {
+    readonly stopPlayingOnPause: boolean;
+}
+declare class Music extends IDAttachable {
+    static createByName(soundName: SoundID, options?: MusicOptions): Music;
+    constructor(soundDefinition: SoundDefinition, partialOptions?: Partial<MusicOptions>);
+    /**
+     * Note: If then music time should stay synced with the game time, "stopPlayingOnPause" option has to be set true.
+     * @param time in seconds
+     * @returns IdleSingleEvent that resolves in the given time
+     */
+    notifyOnTime(targetTime: number): IdleSingleEvent;
+    close(): IdleSingleEvent;
+}
+
+interface MusicPlayerOptionsNoPause extends MusicOptions {
+    readonly stopPlayingOnPause: false;
+    readonly playWhenPaused: undefined;
+}
+interface MusicPlayerOptionsWithPause extends MusicOptions {
+    readonly stopPlayingOnPause: true;
+    readonly playWhenPaused: SoundID | undefined;
+}
+type MusicPlayerOptions = MusicPlayerOptionsNoPause | MusicPlayerOptionsWithPause;
+declare class MusicPlayer extends IDAttachable {
+    constructor(partialOptions?: Partial<MusicPlayerOptions>);
+    play(soundID: SoundID): IdleSingleEvent<Music | undefined>;
+    stop(): IdleSingleEvent;
+    close(): IdleSingleEvent;
+}
+
 declare enum ContainerEventType {
     Click = "click",
     MouseOver = "mouseover",
@@ -260,51 +503,13 @@ declare class Filters {
     removeColorFilter(): void;
 }
 
-declare const DEFAULT_SHADER_RESOLUTION = 2;
-interface AssetDefinition<T extends string = string> {
-    readonly id: string;
-    readonly url: T;
-}
-declare enum BlendMode {
-    Normal = 0,
-    Add = 1,
-    Screen = 3,
-    Luminosity = 16,
-    ColorDodge = 7
-}
-interface SpriteDefinition {
-    readonly id: string;
-    readonly scale: number;
-    readonly anchor: Vec2;
-    readonly size: Vec2;
-    readonly boundingShapes?: PolygonDefinition | undefined;
-    readonly destroyAssetOnDestroy?: boolean | undefined;
-}
-interface GlowingShapeDefinition {
-    readonly color: RGBColor;
-    readonly shapeAlpha: number;
-    readonly glowAlpha: number;
-    readonly glowOptions: GlowOptions;
-    readonly shapes: PolygonDefinition;
-}
-type PolygonDefinition = readonly (readonly Vec2[])[];
-interface GlowOptions {
-    readonly color: RGBColor;
-    readonly blurRadius: number | Vector;
-    readonly expand: number;
-    readonly blendMode: BlendMode;
-}
-type GlowEffectOptions = Partial<GlowOptions> & {
-    glowAlpha?: number;
-};
-
 interface SpriteOptions {
     readonly textureSize?: Vector;
     readonly texturePosition?: Vector;
     readonly ignoreAnchor?: boolean;
 }
 declare class Sprite extends Container {
-    static createByName(spriteName: string): Sprite;
+    static createByName(spriteName: SpriteID): Sprite;
     static createSnapshotSprite(container: Container): Sprite;
     readonly pixiSprite: Pixi.Sprite;
     constructor(spriteDefinition: SpriteDefinition, options?: SpriteOptions);
@@ -480,7 +685,7 @@ declare class MenuUI extends Container {
     readonly onCreate: actions_lib.PersistentSingleNotifier<void>;
     readonly onOpen: actions_lib.PersistentSingleNotifier<void>;
     readonly onClose: actions_lib.PersistentSingleNotifier<void>;
-    constructor(windowSprite: string, partialOptions: Partial<MenuOptions>);
+    constructor(windowSprite: SpriteID, partialOptions: Partial<MenuOptions>);
     getBoundingMask(): Sprite;
     close(): IdleSingleEvent;
 }
@@ -489,7 +694,7 @@ interface MenuEntityOptions {
     readonly closeOnBackgroundClick: boolean;
 }
 declare class MenuEntity extends SingletonEntity {
-    static subscribeIsOpen(): IdleSequence<boolean>;
+    static subscribeIsOpen(): Sequence<boolean>;
     constructor(partialOptions: Partial<MenuEntityOptions>);
     onCreate(): IdleSingleEvent;
     onOpen(): IdleSingleEvent;
@@ -505,7 +710,7 @@ declare class MenuView extends View {
     readonly onCreate: SingleNotifier<Container>;
     readonly onOpen: SingleNotifier;
     readonly onClose: SingleNotifier;
-    constructor(entity: MenuEntity, windowSprite: string, partialOptions: Partial<MenuViewOptions>);
+    constructor(entity: MenuEntity, windowSprite: SpriteID, partialOptions: Partial<MenuViewOptions>);
 }
 
 interface ScrollAreaUIOptions {
@@ -532,6 +737,8 @@ declare class AnimationInterpolationFunctions {
     static lineer(time: number): number;
     static easeIn(time: number): number;
     static easeOut(time: number): number;
+    static easeInCubic(time: number): number;
+    static easeOutCubic(time: number): number;
     static easeInOut(time: number): number;
     static easeInOutCubic(t: number): number;
     static blink(t: number): number;
@@ -552,6 +759,14 @@ declare class AnimationEaseInOut implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
 }
+declare class AnimationEaseInCubic implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class AnimationEaseOutCubic implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
 declare class AnimationEaseInOutCubic implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
@@ -569,6 +784,8 @@ declare class Animations {
     static easeIn: AnimationEaseIn;
     static easeOut: AnimationEaseOut;
     static easeInOut: AnimationEaseInOut;
+    static easeInCubic: AnimationEaseInCubic;
+    static easeOutCubic: AnimationEaseOutCubic;
     static easeInOutCubic: AnimationEaseInOutCubic;
     static blink: AnimationBlink;
 }
@@ -597,6 +814,8 @@ declare class Animator<T extends object = any, K extends NumericKeys<T> = Numeri
     get animating(): boolean;
     get target(): T;
     get value(): Notifier<T>;
+    get paused(): boolean;
+    set paused(value: boolean);
     constructor(target: T & Record<K, number>, animatedProperties: K | K[], partialOptions?: Partial<AnimationOptions>);
     animate(values: Record<K, number>, partialOptions?: Partial<AnimationOptions>): SingleEvent<void>;
     set(values: Record<K, number>): void;
@@ -621,52 +840,40 @@ interface StateAnimationOptions {
     readonly duration: number;
     readonly animation: AnimatorAnimation;
 }
-declare enum AnimationState$1 {
-    Idle = 1,
-    Transitioning = 2,
-    Reverting = 3
+type AnimationState$2 = 'idle' | 'transitioning' | 'reverting';
+interface StateAnimationState<T, A> {
+    readonly value: number;
+    readonly item: T | undefined;
+    readonly nextItem: T | undefined;
+    readonly queuedItem: T | undefined;
+    readonly animationState: A;
 }
 declare class StateAnimation<T> extends Attachable {
-    get currentState(): {
-        value: number;
-        state: T | undefined;
-        nextState: T | undefined;
-        queuedState: T | undefined;
-        animationState: AnimationState$1;
-    };
+    onStateChange(callback: (item: T, nextItem?: T) => void): this;
+    onValueChange(callback: (value: number) => void): this;
+    get state(): StateAnimationState<T, AnimationState$2>;
+    get paused(): boolean;
+    set paused(value: boolean);
     constructor(partialOptions?: Partial<StateAnimationOptions>);
-    setState(state: T, options?: {
+    setItem(item: T, options?: {
         instant?: boolean;
     }): void;
-    onStateChange(callback: (state: T, nextState?: T) => void): this;
-    onValueChange(callback: (value: number) => void): this;
 }
 
-declare enum AnimationState {
-    Hidden = 1,
-    Visible = 2,
-    Appearing = 3,
-    Disappearing = 4,
-    DisappearToChange = 5
-}
-declare class FadeInStateAnimation<T> extends Attachable {
-    get currentState(): {
-        value: number;
-        state: T | undefined;
-        queuedState: T | undefined;
-        animationState: AnimationState;
-    };
+type AnimationState$1 = 'hidden' | 'visible' | 'appearing' | 'disappearing' | 'disappearToChange';
+declare class ThroughEmptyStateAnimation<T> extends Attachable {
+    onStateChange(callback: (state: T | undefined) => void): this;
+    onValueChange(callback: (value: number) => void): this;
+    get state(): StateAnimationState<T, AnimationState$1>;
     constructor(partialOptions?: Partial<StateAnimationOptions>);
     /**
-     * @param state - The new state to set. Keep in mind falsy values are also considered as a new state. To set the state to "disappear" use undefined.
+     * @param item - The new item to set. Keep in mind falsy values are also considered as a new item. To set the item to "disappear" use undefined.
      * @param options - Optional options.
-     * @param options.instant - If true, the state will be set immediately.
+     * @param options.instant - If true, the item will be set immediately.
      */
-    setState(state: T | undefined, options?: {
+    setItem(item: T | undefined, options?: {
         instant?: boolean;
     }): void;
-    onStateChange(callback: (state: T | undefined) => void): this;
-    onValueChange(callback: (value: number) => void): this;
 }
 
 declare enum ScrollDirection {
@@ -706,13 +913,15 @@ declare enum SlideStateAnimationState {
     Appear = 1,
     Disappear = 2
 }
+type AnimationState = 'idle' | 'transitionForward' | 'transitionBackward' | 'reverting';
 declare class SlideStateAnimation extends Attachable {
+    onStateChange(callback: (state: SlideStateAnimationState, index: number) => void): this;
+    onValueChange(callback: (value: number, index: number) => void): this;
+    get state(): StateAnimationState<number, AnimationState>;
     constructor(partialOptions?: Partial<StateAnimationOptions>);
     setIndex(index: number, options?: {
         instant?: boolean;
     }): void;
-    onStateChange(callback: (state: SlideStateAnimationState, index: number) => void): this;
-    onValueChange(callback: (value: number, index: number) => void): this;
 }
 
 declare class VectorSet {
@@ -747,115 +956,6 @@ declare class ScrollMaskUI extends Container {
     constructor(container: Container, size: Vector, padding: number, direction?: ScrollDirection);
 }
 
-interface FocusingNewTargetInfo {
-    time: number;
-    duration: number;
-    position: Vector;
-    roundPosition: boolean;
-    roundPositionThreshold: number;
-    focusingAnimation: FocusingAnimation;
-}
-declare class CameraEntity extends SingletonEntity {
-    readonly position: Variable<Vector>;
-    readonly offset: Variable<Vector>;
-    readonly targetPosition: Variable<Vector | undefined>;
-    readonly focusingNewTargetInfo: Variable<FocusingNewTargetInfo | undefined>;
-}
-
-declare class CameraService {
-    createCamera(): CameraEntity;
-    getCameraPosition(): Vector;
-    setPosition(position: Vector): void;
-    setTransition(options: FocusingOptions): void;
-    update(time: number, delta: number): void;
-}
-
-declare enum CameraLayer {
-    BackgroundScreen = "backgroundScreen",
-    Background = "background",
-    Main = "main",
-    Foreground = "foreground",
-    ForegroundScreen = "foregroundScreen"
-}
-declare enum FocusingAnimation {
-    Instant = 1,
-    EaseInOut = 2,
-    EaseOut = 3
-}
-interface FocusingOptions {
-    duration?: number;
-    animation?: FocusingAnimation;
-    roundPosition?: boolean;
-    roundPositionThreshold?: number;
-}
-type CameraAppearTransitionType = 'alpha' | 'pureBlack' | 'instant';
-
-declare class CameraController {
-    constructor(_cameraService: CameraService);
-    createCamera(): number;
-    update(time: number, delta: number): void;
-    setPosition(position: Vector): void;
-    setTransition(options: FocusingOptions): void;
-    getCameraPosition(): Vector;
-}
-
-declare const CameraGateway_base: new () => CameraController;
-declare class CameraGateway extends CameraGateway_base {
-}
-
-declare class Camera {
-    readonly layers: Record<CameraLayer, number>;
-    get position(): Vector;
-    constructor();
-    setPosition(position: Vector): void;
-    setTransition(options: FocusingOptions): void;
-    appear(on: boolean, type?: CameraAppearTransitionType): IdleSingleEvent;
-}
-
-interface GameConfiguration {
-    readonly screenResolution: {
-        readonly width: number;
-        readonly height: number;
-    } | undefined;
-    readonly maxScreenResolution: {
-        readonly width: number;
-        readonly height: number;
-    } | undefined;
-    readonly devMode: boolean;
-    readonly backgroundColor: RGBColor;
-    readonly antialias: boolean;
-    readonly resolution: number;
-}
-interface GameSetupOptions {
-    readonly assetDefinitions: readonly AssetDefinition<string>[];
-    readonly spriteDefinitions: Readonly<Record<string, SpriteDefinition>>;
-}
-declare class Game {
-    static get instance(): Game;
-    static readonly pause: Reducer<boolean, boolean>;
-    static get camera(): Camera;
-    static get time(): number;
-    readonly stage: Container;
-    readonly renderer: Pixi.Renderer;
-    readonly _screenSize: Variable<Vector>;
-    readonly screenSize: actions_lib.PersistentNotifier<Vector>;
-    readonly _screenSizeCenter: Variable<Vector>;
-    readonly screenSizeCenter: actions_lib.PersistentNotifier<Vector>;
-    readonly devMode: boolean;
-    constructor(partialConfiguration?: Partial<GameConfiguration>);
-    setup(setupOptions: GameSetupOptions): Promise<void>;
-    setResolution(resolution: number): void;
-    screenPositonToStagePosition(screenPosition: Vector): Vector;
-    setScreenPositionToStagePositionFunction(converterFunction: (screenPosition: Vector) => Vector): void;
-    resetScreenPositionToStagePositionFunction(): void;
-    destroyAsset(assetID: string): void;
-}
-
-declare class PositionConversionHelper {
-    static includeScaleInScreenPosition(screenPosition: Vector, gameInstanceScale: number, screenSizeCenter: Vector): Vector;
-    static normalizePolygonByAnchor(polygon: PolygonDefinition, frameSize: Vector, frameAnchor: Vector): PolygonDefinition;
-}
-
 interface KeyboardKeyInfo {
     readonly key: string;
     readonly code: string;
@@ -883,7 +983,6 @@ declare class MouseService {
      * accounting for canvas offset (e.g. letterboxing when max resolution is smaller than the window)
      * and CSS scaling of the canvas.
      */
-    private clientPositionToScreenPosition;
 }
 
 declare class MouseTargetFocusService {
@@ -1216,4 +1315,4 @@ declare const PhysicsGateway_base: new () => PhysicsController;
 declare class PhysicsGateway extends PhysicsGateway_base {
 }
 
-export { AnimationFlicker, AnimationInterpolationFunctions, type AnimationOptions, Animations, AnimationsCompletionHandlingType, Animator, type AnimatorAnimation, type AssetDefinition, BORDER_MATERIAL_NAME, BardLegendsHardReset, BlendMode, type BorderProperties, Camera, CameraGateway, type CircleShapeData, ClosestAvailableSpaceHelper, type CollisionDetails, type CollisionReport, Container, ContainerEventType, ControllerDecorator, type CreateDashedLineOptions, type CreatePhysicsWorldRequestDTO, Cursor, DEFAULT_SHADER_RESOLUTION, DeltaTime, DisplayObjectArray, type DisplayObjectArrayOptions, type DropShadowOptions, Entity, EntityDecorator, type ExplosionHit, FadeInContent, type FadeInContentOptions, FadeInStateAnimation, FocusingAnimation, Game, Gateway, type GlowEffectOptions, type GlowOptions, type GlowingShapeDefinition, Graphics, type HitTestOptions, ImmovablePhysicsEntity, type InteractingBodyGroups, type KeyboardKeyInfo, KeyboardService, type MapSizeDTO, type MaterialContactDefinition, type MaterialDefinition, MenuEntity, type MenuOptions, MenuUI, MenuView, MouseService, MouseTargetFocusService, MovableEntity, MovablePhysicsEntity, type PartialTextOptions, PathFinder, type PathFinderResult, type PhysicsBodyDTO, PhysicsEntity, type PhysicsEntityDefinition, type PhysicsExplosionOptions, PhysicsGateway, PhysicsShapeType, Placeholder, type PolygonDefinition, type PolygonShapeData, PositionConversionHelper, ROTATIONAL_SPEED_LIMIT, type RayCast, type RayCastHit, ReAnimateHandlingType, type RectangleShapeData, RichText, type RichTextOptions, type RichTextRectangleCut, type RichTextStyles, SPEED_LIMIT, Scene, SceneDecorator, ScrollAreaUI, ScrollDirection, type ScrollInContentOptions, ScrollMaskUI, Service, ServiceDecorator, type SetParentOptions, type ShapeDefinition, SingletonEntity, SlideInContent, SlideInContentByIndex, SlideStateAnimation, SlideStateAnimationState, Sprite, type SpriteDefinition, StateAnimation, type StateAnimationOptions, Text, type TextAlignment, type TextOptions, UpdatableContainer, UpdateCycle, VectorFieldPathFinder, VectorSet, View, ViewDecorator, type ViewDecoratorMeta };
+export { AdvancedSound, type AdvancedSoundOptions, AnimationFlicker, AnimationInterpolationFunctions, type AnimationOptions, Animations, AnimationsCompletionHandlingType, Animator, type AnimatorAnimation, type AssetDefinition, type AudioAppearTransitionType, BORDER_MATERIAL_NAME, BardLegendsHardReset, BlendMode, type BorderProperties, Camera, CameraGateway, type CircleShapeData, ClosestAvailableSpaceHelper, type CollisionDetails, type CollisionReport, Container, ContainerEventType, ControllerDecorator, type CreateDashedLineOptions, type CreatePhysicsWorldRequestDTO, Cursor, DEFAULT_SHADER_RESOLUTION, DeltaTime, DisplayObjectArray, type DisplayObjectArrayOptions, type DropShadowOptions, Entity, EntityDecorator, type ExplosionHit, FadeInContent, type FadeInContentOptions, FocusingAnimation, Game, Gateway, type GlowEffectOptions, type GlowOptions, type GlowingShapeDefinition, Graphics, type HitTestOptions, ImmovablePhysicsEntity, type InteractingBodyGroups, type KeyboardKeyInfo, KeyboardService, type MapSizeDTO, type MaterialContactDefinition, type MaterialDefinition, MenuEntity, type MenuOptions, MenuUI, MenuView, MouseService, MouseTargetFocusService, MovableEntity, MovablePhysicsEntity, Music, MusicPlayer, type MusicPlayerOptions, type PartialTextOptions, PathFinder, type PathFinderResult, type PhysicsBodyDTO, PhysicsEntity, type PhysicsEntityDefinition, type PhysicsExplosionOptions, PhysicsGateway, PhysicsShapeType, Placeholder, type PolygonDefinition, type PolygonShapeData, ROTATIONAL_SPEED_LIMIT, type RayCast, type RayCastHit, ReAnimateHandlingType, type RectangleShapeData, RichText, type RichTextOptions, type RichTextRectangleCut, type RichTextStyles, SOUND_TRANSITION_DURATION, SPEED_LIMIT, Scene, SceneDecorator, ScrollAreaUI, ScrollDirection, type ScrollInContentOptions, ScrollMaskUI, Service, ServiceDecorator, type SetParentOptions, type ShapeDefinition, SingletonEntity, SlideInContent, SlideInContentByIndex, SlideStateAnimation, SlideStateAnimationState, Sound, type SoundDefinition, type SoundID, type SoundIDRegistry, type SoundOptions, Sprite, type SpriteDefinition, type SpriteID, type SpriteIDRegistry, StateAnimation, type StateAnimationOptions, type StateAnimationState, Text, type TextAlignment, type TextOptions, ThroughEmptyStateAnimation, UpdatableContainer, UpdateCycle, VectorFieldPathFinder, VectorSet, View, ViewDecorator, type ViewDecoratorMeta };