bard-legends-framework 0.10.8 → 0.11.0

package/dist/pixi/modules/CAMERA//360/237/247/251views/camera.view.d.ts

@@ -15,7 +15,7 @@ export declare class CameraView extends View {
     private alphaAnimator;
     private blackScreenAnimator;
     constructor(entity: CameraEntity);
-    protected destroySelf(): void;
+    destroy(): void;
     getLayers(): Record<CameraLayer, string>;
     appear(value: boolean, type: CameraAppearTransitionType): Promise<void>;
     private convertToCameraPosition;

package/dist/pixi/modules/CAMERA//360/237/247/251views/camera.view.js

@@ -66,9 +66,11 @@ let CameraView = class CameraView extends game_entities_1.View {
             .attach(this);
         this.appear(true, 'alpha');
     }
-    destroySelf() {
-        super.destroySelf();
-        game_1.Game.instance.resetScreenPositionToStagePositionFunction();
+    destroy() {
+        if (!this.destroyed) {
+            game_1.Game.instance.resetScreenPositionToStagePositionFunction();
+            super.destroy();
+        }
     }
     getLayers() {
         return {
@@ -101,7 +103,7 @@ let CameraView = class CameraView extends game_entities_1.View {
         }
     }
     convertToCameraPosition(positionInWorld) {
-        return helpers_lib_1.Vector.fromTo(positionInWorld, game_1.Game.instance.screenSizeCenter.value);
+        return helpers_lib_1.Vector.fromTo(positionInWorld, game_1.Game.instance.getScreenSizeCenter());
     }
 };
 exports.CameraView = CameraView;

package/dist/pixi/services/keyboard/keyboard.d.ts

@@ -1,7 +1,9 @@
 import { Action } from 'actions-lib';
 export declare class KeyboardService {
-    readonly keyPressed: Action<string>;
-    readonly keyReleased: Action<string>;
+    readonly _keyPressed: Action<string>;
+    readonly keyPressed: import("actions-lib").Notifier<string>;
+    readonly _keyReleased: Action<string>;
+    readonly keyReleased: import("actions-lib").Notifier<string>;
     private listOfPressedKeys;
     private listOfJustPressedKeys;
     constructor();

package/dist/pixi/services/keyboard/keyboard.js

@@ -15,18 +15,20 @@ const game_entities_1 = require("../../../game-entities");
 const service_1 = require("../../../game-entities/service/service");
 let KeyboardService = class KeyboardService {
     constructor() {
-        this.keyPressed = new actions_lib_1.Action();
-        this.keyReleased = new actions_lib_1.Action();
+        this._keyPressed = new actions_lib_1.Action();
+        this.keyPressed = this._keyPressed.notifier;
+        this._keyReleased = new actions_lib_1.Action();
+        this.keyReleased = this._keyReleased.notifier;
         this.listOfPressedKeys = new Set();
         this.listOfJustPressedKeys = new Set();
         window.addEventListener('keydown', event => {
             this.listOfPressedKeys.add(event.key);
             this.listOfJustPressedKeys.add(event.key);
-            !event.repeat && this.keyPressed.trigger(event.key);
+            !event.repeat && this._keyPressed.trigger(event.key);
         });
         window.addEventListener('keyup', event => {
             this.listOfPressedKeys.delete(event.key);
-            this.keyReleased.trigger(event.key);
+            this._keyReleased.trigger(event.key);
         });
         window.addEventListener('blur', () => {
             this.listOfPressedKeys.clear();

package/dist/pixi/services/mouse/mouse-target-focus.service.d.ts

@@ -3,7 +3,8 @@ import { Vector } from 'helpers-lib';
 import { MouseService } from './mouse.service';
 export declare class MouseTargetFocusService {
     private mouseService;
-    onTargetFocus: Action<Vector>;
+    readonly _onTargetFocus: Action<Vector>;
+    readonly onTargetFocus: import("actions-lib").Notifier<Vector>;
     get focusedInLastFrame(): boolean;
     get lastFocusedPosition(): Vector | undefined;
     private mouseStagePositionPrevious;

package/dist/pixi/services/mouse/mouse-target-focus.service.js

@@ -24,7 +24,8 @@ let MouseTargetFocusService = class MouseTargetFocusService {
     }
     constructor(mouseService) {
         this.mouseService = mouseService;
-        this.onTargetFocus = new actions_lib_1.Action();
+        this._onTargetFocus = new actions_lib_1.Action();
+        this.onTargetFocus = this._onTargetFocus.notifier;
         this.timePassFromLastTrigger = 0;
         this.triggerAfterCooldown = false;
         this._focusedInLastFrame = false;
@@ -35,7 +36,7 @@ let MouseTargetFocusService = class MouseTargetFocusService {
     }
     update(delta) {
         if (this.mouseStagePositionPrevious) {
-            let mousePositionChange = this.getPositionChange(this.mouseService.stagePosition.value, this.mouseStagePositionPrevious);
+            let mousePositionChange = this.getPositionChange(this.mouseService.getStagePosition(), this.mouseStagePositionPrevious);
             if (this.peakValueChange === undefined) {
                 this.peakValueChange = mousePositionChange;
             }
@@ -43,7 +44,7 @@ let MouseTargetFocusService = class MouseTargetFocusService {
                 this.check(mousePositionChange, delta);
             }
         }
-        this.mouseStagePositionPrevious = this.mouseService.stagePosition.value;
+        this.mouseStagePositionPrevious = this.mouseService.getStagePosition();
     }
     check(mousePositionChange, delta) {
         if (this.peakValueChange - mousePositionChange > 10) {
@@ -64,8 +65,8 @@ let MouseTargetFocusService = class MouseTargetFocusService {
             this.triggerAfterCooldown = false;
             this.timePassFromLastTrigger = 0;
             this._focusedInLastFrame = true;
-            this._lastFocusedPosition = this.mouseService.stagePosition.value;
-            this.onTargetFocus.trigger(this._lastFocusedPosition);
+            this._lastFocusedPosition = this.mouseService.getStagePosition();
+            this._onTargetFocus.trigger(this._lastFocusedPosition);
         }
         else {
             this.timePassFromLastTrigger += delta;

package/dist/pixi/services/mouse/mouse.service.d.ts

@@ -1,11 +1,21 @@
 import { Variable } from 'actions-lib';
 import { Vector } from 'helpers-lib';
 export declare class MouseService {
-    readonly mouseMoved: Variable<boolean>;
-    readonly stagePosition: Variable<Vector>;
-    readonly screenPosition: Variable<Vector>;
-    readonly mainButtonState: Variable<boolean>;
-    readonly secondaryButtonState: Variable<boolean>;
+    readonly _initialMouseMovementHappened: Variable<boolean>;
+    readonly onInitialMouseMove: import("actions-lib").Notifier<boolean>;
+    get initialMouseMoveHappened(): boolean;
+    readonly _stagePosition: Variable<Vector>;
+    readonly stagePosition: import("actions-lib").Notifier<Vector>;
+    getStagePosition(): Vector;
+    readonly _screenPosition: Variable<Vector>;
+    readonly screenPosition: import("actions-lib").Notifier<Vector>;
+    getScreenPosition(): Vector;
+    readonly _mainButtonState: Variable<boolean>;
+    readonly mainButtonState: import("actions-lib").Notifier<boolean>;
+    getMainButtonState(): boolean;
+    readonly _secondaryButtonState: Variable<boolean>;
+    readonly secondaryButtonState: import("actions-lib").Notifier<boolean>;
+    getSecondaryButtonState(): boolean;
     constructor();
     private startListeningMouseMove;
 }

package/dist/pixi/services/mouse/mouse.service.js

@@ -16,58 +16,78 @@ const service_1 = require("../../../game-entities/service/service");
 const update_cycle_1 = require("../../../game-entities/update-cycle");
 const __1 = require("../..");
 let MouseService = class MouseService {
+    get initialMouseMoveHappened() {
+        return this._initialMouseMovementHappened.value;
+    }
+    getStagePosition() {
+        return this._stagePosition.value;
+    }
+    getScreenPosition() {
+        return this._screenPosition.value;
+    }
+    getMainButtonState() {
+        return this._mainButtonState.value;
+    }
+    getSecondaryButtonState() {
+        return this._secondaryButtonState.value;
+    }
     constructor() {
-        this.mouseMoved = new actions_lib_1.Variable().set(false);
-        this.stagePosition = new actions_lib_1.Variable({ notifyOnChange: true }).set(helpers_lib_1.Vector.zero);
-        this.screenPosition = new actions_lib_1.Variable({ notifyOnChange: true }).set(helpers_lib_1.Vector.zero);
-        this.mainButtonState = new actions_lib_1.Variable().set(false);
-        this.secondaryButtonState = new actions_lib_1.Variable().set(false);
+        this._initialMouseMovementHappened = new actions_lib_1.Variable(false);
+        this.onInitialMouseMove = this._initialMouseMovementHappened.notifier;
+        this._stagePosition = new actions_lib_1.Variable(helpers_lib_1.Vector.zero, { notifyOnChange: true });
+        this.stagePosition = this._stagePosition.notifier;
+        this._screenPosition = new actions_lib_1.Variable(helpers_lib_1.Vector.zero, { notifyOnChange: true });
+        this.screenPosition = this._screenPosition.notifier;
+        this._mainButtonState = new actions_lib_1.Variable(false);
+        this.mainButtonState = this._mainButtonState.notifier;
+        this._secondaryButtonState = new actions_lib_1.Variable(false);
+        this.secondaryButtonState = this._secondaryButtonState.notifier;
         this.startListeningMouseMove();
         window.addEventListener('mousedown', event => {
             if (event.button === 0) {
-                this.mainButtonState.value = true;
+                this._mainButtonState.value = true;
             }
             else if (event.button === 2) {
-                this.secondaryButtonState.value = true;
+                this._secondaryButtonState.value = true;
             }
         });
         window.addEventListener('mouseup', event => {
             if (event.button === 0) {
-                this.mainButtonState.value = false;
+                this._mainButtonState.value = false;
             }
             else if (event.button === 2) {
-                this.secondaryButtonState.value = false;
+                this._secondaryButtonState.value = false;
             }
         });
         window.addEventListener('blur', () => {
-            this.mainButtonState.value = false;
-            this.secondaryButtonState.value = false;
+            this._mainButtonState.value = false;
+            this._secondaryButtonState.value = false;
         });
     }
     startListeningMouseMove() {
         let mouseScreenPosition = helpers_lib_1.Vector.zero;
         window.addEventListener('mousemove', event => {
             mouseScreenPosition = new helpers_lib_1.Vector(event.clientX, event.clientY);
-            this.mouseMoved.value = true;
+            this._initialMouseMovementHappened.value = true;
         });
         update_cycle_1.UpdateCycle.beforeSceneUpdateAction
             .subscribe(() => {
-            this.screenPosition.value = mouseScreenPosition;
+            this._screenPosition.value = mouseScreenPosition;
         })
             .attachToRoot();
         update_cycle_1.UpdateCycle.afterSceneUpdateAction
             .subscribe(() => {
-            let newStagePosition = __1.Game.instance.screenPositonToStagePosition(this.screenPosition.value);
-            if (newStagePosition.isEqual(this.stagePosition.value)) {
+            let newStagePosition = __1.Game.instance.screenPositonToStagePosition(this._screenPosition.value);
+            if (newStagePosition.isEqual(this._stagePosition.value)) {
                 // Trigger pointer move event, because content might slide under the mouse cursor
                 __1.Game.instance.renderer.events['onPointerMove'](new PointerEvent('pointermove', {
-                    clientX: this.screenPosition.value.x,
-                    clientY: this.screenPosition.value.y,
+                    clientX: this._screenPosition.value.x,
+                    clientY: this._screenPosition.value.y,
                     pointerType: 'mouse'
                 }));
             }
             else {
-                this.stagePosition.value = newStagePosition;
+                this._stagePosition.value = newStagePosition;
             }
         })
             .attachToRoot();

package/dist/utilities/animator/animating-content/fade-in-content.d.ts

@@ -0,0 +1,18 @@
+import { Container } from '../../../pixi';
+import { AnimatorAnimation } from '../animations';
+export interface FadeInContentOptions {
+    duration: number;
+    animation: AnimatorAnimation;
+}
+export declare class FadeInContent<T> extends Container {
+    private createFunction;
+    private stateAnimation;
+    private content;
+    constructor(createFunction: (value: {
+        state: T;
+        container: Container;
+    }) => void, partialOptions?: Partial<FadeInContentOptions>);
+    setState(state: T | undefined, options?: {
+        instant?: boolean;
+    }): this;
+}

package/dist/utilities/animator/animating-content/fade-in-content.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FadeInContent = void 0;
+const pixi_1 = require("../../../pixi");
+const animations_1 = require("../animations");
+const visit_disappear_state_animation_1 = require("../state-animation/visit-disappear-state-animation");
+class FadeInContent extends pixi_1.Container {
+    constructor(createFunction, partialOptions) {
+        super();
+        this.createFunction = createFunction;
+        let options = {
+            duration: 200,
+            animation: new animations_1.AnimationEaseInOut(),
+            ...partialOptions
+        };
+        this.alpha = 0;
+        this.stateAnimation = new visit_disappear_state_animation_1.VisitDisappearStateAnimation(options)
+            .onStateChange(state => {
+            this.content?.destroy();
+            this.content = undefined;
+            if (state !== undefined) {
+                this.content = new pixi_1.Container().displayParent(this).attach(this);
+                this.createFunction({ state, container: this.content });
+            }
+        })
+            .onValueChange(value => {
+            this.alpha = value;
+        })
+            .attach(this);
+    }
+    setState(state, options) {
+        this.stateAnimation.setState(state, options);
+        return this;
+    }
+}
+exports.FadeInContent = FadeInContent;
+//# sourceMappingURL=fade-in-content.js.map

package/dist/utilities/animator/animating-content/slide-in-content.d.ts

@@ -0,0 +1,37 @@
+import { Vector } from 'helpers-lib';
+import { Container } from '../../../pixi';
+import { AnimatorAnimation } from '../animations';
+export interface ScrollInContentOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+    readonly size: Vector;
+    readonly margin: number;
+    readonly direction: 'horizontal' | 'vertical';
+}
+export declare class SlideInContentByIndex extends Container {
+    private createFunction;
+    private options;
+    private directionProperty;
+    private stateAnimation;
+    private contents;
+    constructor(createFunction: (value: {
+        index: number;
+        container: Container;
+    }) => void, partialOptions?: Partial<ScrollInContentOptions>);
+    setIndex(index: number, options?: {
+        instant?: boolean;
+    }): this;
+    private createMask;
+}
+export 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;
+}

package/dist/utilities/animator/animating-content/slide-in-content.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlideInContent = exports.SlideInContentByIndex = void 0;
+const helpers_lib_1 = require("helpers-lib");
+const pixi_1 = require("../../../pixi");
+const animations_1 = require("../animations");
+const slide_state_animation_1 = require("../state-animation/slide-state-animation");
+class SlideInContentByIndex extends pixi_1.Container {
+    constructor(createFunction, partialOptions) {
+        super();
+        this.createFunction = createFunction;
+        this.directionProperty = 'x';
+        this.contents = new Map();
+        this.options = {
+            duration: 300,
+            animation: new animations_1.AnimationEaseInOutCubic(),
+            size: new helpers_lib_1.Vector(500, 500),
+            margin: 20,
+            direction: 'horizontal',
+            ...partialOptions
+        };
+        let fullSize = this.options.direction === 'horizontal'
+            ? new helpers_lib_1.Vector(this.options.size.x + this.options.margin * 2, this.options.size.y)
+            : new helpers_lib_1.Vector(this.options.size.x, this.options.size.y + this.options.margin * 2);
+        let wrapper = new pixi_1.Container()
+            .setPosition(this.options.direction === 'horizontal' ? new helpers_lib_1.Vector(-this.options.margin, 0) : new helpers_lib_1.Vector(0, -this.options.margin), { round: false })
+            .displayParent(this)
+            .attach(this);
+        this.createMask(fullSize, this.options.margin, this.options.direction, wrapper);
+        this.directionProperty = this.options.direction === 'horizontal' ? 'x' : 'y';
+        this.stateAnimation = new slide_state_animation_1.SlideStateAnimation({
+            duration: this.options.duration,
+            animation: this.options.animation
+        })
+            .onStateChange((state, index) => {
+            if (state === slide_state_animation_1.SlideStateAnimationState.appear) {
+                let container = new pixi_1.Container().displayParent(this).attach(this);
+                this.contents.set(index, container);
+                this.createFunction({ index, container });
+            }
+            else {
+                let container = this.contents.get(index);
+                if (container) {
+                    container.destroy();
+                    this.contents.delete(index);
+                }
+            }
+        })
+            .onValueChange((value, index) => {
+            let container = this.contents.get(index);
+            if (container) {
+                let vec = { x: 0, y: 0 };
+                vec[this.directionProperty] = fullSize[this.directionProperty] * value + this.options.margin;
+                container.setPosition(helpers_lib_1.Vector.fromVec2(vec), { round: false });
+            }
+        })
+            .attach(this);
+        this.addChildTo = wrapper;
+    }
+    setIndex(index, options) {
+        this.stateAnimation.setIndex(index, options);
+        return this;
+    }
+    createMask(size, padding, direction, container) {
+        new pixi_1.ScrollMaskUI(container, new helpers_lib_1.Vector(size.x, size.y), padding, direction).attach(this);
+    }
+}
+exports.SlideInContentByIndex = SlideInContentByIndex;
+class SlideInContent extends SlideInContentByIndex {
+    constructor(items, createFunction, partialOptions) {
+        super((value) => {
+            let item = this.indexToItem.get(value.index);
+            if (item) {
+                createFunction({ index: value.index, item, container: value.container });
+            }
+            else {
+                throw new Error(`SlideInContent: The item with index '${value.index}' is not part of the items list`);
+            }
+        }, partialOptions);
+        this.itemToIndex = new Map();
+        this.indexToItem = new Map();
+        items.forEach((item, index) => {
+            this.itemToIndex.set(item, index);
+            this.indexToItem.set(index, item);
+        });
+    }
+    setItem(item, options) {
+        let index = this.itemToIndex.get(item);
+        if (index !== undefined) {
+            this.setIndex(index, options);
+        }
+        else {
+            throw new Error(`SlideInContent: The item '${item}' is not part of the items list`);
+        }
+        return this;
+    }
+}
+exports.SlideInContent = SlideInContent;
+//# sourceMappingURL=slide-in-content.js.map

package/dist/utilities/animator/animations.d.ts

@@ -0,0 +1,37 @@
+export interface AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export 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;
+}
+export declare class AnimationLineer implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationEaseIn implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationEaseOut implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationEaseInOut implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationEaseInOutCubic implements AnimatorAnimation {
+    start(): void;
+    multiplierFunction(t: number): number;
+}
+export declare class AnimationFlicker implements AnimatorAnimation {
+    private timeGrid;
+    start(): void;
+    multiplierFunction(t: number): number;
+}

package/dist/utilities/animator/animations.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimationFlicker = exports.AnimationEaseInOutCubic = exports.AnimationEaseInOut = exports.AnimationEaseOut = exports.AnimationEaseIn = exports.AnimationLineer = exports.AnimationInterpolationFunctions = void 0;
+const helpers_lib_1 = require("helpers-lib");
+class AnimationInterpolationFunctions {
+    static boomerangTime(time) {
+        return 1 - Math.abs(time - 0.5) * 2;
+    }
+    static lineer(time) {
+        return time;
+    }
+    static easeIn(time) {
+        return Math.pow(time, 2);
+    }
+    static easeOut(time) {
+        return 1 - Math.pow(1 - time, 2);
+    }
+    static easeInOut(time) {
+        if (time < 0.5) {
+            return 2 * time * time;
+        }
+        else {
+            time -= 1;
+            return 1 - 2 * time * time;
+        }
+    }
+    static easeInOutCubic(t) {
+        let a = 2 * t - 2;
+        return t < 0.5 ? 4 * Math.pow(t, 3) : (t - 1) * Math.pow(a, 2) + 1;
+    }
+}
+exports.AnimationInterpolationFunctions = AnimationInterpolationFunctions;
+class AnimationLineer {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.lineer(t);
+    }
+}
+exports.AnimationLineer = AnimationLineer;
+class AnimationEaseIn {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.easeIn(t);
+    }
+}
+exports.AnimationEaseIn = AnimationEaseIn;
+class AnimationEaseOut {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.easeOut(t);
+    }
+}
+exports.AnimationEaseOut = AnimationEaseOut;
+class AnimationEaseInOut {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.easeInOut(t);
+    }
+}
+exports.AnimationEaseInOut = AnimationEaseInOut;
+class AnimationEaseInOutCubic {
+    start() { }
+    multiplierFunction(t) {
+        return AnimationInterpolationFunctions.easeInOutCubic(t);
+    }
+}
+exports.AnimationEaseInOutCubic = AnimationEaseInOutCubic;
+class AnimationFlicker {
+    start() {
+        this.timeGrid = new Array(10).fill(0);
+        helpers_lib_1.Random.integerBetween(0, 9);
+        this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+        if (Math.random() < 0.3) {
+            helpers_lib_1.Random.integerBetween(0, 9);
+            this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+        }
+        if (Math.random() < 0.2) {
+            helpers_lib_1.Random.integerBetween(0, 9);
+            this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+        }
+    }
+    multiplierFunction(t) {
+        let index = Math.floor(t * 10);
+        return this.timeGrid[index];
+    }
+}
+exports.AnimationFlicker = AnimationFlicker;
+//# sourceMappingURL=animations.js.map

package/dist/utilities/animator/animator.d.ts

@@ -0,0 +1,61 @@
+import { Attachable } from 'actions-lib';
+import { AnimatorAnimation } from './animations';
+export interface AnimationState {
+    duration: number;
+    elapsedTime: number;
+    startingValue: number;
+    targetValue: number;
+    loop: boolean;
+    completeAnimationsHandling: CompleteAnimationsHandlingType;
+}
+export declare enum ReAnimateHandlingType {
+    throwError = "throwError",
+    ignoreNewAnimation = "ignoreNewAnimation",
+    completePrevious = "completePrevious"
+}
+export declare enum CompleteAnimationsHandlingType {
+    returnToOriginal = "returnToOriginal",
+    stayInCurrentState = "stayInCurrentState",
+    jumpToEnd = "jumpToEnd"
+}
+export interface AnimationOptions {
+    duration?: number;
+    animation?: AnimatorAnimation;
+    loop?: boolean;
+    reAnimateHandling?: ReAnimateHandlingType;
+    completeAnimationsHandling?: CompleteAnimationsHandlingType;
+}
+export declare class Animator<T> extends Attachable {
+    private target;
+    private static animatedObjects;
+    private effectOn;
+    private defaultDuration;
+    private defaultAnimation;
+    private defaultLoop;
+    private defaultReAnimateHandling;
+    private defaultCompleteAnimationsHandling;
+    private onChangeCallback?;
+    private onCompleteCallback?;
+    private running;
+    private propertyStates;
+    private updateCycleSubscription;
+    private allResolvers;
+    get isAnimating(): boolean;
+    constructor(target: T, effectOn: string | string[], options?: AnimationOptions);
+    onChange(callback: (target: T) => void): Animator<T>;
+    onComplete(callback: (key: string, value: number) => void): Animator<T>;
+    destroy(): void;
+    getAnimationStateOfKey(key: string): AnimationState | undefined;
+    pauseAnimations(): void;
+    resumeAnimations(): void;
+    completeAnimations(completeAnimationsHandling?: CompleteAnimationsHandlingType): void;
+    set(values: Record<string, any>): void;
+    animate(values: Record<string, any>, options?: AnimationOptions): Promise<void>;
+    private completeAnimationOfProperty;
+    private checkOngoingAnimations;
+    private update;
+    private subscribeUpdateCycle;
+    private unsubscribeUpdateCycle;
+    private checkPropertyValidity;
+    private triggerOnChange;
+}