@woosh/meep-engine 2.165.6 → 2.165.7

package/src/engine/platform/EnginePlatform.d.ts

@@ -1,14 +1,24 @@
-import {AchievementGateway} from "../achievements/AchievementGateway";
-import Storage from "../save/Storage";
-
-export class EnginePlatform {
-    getStorage(): Storage;
-
-    getAchievementGateway(): AchievementGateway;
-
-    pickDefaultLocale(options: string[]): string;
-
-    startup(): Promise<any>;
-
-    shutdown(): Promise<any>;
-}
+export class EnginePlatform {
+    /**
+     * @returns {Storage}
+     */
+    getStorage(): Storage;
+    /**
+     * @returns {AchievementGateway}
+     */
+    getAchievementGateway(): AchievementGateway;
+    /**
+     * @param {string[]} options
+     * @returns {string}
+     */
+    pickDefaultLocale(options: string[]): string;
+    /**
+     * @returns {Promise}
+     */
+    startup(): Promise<any>;
+    /**
+     * @returns {Promise}
+     */
+    shutdown(): Promise<any>;
+}
+//# sourceMappingURL=EnginePlatform.d.ts.map

package/src/engine/platform/WebEnginePlatform.d.ts

@@ -1,5 +1,20 @@
-import {EnginePlatform} from "./EnginePlatform";
-
-export class WebEnginePlatform extends EnginePlatform {
-    constructor(options?: { storageKey?: string })
-}
+export class WebEnginePlatform extends EnginePlatform {
+    constructor({ storageKey }?: {
+        storageKey?: string;
+    });
+    /**
+     *
+     * @type {Storage}
+     */
+    storage: Storage;
+    /**
+     *
+     * @type {StorageAchievementGateway}
+     */
+    achievements: StorageAchievementGateway;
+    getAchievementGateway(): StorageAchievementGateway;
+    pickDefaultLocale(localeOptions: any): any;
+}
+import { EnginePlatform } from "./EnginePlatform.js";
+import { StorageAchievementGateway } from "../achievements/gateway/StorageAchievementGateway.js";
+//# sourceMappingURL=WebEnginePlatform.d.ts.map

package/src/engine/platform/WebEnginePlatform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebEnginePlatform.d.ts","sourceRoot":"","sources":["../../../../src/engine/platform/WebEnginePlatform.js"],"names":[],"mappings":"AAMA;IACI;;OAiBC;IAZG;;;OAGG;IACH,SAFU,OAAO,CAE6C;IAG9D;;;OAGG;IACH,cAFU,yBAAyB,CAE4B;IAGnE,sBAEC;IAED,mDAEC;IAED,2CA+DC;CACJ;+BA/F8B,qBAAqB;0CAFV,sDAAsD"}
+{"version":3,"file":"WebEnginePlatform.d.ts","sourceRoot":"","sources":["../../../../src/engine/platform/WebEnginePlatform.js"],"names":[],"mappings":"AAMA;IACI;;OAiBC;IAZG;;;OAGG;IACH,SAFU,OAAO,CAE6C;IAG9D;;;OAGG;IACH,cAFU,yBAAyB,CAE4B;IAOnE,mDAEC;IAED,2CA+DC;CACJ;+BA/F8B,qBAAqB;0CAFV,sDAAsD"}

package/src/engine/plugin/EnginePlugin.d.ts

@@ -1,3 +1,36 @@
-export class EnginePlugin {
-
-}
+export class EnginePlugin extends BaseProcess {
+    /**
+     *
+     * @type {Class<EnginePlugin>[]}
+     * @private
+     */
+    private __dependencies;
+    /**
+     *
+     * @type {Engine|null}
+     */
+    engine: Engine | null;
+    attach(): void;
+    /**
+     *
+     * @returns {Class<EnginePlugin>[]}
+     */
+    get dependencies(): Class<EnginePlugin>[];
+    /**
+     *
+     * @param {Engine} engine
+     */
+    initialize(engine: Engine): void;
+    /**
+     *
+     * @return {Promise}
+     */
+    startup(): Promise<any>;
+    /**
+     *
+     * @return {Promise}
+     */
+    shutdown(): Promise<any>;
+}
+import { BaseProcess } from "../../core/process/BaseProcess.js";
+//# sourceMappingURL=EnginePlugin.d.ts.map

package/src/engine/plugin/EnginePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnginePlugin.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePlugin.js"],"names":[],"mappings":"AAGA;IAEI;;;;OAIG;IACH,uBAAoB;IAEpB;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd,eAYC;IAXG;;;OAGG;IACH,IAFU,MAAM,CAEJ;IAShB;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,iCAQC;IAED,iBAEC;IAGD;;;OAGG;IACH,wBAIC;IAGD;;;OAGG;IACH,yBAIC;CACJ;4BA9E2B,mCAAmC"}
+{"version":3,"file":"EnginePlugin.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePlugin.js"],"names":[],"mappings":"AAGA;IAEI;;;;OAIG;IACH,uBAAoB;IAEpB;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd,eAYC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,iCAQC;IAOD;;;OAGG;IACH,wBAIC;IAGD;;;OAGG;IACH,yBAIC;CACJ;4BA9E2B,mCAAmC"}

package/src/engine/plugin/EnginePluginManager.d.ts

@@ -1,16 +1,85 @@
-import {BaseProcess} from "../../core/process/BaseProcess";
-import {Reference} from "../reference/v2/Reference";
-
-interface Type<T> extends Function {
-    new(...args: any[]): T;
-}
-
-export class EnginePluginManager extends BaseProcess {
-    acquire<T>(klass: Type<T>): Promise<Reference<T>>
-
-    getPlugin<T>(klass: Type<T>): T | undefined
-
-    startup(): Promise<void>
-
-    shutdown(): Promise<void>
-}
+export class EnginePluginManager extends BaseProcess {
+    /**
+     * @private
+     * @type {Map<Class, PluginReferenceContext>}
+     */
+    private __plugins;
+    /**
+     *
+     * @type {Engine}
+     */
+    engine: Engine;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __version;
+    /**
+     *
+     * @returns {EnginePlugin[]}
+     * @private
+     */
+    private __getActivePluginInstances;
+    /**
+     *
+     * @returns {PluginReferenceContext[]}
+     * @private
+     */
+    private __getActivePluginContexts;
+    /**
+     *
+     * @param {PluginReferenceContext} context
+     * @param {ProcessState} state
+     * @returns {Promise<void>}
+     * @private
+     */
+    private __transition_plugin_to_state;
+    /**
+     *
+     * @param {ProcessState} state
+     * @returns {Promise<void>}
+     * @private
+     */
+    private __transition_active_plugins_to;
+    /**
+     *
+     * @param {PluginReferenceContext} ctx
+     * @private
+     */
+    private __handle_last_plugin_reference_release;
+    /**
+     *
+     * @param {Engine} engine
+     */
+    initialize(engine: Engine): void;
+    startup(): Promise<void>;
+    shutdown(): Promise<void>;
+    /**
+     * @template T
+     * @param {Class<T>} PluginClass
+     * @returns {Promise<Reference<T>>}
+     */
+    acquire<T>(PluginClass: Class<T>): Promise<Reference<T>>;
+    /**
+     *
+     * @param {Class[]} PluginClasses
+     * @returns {Promise<Reference[]>}
+     */
+    acquireMany(PluginClasses: Class[]): Promise<Reference[]>;
+    /**
+     * @template T
+     * @param {Class<T>} PluginClass
+     * @returns {T|undefined}
+     */
+    getPlugin<T_1>(PluginClass: Class<T_1>): T_1;
+    /**
+     * @template T
+     * @param {string} id
+     * @returns {EnginePlugin|T|undefined}
+     */
+    getById<T_2>(id: string): EnginePlugin | T_2;
+}
+import { BaseProcess } from "../../core/process/BaseProcess.js";
+import { EnginePlugin } from "./EnginePlugin.js";
+//# sourceMappingURL=EnginePluginManager.d.ts.map

package/src/engine/plugin/EnginePluginManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnginePluginManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePluginManager.js"],"names":[],"mappings":"AAOA;IAEI;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,eAAc;IAEd;;;;OAIG;IACH,kBAAc;IAEd;;;;OAIG;IACH,mCAYC;IAED;;;;OAIG;IACH,kCAYC;IAGD;;;;;;OAMG;IACH,qCA0BC;IAED;;;;;OAKG;IACH,uCA2BC;IAED;;;;OAIG;IACH,+CAaC;IAED;;;OAGG;IACH,iCAgBC;IAED,iBAcC;IAED,yBAIC;IAED,0BAIC;IAED;;;;OAIG;IACH,mCAFa,qBAAqB,CAyDjC;IAED;;;;OAIG;IACH,2BAHW,OAAO,GACL,QAAQ,WAAW,CAAC,CAQhC;IAED;;;;OAIG;IACH,6CAaC;IAED;;;;OAIG;IACH,iBAHW,MAAM,sBAahB;CACJ;4BA9T2B,mCAAmC;6BAElC,mBAAmB"}
+{"version":3,"file":"EnginePluginManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePluginManager.js"],"names":[],"mappings":"AAOA;IAEI;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,eAAc;IAEd;;;;OAIG;IACH,kBAAc;IAEd;;;;OAIG;IACH,mCAYC;IAED;;;;OAIG;IACH,kCAYC;IAGD;;;;;;OAMG;IACH,qCA0BC;IAED;;;;;OAKG;IACH,uCA2BC;IAED;;;;OAIG;IACH,+CAaC;IAED;;;OAGG;IACH,iCAgBC;IAkBD,yBAIC;IAED,0BAIC;IAED;;;;OAIG;IACH,mCAFa,qBAAqB,CAyDjC;IAED;;;;OAIG;IACH,2BAHW,OAAO,GACL,QAAQ,WAAW,CAAC,CAQhC;IAED;;;;OAIG;IACH,6CAaC;IAED;;;;OAIG;IACH,iBAHW,MAAM,sBAahB;CACJ;4BA9T2B,mCAAmC;6BAElC,mBAAmB"}

package/src/engine/plugin/PluginReferenceContext.d.ts

@@ -29,7 +29,7 @@ export class PluginReferenceContext {
      */
     dependency_references: List<Reference<EnginePlugin>>;
     on: {
-        lastReleased: Signal<any, any, any, any, any, any, any, any>;
+        lastReleased: Signal;
     };
     /**
      *

package/src/engine/reference/v2/Reference.d.ts

@@ -1,17 +1,55 @@
-import Signal from "../../../core/events/signal/Signal";
-
-export class Reference<T> {
-    readonly onReleased: Signal<this, T>
-
-    readonly bound: boolean
-
-    getValue(): T | null
-
-    release(): void
-
-    bind(v: T): void
-
-    static from<X>(x: X): Reference<X>
-
-    static readonly NULL: Readonly<Reference<any>>
-}
+/**
+ * Value container, allows reference counting through {@link #onReleased} signal
+ * Intended for usage with reference-managing systems
+ * @example
+ *      const ref: Reference<Texture> = texture_system.get(some_id);
+ *      // do work with texture
+ *      ref.release(); // we're done with the resource, texture_system will be notified
+ *      // now ref.getValue() === null, reference is no longer valid
+ * @example
+ *      const ref: Reference<Texture> = Reference.from(texture);
+ *      ref.onReleased.add((this_ref:Reference<Texture>, texture:Texture) => {
+ *          // cleanup memory when the reference is released
+ *          texture.dispose();
+ *      });
+ *      // pass the reference to some other system for use
+ * @template T
+ */
+export class Reference<T> {
+    /**
+     * Produces a new instance of a bound reference with a given value.
+     * Same as calling {@link bind} on a new instance.
+     *
+     * @template X
+     * @param {X} x
+     * @return {Reference<X>}
+     * @see bind
+     */
+    static from<X>(x: X): Reference<X>;
+    get bound(): boolean;
+    /**
+     *
+     * @returns {Signal<this,T>}
+     */
+    get onReleased(): any;
+    /**
+     *
+     * @param {T} value
+     */
+    bind(value: T): void;
+    /**
+     *
+     * @returns {T}
+     */
+    getValue(): T;
+    /**
+     * Release value being referenced. After this the held value is set to null
+     * This method is idempotent, calling it multiple times is safe
+     */
+    release(): void;
+    #private;
+}
+export namespace Reference {
+    let NULL: Readonly<Reference<any>>;
+}
+//# sourceMappingURL=Reference.d.ts.map

package/src/engine/reference/v2/Reference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Reference.d.ts","sourceRoot":"","sources":["../../../../../src/engine/reference/v2/Reference.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IAoCI;;;;;;;;OAQG;IACH,mCAMC;IA3BD,qBAEC;IAED;;;OAGG;IACH,gEAEC;IAmBD;;;OAGG;IACH,YAFW,CAAC,QAcX;IAED;;;OAGG;IACH,YAFa,CAAC,CAIb;IAED;;;OAGG;IACH,gBAcC;;CACJ;;cAKS,wBAAmB;;mBA1HV,uCAAuC"}
+{"version":3,"file":"Reference.d.ts","sourceRoot":"","sources":["../../../../../src/engine/reference/v2/Reference.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IAoCI;;;;;;;;OAQG;IACH,mCAMC;IA3BD,qBAEC;IAED;;;OAGG;IACH,sBAEC;IAmBD;;;OAGG;IACH,YAFW,CAAC,QAcX;IAED;;;OAGG;IACH,YAFa,CAAC,CAIb;IAED;;;OAGG;IACH,gBAcC;;CACJ;;cAKS,wBAAmB"}

package/src/engine/save/GameStateLoader.d.ts

@@ -1,6 +1,5 @@
 export default GameStateLoader;
 declare class GameStateLoader extends EnginePlugin {
-    id: string;
     /**
      *
      * @type {Storage}

package/src/engine/save/GameStateLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GameStateLoader.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/GameStateLoader.js"],"names":[],"mappings":";AAIA;IAEI,WAAyB;IAEzB;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf,yBAEC;IAED,gEAeC;IAED;;;;;;OAMG;IACH,iBALW,MAAM,iEAShB;IAED;;;;;OAKG;IACH,yDAIC;IAED;;;;;;OAMG;IACH,WALW,MAAM,kBACG,WAAW,yCAEX,MAAM,gBA6CzB;IAED;;;;;OAKG;IACH,YAJW,MAAM,kBACG,MAAM,kCAoBzB;IAED;;;;;OAKG;IACH,aAJW,MAAM,kBACG,OAAO,kCAwB1B;CACJ;6BAnK4B,2BAA2B"}
+{"version":3,"file":"GameStateLoader.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/GameStateLoader.js"],"names":[],"mappings":";AAIA;IAII;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf,yBAEC;IAED,gEAeC;IAED;;;;;;OAMG;IACH,iBALW,MAAM,iEAShB;IAED;;;;;OAKG;IACH,yDAIC;IAED;;;;;;OAMG;IACH,WALW,MAAM,kBACG,WAAW,yCAEX,MAAM,gBA6CzB;IAED;;;;;OAKG;IACH,YAJW,MAAM,kBACG,MAAM,kCAoBzB;IAED;;;;;OAKG;IACH,aAJW,MAAM,kBACG,OAAO,kCAwB1B;CACJ;6BAnK4B,2BAA2B"}

package/src/engine/save/Storage.d.ts

@@ -1,15 +1,75 @@
-export default class Storage {
-    storeBinary(key: string, value: ArrayBuffer, resolve: Function, reject: Function, progress: Function): void
-
-    loadBinary(key: string, resolve: Function, reject: Function, progress: Function): void
-
-    store(key: string, value: any, resolve: Function, reject: Function, progress: Function): void
-
-    load(key: string, resolve: Function, reject: Function, progress: Function): void
-
-    list(resolve: Function, reject: Function): void
-
-    remove(key: string, resolve: Function, reject: Function): void
-
-    contains(key: string, resolve: Function, reject: Function): void
-}
+export default Storage;
+declare class Storage {
+    /**
+     *
+     * @param {string} key
+     * @param {ArrayBuffer} value
+     * @param {function} resolve
+     * @param {function} reject
+     * @param {function} progress
+     */
+    storeBinary(key: string, value: ArrayBuffer, resolve: Function, reject: Function, progress: Function): void;
+    /**
+     *
+     * @param {string} key
+     * @param {function(ArrayBuffer)} resolve
+     * @param {function} reject
+     * @param {function} progress
+     */
+    loadBinary(key: string, resolve: (arg0: ArrayBuffer) => any, reject: Function, progress: Function): void;
+    /**
+     *
+     * @param {string} key
+     * @param {function} [progress]
+     * @returns {Promise<ArrayBuffer>}
+     */
+    promiseLoadBinary(key: string, progress?: Function): Promise<ArrayBuffer>;
+    /**
+     *
+     * @param {string} key
+     * @param {ArrayBuffer} value
+     * @param {function} [progress]
+     * @returns {Promise}
+     */
+    promiseStoreBinary(key: string, value: ArrayBuffer, progress?: Function): Promise<any>;
+    store(key: any, value: any, resolve: any, reject: any, progress: any): void;
+    load(key: any, resolve: any, reject: any, progress: any): void;
+    /**
+     *
+     * @param {function(list:string[])} resolve
+     * @param {function} reject
+     */
+    list(resolve: any, reject: Function): void;
+    /**
+     *
+     * @returns {Promise<string[]>}
+     */
+    promiseList(): Promise<string[]>;
+    /**
+     *
+     * @param {String} key
+     * @param {function} resolve
+     * @param {function} reject
+     */
+    remove(key: string, resolve: Function, reject: Function): void;
+    /**
+     *
+     * @param {string} key
+     * @returns {Promise<unknown>}
+     */
+    promiseRemove(key: string): Promise<unknown>;
+    /**
+     *
+     * @param {string} key
+     * @param {function(boolean)} resolve
+     * @param {function(reason:*)} reject
+     */
+    contains(key: string, resolve: (arg0: boolean) => any, reject: any): void;
+    /**
+     *
+     * @param {string} key
+     * @returns {Promise<unknown>}
+     */
+    promiseContains(key: string): Promise<unknown>;
+}
+//# sourceMappingURL=Storage.d.ts.map

package/src/engine/save/storage/InMemoryStorage.d.ts

@@ -1,6 +1,5 @@
 export class InMemoryStorage extends Storage {
     store(key: any, value: any, resolve: typeof noop, reject: any, progress: any): void;
-    load(key: any, resolve: any, reject: any, progress: any): void;
     remove(key: any, resolve: typeof noop, reject: any): void;
     contains(key: any, resolve: any, reject: any): void;
     list(resolve: any, reject: any): void;

package/src/engine/save/storage/InMemoryStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InMemoryStorage.d.ts","sourceRoot":"","sources":["../../../../../src/engine/save/storage/InMemoryStorage.js"],"names":[],"mappings":"AAIA;IAGI,oFAIC;IAED,+DAEC;IAED,0DAIC;IAED,oDAEC;IAED,sCAMC;;CACJ;oBAhCmB,eAAe;qBADd,gCAAgC"}
+{"version":3,"file":"InMemoryStorage.d.ts","sourceRoot":"","sources":["../../../../../src/engine/save/storage/InMemoryStorage.js"],"names":[],"mappings":"AAIA;IAGI,oFAIC;IAMD,0DAIC;IAED,oDAEC;IAED,sCAMC;;CACJ;oBAhCmB,eAAe;qBADd,gCAAgC"}

package/src/engine/save/storage/IndexedDBStorage.d.ts

@@ -9,8 +9,6 @@ export class IndexedDBStorage extends Storage {
      */
     db: Promise<IDBDatabase>;
     remove(key: any, resolve: any, reject: any): void;
-    load(key: any, resolve: any, reject: any, progress: any): void;
-    store(key: any, value: any, resolve: any, reject: any, progress: any): void;
     list(resolve: any, reject: any): void;
 }
 import Storage from "../Storage.js";

package/src/engine/save/storage/IndexedDBStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IndexedDBStorage.d.ts","sourceRoot":"","sources":["../../../../../src/engine/save/storage/IndexedDBStorage.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACI,uBAgCC;IAnBG;;;OAGG;IACH,IAFU,QAAQ,WAAW,CAAC,CAe5B;IAIN,kDA+BC;IAED,+DAkBC;IAED,4EA8BC;IAED,sCAkBC;CACJ;oBApJmB,eAAe"}
+{"version":3,"file":"IndexedDBStorage.d.ts","sourceRoot":"","sources":["../../../../../src/engine/save/storage/IndexedDBStorage.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACI,uBAgCC;IAnBG;;;OAGG;IACH,IAFU,QAAQ,WAAW,CAAC,CAe5B;IAIN,kDA+BC;IAsDD,sCAkBC;CACJ;oBApJmB,eAAe"}

package/src/engine/scene/Scene.d.ts

@@ -1,7 +1,65 @@
-import {EntityComponentDataset} from "../ecs/EntityComponentDataset";
-
-export default class Scene {
-    constructor(name?: string)
-
-    public dataset: EntityComponentDataset
-}
+export default Scene;
+declare class Scene {
+    /**
+     *
+     * @param {string} [name]
+     * @constructor
+     */
+    constructor(name?: string);
+    /**
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     *
+     * @type {EntityComponentDataset}
+     */
+    dataset: EntityComponentDataset;
+    /**
+     * @readonly
+     * @type {ObservedBoolean}
+     */
+    readonly active: ObservedBoolean;
+    /**
+     * Flag used to signal that the scene was been destroyed and should no longer be used
+     * @type {boolean}
+     */
+    destroyed: boolean;
+    /**
+     * Clock modifiers
+     * @type {List<LinearModifier>}
+     */
+    speedModifiers: List<LinearModifier>;
+    /**
+     * Executed just before the scene is is activated
+     */
+    handlePreActivation(): void;
+    /**
+     * Executed just after scene is activate
+     */
+    handlePostActivation(): void;
+    /**
+     * Executed just before scene is deactivated
+     */
+    handlePreDeactivation(): void;
+    /**
+     * Executed just after scene is deactivated
+     */
+    handlePostDeactivation(): void;
+    /**
+     *
+     * @param options
+     * @param {Engine} engine
+     * @param {function} success
+     * @param {function} failure
+     * @returns {Task|TaskGroup}
+     */
+    setup(options: any, engine: Engine, success: Function, failure: Function): Task | TaskGroup;
+    teardown(engine: any, success: any, failure: any): void;
+    clear(): void;
+}
+import { EntityComponentDataset } from "../ecs/EntityComponentDataset.js";
+import ObservedBoolean from "../../core/model/ObservedBoolean.js";
+import List from "../../core/collection/list/List.js";
+//# sourceMappingURL=Scene.d.ts.map

package/src/engine/scene/SceneManager.d.ts

@@ -1,25 +1,125 @@
-import Scene from "./Scene";
-import {EntityManager} from "../ecs/EntityManager";
-
-export default class SceneManager {
-    readonly current_scene:Scene|null
-    readonly entity_manager: EntityManager
-
-    create(name: string): Scene
-
-    add(scene: Scene): void
-
-    set(name: string): void
-
-    stackPush(id: string): void
-
-    stackPop(): string
-
-    remove(name: string): boolean
-
-    clear(): void
-
-    exists(name: string): boolean
-
-    getByName(name: string): Scene | undefined
-}
+export default SceneManager;
+declare class SceneManager {
+    /**
+     *
+     * @param {EntityManager} entityManager
+     * @param {Clock} clock
+     * @constructor
+     */
+    constructor(entityManager: EntityManager, clock: Clock);
+    /**
+     *
+     * @return {Scene|null}
+     */
+    get current_scene(): Scene;
+    /**
+     *
+     * @return {EntityManager|null}
+     */
+    get entity_manager(): EntityManager;
+    /**
+     * @type {List<Scene>}
+     */
+    scenes: List<Scene>;
+    /**
+     *
+     * @type {Clock}
+     */
+    clock: Clock;
+    /**
+     * Used to track scene transitions
+     * @readonly
+     * @private
+     * @type {string[]}
+     */
+    private readonly stack;
+    /**
+     *
+     * @param {string} name
+     * @returns {Scene}
+     */
+    create(name: string): Scene;
+    /**
+     *
+     * @param {Scene} scene
+     */
+    add(scene: Scene): void;
+    /**
+     *
+     * @param {string} name
+     * @returns {number}
+     */
+    indexByName(name: string): number;
+    /**
+     * @template T
+     * @param {string} name
+     * @returns {Scene|T|undefined}
+     */
+    getByName<T>(name: string): Scene | T;
+    /**
+     *
+     * @param {string} name
+     * @returns {boolean}
+     */
+    remove(name: string): boolean;
+    /**
+     *
+     * @returns {SceneManager}
+     */
+    clear(): SceneManager;
+    /**
+     *
+     * @param {string} name
+     * @returns {boolean}
+     */
+    exists(name: string): boolean;
+    /**
+     * @private
+     * @param {Scene} scene
+     */
+    private deactivateScene;
+    /**
+     * @private
+     * @param {Scene} scene
+     */
+    private activateScene;
+    /**
+     * @private
+     */
+    private deactivateCurrentScene;
+    /**
+     * @private
+     * @param {LinearModifier} mod
+     */
+    private __handleSpeedModifierAdded;
+    /**
+     * @private
+     * @param {LinearModifier} mod
+     */
+    private __handleSpeedModifierRemoved;
+    /**
+     *
+     * @param {string} name
+     */
+    set(name: string): void;
+    /**
+     *
+     * @param {string} id
+     */
+    stackPush(id: string): void;
+    /**
+     *
+     * @returns {string} ID of the popped scene
+     */
+    stackPop(): string;
+    /**
+     * Clear out current stack of scenes
+     */
+    stackDrop(): void;
+    update(timeDelta: any): void;
+    #private;
+}
+import Scene from "./Scene.js";
+import { EntityManager } from "../ecs/EntityManager.js";
+import List from "../../core/collection/list/List.js";
+//# sourceMappingURL=SceneManager.d.ts.map