bard-legends-framework 0.12.0 → 1.0.0-rc0

package/dist/index.d.mts

@@ -0,0 +1,976 @@
+import * as actions_lib from 'actions-lib';
+import { IDAttachable, Attachable, SingleEvent, IAttachment, Action, Notifier, Reducer, Variable } from 'actions-lib';
+import { Vector, Radian, Vec2, RGBColor, Rectangle, Grid, GridNeighborType, Line } from 'helpers-lib';
+import * as Pixi from 'pixi.js';
+
+declare class ControllerLink {
+    trigger<T>(functionName: string, ...args: any[]): T;
+}
+interface ControllerDecoratorMeta {
+    controllerLink: ControllerLink;
+}
+declare function ControllerDecorator(meta: ControllerDecoratorMeta): (ControllerClass: any) => any;
+
+type EntityClassType<T extends Entity = Entity> = (new (...args: any[]) => T) & {
+    id: number;
+};
+declare function EntityDecorator(): <T extends Entity>(EntityClass: EntityClassType<T>) => any;
+declare abstract class Entity extends IDAttachable {
+    static getInstanceByID<T extends Entity>(this: EntityClassType<T>, entityID: number | undefined): T | undefined;
+    static getInstanceByIDOrFail<T extends Entity>(this: EntityClassType<T>, entityID: number): T;
+    static getEntities<T extends Entity>(this: EntityClassType<T>): T[];
+    constructor();
+    destroy(): void;
+    attach(parent: Attachable): this;
+    attachByID(id: number): this;
+    attachToRoot(): this;
+}
+
+declare abstract class SingletonEntity extends Entity {
+    static getInstance<T extends SingletonEntity>(this: EntityClassType<T>): T | undefined;
+    static getInstanceOrFail<T extends SingletonEntity>(this: EntityClassType<T>): T;
+    constructor();
+}
+
+declare class BardLegendsHardReset {
+    static readonly onHardReset: actions_lib.Notifier<void>;
+    static hardReset(): void;
+}
+
+type SceneClassType = new (...services: unknown[]) => Scene<unknown, unknown>;
+type SceneInput<T> = T extends Scene<infer I, any> ? I : never;
+declare function SceneDecorator(): (SceneClass: SceneClassType) => any;
+declare abstract class Scene<InputType, OutputType> extends IDAttachable {
+    static readonly activeScene: actions_lib.Notifier<Scene<unknown, unknown> | undefined>;
+    static getActiveScene(this: typeof Scene): Scene<unknown, unknown> | undefined;
+    static getActiveSceneOrFail(this: typeof Scene): Scene<unknown, unknown>;
+    static isActive<T extends Scene<unknown, unknown>>(this: new (...args: unknown[]) => T): boolean;
+    static getInstance<T extends Scene<unknown, unknown>>(this: new (...args: unknown[]) => T): T | undefined;
+    static getInstanceOrFail<T extends Scene<unknown, unknown>>(this: new (...args: unknown[]) => T): T;
+    static open<T extends Scene<any, any>>(this: new (...args1: unknown[]) => T, ...args2: T extends Scene<void, any> ? [] : [SceneInput<T>]): SingleEvent<T>;
+    readonly onClose: actions_lib.Notifier<OutputType>;
+    constructor();
+    close(...args: OutputType extends void ? [] : [OutputType]): SingleEvent<OutputType>;
+    protected abstract init(input: InputType): SingleEvent;
+    protected abstract update(time: number, delta: number): void;
+    protected abstract prepareToClose(): SingleEvent;
+    /**
+     * @deprecated
+     */
+    destroy(): void;
+}
+
+declare function ServiceDecorator(): (ServiceClass: any) => any;
+declare class Service {
+    static get<T extends Service>(ServiceClass: new (...args: any[]) => T): T;
+}
+
+declare class UpdateCycle {
+    static readonly beforeSceneUpdateAction: actions_lib.Notifier<{
+        time: number;
+        delta: number;
+    }>;
+    static readonly sceneUpdateAction: actions_lib.Notifier<{
+        time: number;
+        delta: number;
+    }>;
+    static readonly afterSceneUpdateAction: actions_lib.Notifier<{
+        time: number;
+        delta: number;
+    }>;
+    static wait(duration: number): SingleEvent;
+    static registerUpdateModifier(callback: (time: number, delta: number) => number): void;
+    static cleanUpdateModifier(): void;
+    static triggerUpdateTick(delta: number): void;
+    static get lastDelta(): number;
+}
+
+type ViewClassType<EntityType extends Entity> = new (entity: EntityType, ...services: any[]) => View;
+interface ViewDecoratorMeta<EntityType extends Entity> {
+    entity: EntityClassType<EntityType>;
+}
+declare function ViewDecorator<EntityType extends Entity>(meta: ViewDecoratorMeta<EntityType>): (ViewClass: ViewClassType<EntityType>) => any;
+declare abstract class View extends IDAttachable {
+    static getInstance<T extends View>(this: new (...args: any[]) => T, entityID: number): T | undefined;
+    static getInstanceOrFail<T extends View>(this: new (...args: any[]) => T, entityID: number): T;
+    constructor();
+    destroy(): void;
+    update(time: number, delta: number): void;
+}
+
+declare enum ContainerEventType {
+    Click = "click",
+    MouseOver = "mouseover",
+    MouseOut = "mouseout",
+    PointerDown = "pointerdown",
+    PointerUp = "pointerup",
+    PointerUpOutside = "pointerupoutside",
+    PointerMove = "pointermove",
+    PointerCancel = "pointercancel",
+    PointerOver = "pointerover",
+    PointerOut = "pointerout",
+    PointerEnter = "pointerenter",
+    PointerLeave = "pointerleave",
+    Added = "added",
+    Removed = "removed",
+    Update = "update",
+    Change = "change"
+}
+declare enum Cursor {
+    Default = "default",
+    Pointer = "pointer"
+}
+declare abstract class ContainerAttributes extends IDAttachable {
+    protected constructor();
+    get size(): Vector;
+    set size(value: Vector);
+    getSize(): Vector;
+    setSize(value: Vector): this;
+    /**
+     * @param value The position to set
+     * @param options.holdFrom An anchor point to hold the position from
+     * @param options.round Default: true
+     * @returns this
+     */
+    setPosition(value: Vector, options?: {
+        holdFrom?: Vector;
+        round?: boolean;
+    }): this;
+    get position(): Vector;
+    set position(value: Vector);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    on(eventType: ContainerEventType, callback: () => void): IAttachment;
+    setRotation(value: Radian): this;
+    get rotation(): Radian;
+    set rotation(value: Radian);
+    /**
+     * Number value of the rotation, in order to be animated
+     */
+    get rotationValue(): number;
+    set rotationValue(value: number);
+    setZIndex(value: number): this;
+    get zIndex(): number;
+    set zIndex(value: number);
+    setSkewX(radian: Radian): this;
+    get skewX(): Radian;
+    set skewX(radian: Radian);
+    setSkewY(radian: Radian): this;
+    get skewY(): Radian;
+    set skewY(radian: Radian);
+    setSortableChildren(value: boolean): this;
+    get sortableChildren(): boolean;
+    set sortableChildren(value: boolean);
+    setAlpha(value: number): this;
+    get alpha(): number;
+    set alpha(value: number);
+    setInteractive(value: boolean): this;
+    get interactive(): boolean;
+    set interactive(value: boolean);
+    setCursor(value: Cursor): this;
+    get cursor(): Cursor;
+    set cursor(value: Cursor);
+    protected getMask(): Pixi.Container;
+    setMask(mask: ContainerAttributes | undefined): this;
+    hitTest(stagePosition: Vector): boolean;
+    setMirror(mirror?: boolean): this;
+    get mirror(): boolean;
+    set mirror(value: boolean);
+    setFlip(flip?: boolean): this;
+    get flip(): boolean;
+    set flip(value: boolean);
+    setScale(value: number): this;
+    get scale(): number;
+    set scale(value: number);
+    setAspectRatio(value: number): this;
+    get aspectRatio(): number;
+    set aspectRatio(value: number);
+}
+
+declare class Filters {
+    get red(): number;
+    set red(value: number);
+    get green(): number;
+    set green(value: number);
+    get blue(): number;
+    set blue(value: number);
+    get brightness(): number;
+    set brightness(value: number);
+    get contrast(): number;
+    set contrast(value: number);
+    get blur(): Vector | undefined;
+    set blur(value: Vector | number | undefined);
+    constructor(_container: Pixi.Container);
+    removeColorFilter(): void;
+}
+
+declare const DEFAULT_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;
+    readonly destroyAssetOnDestroy?: boolean;
+}
+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 createSnapshotSprite(container: Container): Sprite;
+    readonly pixiSprite: Pixi.Sprite;
+    constructor(spriteDefinition: SpriteDefinition, options?: SpriteOptions);
+    destroy(): void;
+    setTextureScale(value: number): this;
+    get textureScale(): number;
+    set textureScale(value: number);
+    get size(): Vector;
+    protected getMask(): Pixi.Container;
+    set interactive(value: boolean);
+    setMipmap(value: boolean): this;
+    get mipmap(): boolean;
+    set mipmap(value: boolean);
+    setBlendMode(value: BlendMode): this;
+    get blendMode(): BlendMode;
+    set blendMode(value: BlendMode);
+    setTint(tint: RGBColor): this;
+    get tint(): RGBColor;
+    set tint(value: RGBColor);
+    setShapeAlpha(value: number): this;
+    get shapeAlpha(): number;
+    set shapeAlpha(value: number);
+    setGlowAlpha(alpha: number): this;
+    get glowAlpha(): number;
+    set glowAlpha(value: number);
+    /**
+     * @param align the anchor of the desired alignment dimentions of the Sprite is from 0 to 1 like the anchor
+     * @returns the vector of the alignment to set the position for the children
+     */
+    getAlignmentVector(alignment: Vector): Vector;
+    setGlowEffect(partialOptions: GlowEffectOptions | undefined): this;
+    showBoundingShape(value: boolean): this;
+    getBoundingMask(): Sprite;
+    download(): this;
+}
+
+interface SetParentOptions {
+    addUnder: boolean;
+    cropOverflowingParts: boolean;
+}
+declare class Container extends ContainerAttributes {
+    protected static allContainers: Map<number, Container>;
+    readonly filters: Filters;
+    protected addChildTo: Container;
+    protected defaultChildOptions: {
+        addUnder: boolean;
+        cropOverflowingParts: boolean;
+    };
+    constructor();
+    destroy(): void;
+    getBoundingMask(): Sprite;
+    displayParent(parent: Container | number, partialOptions?: Partial<SetParentOptions>): this;
+    get boundingBox(): Rectangle;
+}
+
+interface CreateDashedLineOptions {
+    readonly color: RGBColor;
+    readonly width: number;
+    readonly dashLength: number;
+    readonly dashGap: number;
+    readonly lineStartGap: number;
+    readonly lineEndGap: number;
+}
+
+interface ToSpriteOptions {
+    readonly cache: boolean;
+    readonly cacheName: string;
+    readonly keepBounds: boolean;
+}
+declare class Graphics extends Container {
+    static createArrow(size: number, color: RGBColor): Graphics;
+    static createDashedLine(from: Vector, to: Vector, partialOptions?: Partial<CreateDashedLineOptions>): Graphics;
+    static createVector(from: Vector, to: Vector, color: RGBColor): Graphics;
+    static createRectangleBorders(size: Vector, borderSize: number, color: RGBColor): Graphics;
+    static createRectangle(size: Vector, color?: RGBColor): Graphics;
+    static createCircle(radius: number, color: RGBColor): Graphics;
+    static createElipse(size: Vector, color: RGBColor): Graphics;
+    static createPolygon(polygon: PolygonDefinition, color: RGBColor): Graphics;
+    static createRegularPolygon(sides: number, radius: number, color: RGBColor): Graphics;
+    readonly pixiGraphics: Pixi.Graphics;
+    protected constructor(pixiGraphics: Pixi.Graphics, cacheName: string);
+    destroy(): void;
+    toSprite(partialOptions?: Partial<ToSpriteOptions>): Sprite;
+}
+
+declare class Placeholder extends Container {
+    constructor(size: Vector);
+    destroy(): void;
+}
+
+interface DropShadowOptions {
+    readonly blur: number;
+    readonly angle: Radian;
+    readonly distance: number;
+    readonly color: RGBColor;
+    readonly alpha: number;
+}
+type TextAlignment = 'center' | 'left' | 'right';
+interface TextOptions {
+    readonly color: RGBColor;
+    readonly align: TextAlignment;
+    readonly fontFamily: string;
+    readonly fontSize: number;
+    readonly fontStyle: 'normal' | 'italic' | 'oblique';
+    readonly lineHeight: number | undefined;
+    readonly dropShadow: DropShadowOptions | undefined;
+    readonly wordWrapWidth: number | undefined;
+    readonly lineThrough: boolean;
+}
+type PartialTextOptions = Partial<Omit<TextOptions, 'dropShadow'>> & {
+    dropShadow?: Partial<DropShadowOptions> | true;
+};
+
+interface RichTextRectangleCut {
+    readonly position: Vector;
+    readonly direction: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+}
+interface RichTextStyles {
+    readonly [key: string]: Omit<PartialTextOptions, 'align' | 'wordWrapWidth' | 'dropShadow'>;
+}
+interface RichTextOptions {
+    readonly default: PartialTextOptions;
+    readonly styles?: RichTextStyles;
+    readonly rectangleCut?: RichTextRectangleCut;
+    readonly verticalAlignment?: 'top' | 'center' | 'bottom';
+}
+declare class RichText extends Container {
+    constructor(text: string, options: RichTextOptions);
+}
+
+declare class Text extends Container {
+    get ascent(): number;
+    constructor(text: string, partialOptions?: PartialTextOptions);
+    destroy(): void;
+    setAnchor(value: Vector): this;
+    get anchor(): Vector;
+    set anchor(value: Vector);
+    setPosition(value: Vector, options?: {
+        holdFrom?: Vector | undefined;
+        round?: boolean | undefined;
+    } | undefined): this;
+    setText(text: string): this;
+    setColor(color: RGBColor): this;
+}
+
+declare abstract class UpdatableContainer<T> extends Container {
+    abstract update(value: T): void;
+}
+interface DisplayObjectArrayOptions<T> {
+    readonly trackBy: (item: T, index: number) => string | number;
+    readonly positioning: {
+        readonly direction: 'horizontal' | 'vertical';
+        readonly spacing: number;
+    };
+}
+declare class DisplayObjectArray<T> extends Container {
+    /**
+     * @param _createFunction function to create the display object
+     * @param partialOptions.trackBy default is index
+     * @param partialOptions.positioning.direction default is vertical
+     * @param partialOptions.positioning.spacing default is 0
+     */
+    constructor(_createFunction: (item: T) => UpdatableContainer<T>, partialOptions?: Partial<DisplayObjectArrayOptions<T>>);
+    /**
+     * Updates the display objects. Removes the deleted ones, updates the existing ones with their "trackBy" key, creates the new ones.
+     * @param items new items list
+     */
+    set(items: T[]): void;
+}
+
+interface MenuOptions {
+    readonly closeOnBackgroundClick: boolean;
+    readonly appearAnimationDuration: number;
+    readonly darkeningAlpha: number;
+}
+declare class Menu extends Container {
+    static closeAll(): SingleEvent;
+    readonly onOpen: actions_lib.Notifier<void>;
+    readonly onClose: actions_lib.Notifier<void>;
+    constructor(background: string, partialOptions: Partial<MenuOptions>);
+    getBoundingMask(): Sprite;
+    close(): SingleEvent;
+}
+
+declare class MenuEntity extends SingletonEntity {
+    readonly onCreate: actions_lib.Notifier<Menu>;
+    readonly onOpen: actions_lib.Notifier<void>;
+    readonly onClose: actions_lib.Notifier<void>;
+    constructor(background: string, partialOptions: Partial<MenuOptions>);
+    close(): SingleEvent;
+}
+
+declare class MouseWheelListenerUI extends Container {
+    readonly _onWheel: Action<number>;
+    readonly onWheel: actions_lib.Notifier<number>;
+    constructor(size: Vector);
+    destroy(): void;
+}
+
+interface ScrollAreaUIOptions {
+    readonly padding: number;
+    readonly smallContentAlign: 'start' | 'center' | 'end';
+}
+interface ScrollingOptions {
+    readonly instant: boolean;
+}
+declare class ScrollAreaUI extends Container {
+    get contentAreaSize(): Vector;
+    get contentSize(): Vector;
+    constructor(scrollAreaSize: Vector, partialOptions?: Partial<ScrollAreaUIOptions>);
+    scrollToTop(options?: ScrollingOptions): void;
+    scrollToBottom(options?: ScrollingOptions): void;
+}
+
+interface AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class AnimationInterpolationFunctions {
+    static boomerangTime(time: number): number;
+    static lineer(time: number): number;
+    static easeIn(time: number): number;
+    static easeOut(time: number): number;
+    static easeInOut(time: number): number;
+    static easeInOutCubic(t: number): number;
+}
+declare class AnimationLineer implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class AnimationEaseIn implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class AnimationEaseOut implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class AnimationEaseInOut implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class AnimationEaseInOutCubic implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class AnimationFlicker implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+declare class Animations {
+    static lineer: AnimationLineer;
+    static easeIn: AnimationEaseIn;
+    static easeOut: AnimationEaseOut;
+    static easeInOut: AnimationEaseInOut;
+    static easeInOutCubic: AnimationEaseInOutCubic;
+}
+
+declare enum ReAnimateHandlingType {
+    ThrowError = 1,
+    IgnoreNewAnimation = 2,
+    CompletePrevious = 3
+}
+declare enum AnimationsCompletionHandlingType {
+    ReturnToOriginal = 1,
+    StayInCurrentState = 2,
+    JumpToEnd = 3,
+    Loop = 4
+}
+interface AnimationOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+    readonly reAnimateHandling: ReAnimateHandlingType;
+    readonly completionHandling: AnimationsCompletionHandlingType;
+}
+type NumericKeys<T> = {
+    [P in keyof T]: T[P] extends number ? P : never;
+}[keyof T] & string;
+declare class Animator<T extends object = any, K extends NumericKeys<T> = NumericKeys<T>> {
+    get animating(): boolean;
+    get target(): T;
+    get value(): Notifier<T>;
+    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;
+    completeAnimation(completionHandling?: AnimationsCompletionHandlingType): void;
+}
+
+interface FadeInContentOptions {
+    duration: number;
+    animation: AnimatorAnimation;
+}
+declare class FadeInContent<T> extends Container {
+    constructor(_createFunction: (value: {
+        state: T;
+        container: Container;
+    }) => void, partialOptions?: Partial<FadeInContentOptions>);
+    setState(state: T | undefined, options?: {
+        instant?: boolean;
+    }): this;
+}
+
+interface StateAnimationOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+}
+declare enum AnimationState$1 {
+    Idle = 1,
+    Transitioning = 2,
+    Reverting = 3
+}
+declare class StateAnimation<T> extends Attachable {
+    get currentState(): {
+        value: number;
+        state: T | undefined;
+        nextState: T | undefined;
+        queuedState: T | undefined;
+        animationState: AnimationState$1;
+    };
+    constructor(partialOptions?: Partial<StateAnimationOptions>);
+    setState(state: 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;
+    };
+    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 options - Optional options.
+     * @param options.instant - If true, the state will be set immediately.
+     */
+    setState(state: T | undefined, options?: {
+        instant?: boolean;
+    }): void;
+    onStateChange(callback: (state: T | undefined) => void): this;
+    onValueChange(callback: (value: number) => void): this;
+}
+
+declare enum ScrollDirection {
+    Horizontal = 1,
+    Vertical = 2
+}
+interface ScrollInContentOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+    readonly size: Vector;
+    readonly margin: number;
+    readonly direction: ScrollDirection;
+}
+declare class SlideInContentByIndex extends Container {
+    constructor(_createFunction: (value: {
+        index: number;
+        container: Container;
+    }) => void, partialOptions?: Partial<ScrollInContentOptions>);
+    setIndex(index: number, options?: {
+        instant?: boolean;
+    }): this;
+}
+declare class SlideInContent<T> extends SlideInContentByIndex {
+    readonly itemToIndex: Map<T, number>;
+    readonly indexToItem: Map<number, T>;
+    constructor(items: T[], createFunction: (value: {
+        index: number;
+        item: T;
+        container: Container;
+    }) => void, partialOptions?: Partial<ScrollInContentOptions>);
+    setItem(item: T, options?: {
+        instant?: boolean;
+    }): this;
+}
+
+declare enum SlideStateAnimationState {
+    Appear = 1,
+    Disappear = 2
+}
+declare class SlideStateAnimation extends Attachable {
+    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 {
+    add(vector: Vector): void;
+    has(vector: Vector): boolean;
+    delete(vector: Vector): boolean;
+}
+
+declare class DeltaTime {
+    static adjustMultiplier(multiplier: number, delta: number): number;
+}
+
+declare class ClosestAvailableSpaceHelper {
+    static findByConvertingGridSpace(grid: Grid<boolean>, boundingBox: Rectangle, cellSize: number): Vector | undefined;
+    static find(availabilityGrid: Grid<boolean>, desiredPosition: Vector, objectSize: Vector): Vector | undefined;
+}
+
+interface PathFinderResult {
+    directPathAvailable: boolean;
+    path: Vector[];
+}
+declare class PathFinder {
+    static findPath(grid: Grid<boolean>, startingPosition: Vector, targetPosition: Vector, type: GridNeighborType): PathFinderResult;
+}
+
+declare class VectorFieldPathFinder {
+    constructor(_targetArea: Rectangle, _availabilityGrid: Grid<boolean>);
+    getDirectionToTarget(startingPosition: Vector): Radian | undefined;
+}
+
+declare class ScrollMaskUI extends Container {
+    constructor(container: Container, size: Vector, padding: number, direction?: ScrollDirection);
+}
+
+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 CameraGateway {
+    createCamera(): string;
+    update(time: number, delta: number): void;
+    setPosition(position: Vector): void;
+    setTransition(options: FocusingOptions): void;
+    getCameraPosition(): Vector;
+}
+
+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): SingleEvent;
+}
+
+interface GameConfiguration {
+    readonly screenResolution?: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly devMode: boolean;
+    readonly backgroundColor: RGBColor;
+}
+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.Notifier<Vector>;
+    getScreenSize(): Vector;
+    readonly _screenSizeCenter: Variable<Vector>;
+    readonly screenSizeCenter: actions_lib.Notifier<Vector>;
+    getScreenSizeCenter(): 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;
+}
+
+declare class KeyboardService {
+    readonly _keyPressed: Action<string>;
+    readonly keyPressed: actions_lib.Notifier<string>;
+    readonly _keyReleased: Action<string>;
+    readonly keyReleased: actions_lib.Notifier<string>;
+    constructor();
+    isKeyDown(key: string): boolean;
+    isKeyJustPressed(key: string): boolean;
+}
+
+declare class MouseService {
+    readonly _initialMouseMovementHappened: Variable<boolean>;
+    readonly onInitialMouseMove: actions_lib.Notifier<boolean>;
+    get initialMouseMoveHappened(): boolean;
+    readonly _stagePosition: Variable<Vector>;
+    readonly stagePosition: actions_lib.Notifier<Vector>;
+    getStagePosition(): Vector;
+    readonly _screenPosition: Variable<Vector>;
+    readonly screenPosition: actions_lib.Notifier<Vector>;
+    getScreenPosition(): Vector;
+    readonly _mainButtonState: Variable<boolean>;
+    readonly mainButtonState: actions_lib.Notifier<boolean>;
+    getMainButtonState(): boolean;
+    readonly _secondaryButtonState: Variable<boolean>;
+    readonly secondaryButtonState: actions_lib.Notifier<boolean>;
+    getSecondaryButtonState(): boolean;
+    constructor();
+}
+
+declare class MouseTargetFocusService {
+    readonly _onTargetFocus: Action<Vector>;
+    readonly onTargetFocus: actions_lib.Notifier<Vector>;
+    get focusedInLastFrame(): boolean;
+    get lastFocusedPosition(): Vector | undefined;
+    constructor(_mouseService: MouseService);
+}
+
+type PhysicsBodyGroup = string;
+
+declare const SPEED_LIMIT = 10.8;
+declare const ROTATIONAL_SPEED_LIMIT = 10.01;
+interface PhysicsBodyDTO {
+    readonly entityID: number;
+    readonly classID: number;
+    readonly position: Vector;
+    readonly rotation: Radian;
+    readonly velocity: Vector;
+    readonly rotationalSpeed: number;
+}
+interface CollisionDetails {
+    readonly body: PhysicsBodyDTO;
+    readonly getPositionReletiveToObject: () => Vector;
+    readonly getPositionOnWorld: () => Vector;
+    readonly position: Vector;
+    readonly mass: number;
+    readonly area: number;
+    readonly normal: Vector;
+}
+interface CollisionReport {
+    readonly self: CollisionDetails;
+    readonly target: CollisionDetails;
+}
+declare enum PhysicsShapeType {
+    Point = 1,
+    Circle = 2,
+    Polygon = 3,
+    Rectangle = 4
+}
+type CircleShapeData = number;
+type RectangleShapeData = Vector;
+type PolygonShapeData = PolygonDefinition | undefined;
+interface ShapeDefinition {
+    readonly materialName: string;
+    readonly group: PhysicsBodyGroup;
+    readonly shapeType: PhysicsShapeType;
+    readonly shapeData: PolygonShapeData | RectangleShapeData | CircleShapeData | undefined;
+}
+interface PhysicsEntityDefinition {
+    readonly shapeDefinition: ShapeDefinition;
+    readonly position: Vector;
+    readonly rotation: Radian;
+    readonly addInEmptySpace: boolean;
+    readonly includeOnPathfinding: boolean;
+}
+
+declare abstract class PhysicsEntity extends Entity {
+    static getFromP2BodyID(p2BodyID: number): PhysicsEntity | undefined;
+    static getFromP2BodyIDOrFail(p2BodyID: number): PhysicsEntity;
+    static getPhysicsInstanceOrFail(id: number): PhysicsEntity;
+    static getPhysicsEntities(): PhysicsEntity[];
+    readonly _onCollision: Action<readonly CollisionReport[]>;
+    readonly onCollision: actions_lib.Notifier<readonly CollisionReport[]>;
+    get area(): number;
+    get mass(): number;
+    get collisions(): readonly CollisionReport[];
+    readonly physicsWorldID: number;
+    readonly physicsBodyGroup: PhysicsBodyGroup;
+    readonly includeInPathfinding: boolean;
+    protected readonly type: 'dynamic' | 'static';
+    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition, type: 'dynamic' | 'static');
+    abstract convertToDTO(): PhysicsBodyDTO;
+    destroy(): void;
+    canCollideWith(target: PhysicsEntity): boolean;
+}
+
+declare abstract class ImmovablePhysicsEntity extends PhysicsEntity {
+    readonly position: Vector;
+    readonly rotation: Radian;
+    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition);
+    convertToDTO(): PhysicsBodyDTO;
+}
+
+declare abstract class MovableEntity extends Entity {
+    readonly position: Variable<Vector>;
+    readonly rotation: Variable<Radian>;
+    readonly velocity: Variable<Vector>;
+    readonly rotationalSpeed: Variable<number>;
+    constructor();
+}
+
+declare abstract class MovablePhysicsEntity extends PhysicsEntity {
+    readonly position: Variable<Vector>;
+    readonly rotation: Variable<Radian>;
+    readonly velocity: Variable<Vector>;
+    readonly rotationalSpeed: Variable<number>;
+    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition);
+    convertToDTO(): PhysicsBodyDTO;
+}
+
+declare const BORDER_MATERIAL_NAME = "border";
+interface MaterialDefinition {
+    readonly id: string;
+    readonly density: number;
+    readonly velocityDrag: number;
+    readonly rotationalDrag: number;
+}
+interface MaterialContactDefinition {
+    readonly materialA: string;
+    readonly materialB: string;
+    readonly friction: number;
+    readonly bounciness: number;
+    readonly stiffness: number;
+}
+interface BorderProperties {
+    readonly friction: number;
+    readonly bounciness: number;
+    readonly stiffness: number;
+    readonly borderBodyGroup: PhysicsBodyGroup;
+}
+
+type InteractingBodyGroups = readonly (readonly [PhysicsBodyGroup, PhysicsBodyGroup])[];
+interface CreatePhysicsWorldRequestDTO {
+    readonly attachTo: number;
+    readonly mapSize: Vector;
+    readonly modifyUpdateCycle: boolean;
+    readonly borderProperties: BorderProperties;
+    readonly materialDefinitions: readonly MaterialDefinition[];
+    readonly materialContactDefinitions: readonly MaterialContactDefinition[];
+    readonly physicsBodyGroups: readonly PhysicsBodyGroup[];
+    readonly interactingBodyGroups: InteractingBodyGroups;
+}
+interface PhysicsExplosionOptions {
+    readonly testLayerID?: number;
+    readonly debugRayDuration?: number;
+    readonly hitOnlyClosest?: boolean;
+}
+interface HitTestOptions {
+    readonly overridePosition?: Vector;
+    readonly overrideRotation?: Radian;
+    readonly testLayerID?: number;
+}
+
+interface RayCast {
+    line: Line;
+    hits: RayCastHit[];
+}
+interface RayCastHit {
+    readonly body: p2.Body;
+    readonly hitPosition: () => Vector;
+    readonly hitDistance: () => number;
+    readonly isExternal: () => boolean;
+    readonly normal: Vector;
+    readonly fraction: number;
+    readonly line: Line;
+}
+interface ExplosionHit {
+    body: PhysicsBodyDTO;
+    isExternal: boolean;
+    normal: Vector;
+    fraction: number;
+    ratioOfHits: number;
+    raycastResults: readonly RayCastHit[];
+    getHitPosition: () => Vector;
+    getHitDistance: () => number;
+}
+interface MapSizeDTO {
+    readonly dimentions: Vector;
+    readonly center: Vector;
+}
+
+declare class PhysicsGateway {
+    createPhysicsWorld(request: CreatePhysicsWorldRequestDTO): number;
+    getMapSize(physicsWorldID: number): MapSizeDTO;
+    setPaused(pause: boolean, physicsWorldID: number): void;
+    hitTest(physicsEntityID: number, options?: HitTestOptions): boolean;
+    findPath(physicsWorldID: number, startingPosition: Vector, target: Vector | number, collidableWithGroup: PhysicsBodyGroup, neighborType: GridNeighborType): PathFinderResult;
+    findPathDirection(physicsWorldID: number, startingPosition: Vector, target: Vector | number, collidableWithGroup: PhysicsBodyGroup): Radian | undefined;
+    applyImpulse(physicsEntityID: number, hitPosition: Vector, hitDirection: Vector, severity: number): void;
+    createExplosion(physicsWorldID: number, explosionCenter: Vector, radius: number, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
+    createElipticExplosion(physicsWorldID: number, explosionCenter: Vector, rotation: Radian, size: Vector, physicsBodyGroup: PhysicsBodyGroup, severity: number, options?: PhysicsExplosionOptions): ExplosionHit[];
+    printPathfindingTestGrid(physicsWorldID: number, testLayerID: number, target: Vector | number, physicsBodyGroup: PhysicsBodyGroup, area: Rectangle, gridCellSize?: number): void;
+}
+
+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 ControllerDecoratorMeta, ControllerLink, type CreateDashedLineOptions, type CreatePhysicsWorldRequestDTO, Cursor, DEFAULT_RESOLUTION, DeltaTime, DisplayObjectArray, type DisplayObjectArrayOptions, type DropShadowOptions, Entity, EntityDecorator, type ExplosionHit, FadeInContent, type FadeInContentOptions, FadeInStateAnimation, FocusingAnimation, Game, type GlowEffectOptions, type GlowOptions, type GlowingShapeDefinition, Graphics, type HitTestOptions, ImmovablePhysicsEntity, type InteractingBodyGroups, KeyboardService, type MapSizeDTO, type MaterialContactDefinition, type MaterialDefinition, Menu, MenuEntity, type MenuOptions, MouseService, MouseTargetFocusService, MouseWheelListenerUI, 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 };