@woosh/meep-engine 2.165.6 → 2.165.7

package/src/engine/achievements/AchievementGateway.d.ts

@@ -1,5 +1,17 @@
-export class AchievementGateway {
-    getUnlocked(): Promise<string[]>
-
-    unlock(id: string): Promise<any>
-}
+/**
+ * Base class for implementing achievement system API connectors
+ */
+export class AchievementGateway {
+    /**
+     * Retrieve list of unlocked achievements
+     * @returns {Promise<string[]>} IDs of unlocked achievements
+     */
+    getUnlocked(): Promise<string[]>;
+    /**
+     * Unlock an achievements by ID
+     * @param {String} id
+     * @returns {Promise}
+     */
+    unlock(id: string): Promise<any>;
+}
+//# sourceMappingURL=AchievementGateway.d.ts.map

package/src/engine/achievements/AchievementManager.d.ts

@@ -1,5 +1,4 @@
 export class AchievementManager extends EnginePlugin {
-    id: string;
     /**
      *
      * @type {AchievementGateway|null}

package/src/engine/achievements/AchievementManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AchievementManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/achievements/AchievementManager.js"],"names":[],"mappings":"AA0CA;IAGQ,WAAwB;IAExB;;;OAGG;IACH,SAFU,qBAAmB,IAAI,CAEd;IAEnB;;;OAGG;IACH,SAFU,WAAW,EAAE,CAEN;IAGjB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB;;;OAGG;IACH,YAFU,aAAW,IAAI,CAEH;IAEtB;;;OAGG;IACH,eAFU,gBAAc,IAAI,CAEH;IAEzB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB;;;OAGG;IACH,oBAFU,eAAe,CAEkB;IAG3C;;;OAGG;IACH,+BAFU,eAAe,CAE6B;IAEtD;;;OAGG;IACH,+BAFU,eAAe,CAE6B;IAEtD;;;OAGG;IACH,mBAFU,WAAW,CAKpB;IAUD,aAAkB;IAGtB;;;;OAIG;IACH,gCAFY,WAAW,GAAC,SAAS,CAIhC;IAGD;;;OAGG;IACH,yBA6BC;IAED;;;OAGG;IACH,sBAcC;IAED;;;OAGG;IACH,wBAUC;IAGD;;OAEG;IACH,iBAUC;IAED;;OAEG;IACH,mBAMC;IAED,uCAMC;IAED;;;OAGG;IACH,2DAaC;IAED;;;OAGG;IACH,qBAFW,WAAW,QA2FrB;IAED;;;OAGG;IACH,+CAOC;IAED,mCAoDC;IAED,yBASC;IAED,0BAEC;CACJ;6BA1Z4B,2BAA2B;4BAG5B,kBAAkB;4BAxBlB,qCAAqC;4BACrC,sDAAsD"}
+{"version":3,"file":"AchievementManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/achievements/AchievementManager.js"],"names":[],"mappings":"AA0CA;IAKQ;;;OAGG;IACH,SAFU,qBAAmB,IAAI,CAEd;IAEnB;;;OAGG;IACH,SAFU,WAAW,EAAE,CAEN;IAGjB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB;;;OAGG;IACH,YAFU,aAAW,IAAI,CAEH;IAEtB;;;OAGG;IACH,eAFU,gBAAc,IAAI,CAEH;IAEzB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB;;;OAGG;IACH,oBAFU,eAAe,CAEkB;IAG3C;;;OAGG;IACH,+BAFU,eAAe,CAE6B;IAEtD;;;OAGG;IACH,+BAFU,eAAe,CAE6B;IAEtD;;;OAGG;IACH,mBAFU,WAAW,CAKpB;IAUD,aAAkB;IAGtB;;;;OAIG;IACH,gCAFY,WAAW,GAAC,SAAS,CAIhC;IAGD;;;OAGG;IACH,yBA6BC;IAED;;;OAGG;IACH,sBAcC;IAED;;;OAGG;IACH,wBAUC;IAGD;;OAEG;IACH,iBAUC;IAED;;OAEG;IACH,mBAMC;IAED,uCAMC;IAED;;;OAGG;IACH,2DAaC;IAED;;;OAGG;IACH,qBAFW,WAAW,QA2FrB;IAED;;;OAGG;IACH,+CAOC;IAED,mCAoDC;IAED,yBASC;IAED,0BAEC;CACJ;6BA1Z4B,2BAA2B;4BAG5B,kBAAkB;4BAxBlB,qCAAqC;4BACrC,sDAAsD"}

package/src/engine/animation/Tween.d.ts

@@ -12,7 +12,7 @@ declare class Tween {
     constructor(callback: any, valueStart: number, valueEnd: number, duration: number, formula?: (x: number) => number, oscillate?: boolean);
     timeElapsed: number;
     on: {
-        ended: Signal<any, any, any, any, any, any, any, any>;
+        ended: Signal;
     };
     oscillate: boolean;
     formula: (x: number) => number;

package/src/engine/animation/clip/AnimationClip.d.ts

@@ -1,4 +1,24 @@
-export class AnimationClip {
-    name: string
-    readonly duration: number
-}
+export class AnimationClip {
+    /**
+     * Human-readable label
+     * @type {string}
+     */
+    name: string;
+    /**
+     *
+     * @type {AnimationTrack[]}
+     */
+    tracks: AnimationTrack[];
+    /**
+     *
+     * @returns {number}
+     */
+    get start_time(): number;
+    get end_time(): number;
+    /**
+     *
+     * @return {number}
+     */
+    get duration(): number;
+}
+//# sourceMappingURL=AnimationClip.d.ts.map

package/src/engine/animation/clip/AnimationClipBinding.d.ts

@@ -1,14 +1,35 @@
-import {AnimationClip} from "./AnimationClip";
-
-export class AnimationClipBinding {
-    /**
-     * @deprecated
-     */
-    readonly name: string
-    /**
-     * @deprecated
-     */
-    readonly duration: number
-
-    clip: AnimationClip
-}
+export class AnimationClipBinding {
+    static from(clip: any, root: any, binding_registry: any): AnimationClipBinding;
+    /**
+     * @type {AnimationClip}
+     */
+    clip: AnimationClip;
+    /**
+     * Populated by {@link bind} method
+     * @type {AnimationTrackBinding[]}
+     */
+    tracks: AnimationTrackBinding[];
+    /**
+     * @deprecated use `clip.name` directly instead
+     * @return {string}
+     */
+    get name(): string;
+    /**
+     * @deprecated use `clip.duration` directly instead
+     * @return {number}
+     */
+    get duration(): number;
+    /**
+     * @template T
+     * @param {T} root
+     * @param {Object<Type<BoundValueWriter>>} binding_registry
+     */
+    bind<T>(root: T, binding_registry: any): void;
+    /**
+     *
+     * @param {number} time time in seconds
+     */
+    writeAt(time: number): void;
+}
+import { AnimationTrackBinding } from "./AnimationTrackBinding.js";
+//# sourceMappingURL=AnimationClipBinding.d.ts.map

package/src/engine/animation/curve/actionProcessorOperations/curveActions.d.ts

@@ -28,7 +28,7 @@ export class RemoveKeyframeAction extends Action<any> {
      * @param {keyframesContext} context
      */
     constructor(passKeyframes: List<any>, passNullKeyframe: Keyframe, context: keyframesContext);
-    copyKfToDelete: any;
+    copyKfToDelete: List<any>;
     refNullKeyframe: Keyframe;
     actionContext: keyframesContext;
     linkedActiveKeyframe: any;
@@ -102,6 +102,6 @@ export class SelectionAction extends Action<any> {
 }
 import { AnimationCurve } from "../AnimationCurve.js";
 import { Action } from "../../../../core/process/undo/Action.js";
-import { Keyframe } from "../Keyframe.js";
 import List from "../../../../core/collection/list/List.js";
+import { Keyframe } from "../Keyframe.js";
 //# sourceMappingURL=curveActions.d.ts.map

package/src/engine/animation/curve/actionProcessorOperations/curveActions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curveActions.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/actionProcessorOperations/curveActions.js"],"names":[],"mappings":"AAKA;IACI;;;;;;;;;;OAUG;IACH,sIATW,cAAc,EAkBxB;IARG,cAAqB;IACrB,sBAAsC;IACtC,mBAAgC;IAChC,sBAAqC;IACrC,uBAAuC;IACvC,2BAA8C;IAC9C,yBAA4C;IAC5C,mBAAgC;CAEvC;AAED;IACI;;;;;OAKG;IACH,wDAHW,QAAQ,WACR,gBAAgB,EAc1B;IAVG,oBAA2C;IAC3C,0BAAuC;IAEvC,gCAA4B;IAE5B,0BAAsE;IACtE,oCAA0C;IAM9C,mCASC;IAED,oCAMC;CACJ;AAED;IACI;;;;OAIG;IACH,0BAHW,QAAQ,WACR,gBAAgB,EAO1B;IAHG,2BAA4C;IAE5C,gCAA4B;IAGhC,mCAIC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,iCANW,cAAc,qBACd,cAAc,qBACd,cAAc,mBACd,cAAc,WACd,gBAAgB,EAW1B;IAPG,8BAAsC;IACtC,gCAAkD;IAElD,4BAAkC;IAClC,8BAA8C;IAE9C,gCAA4B;IAGhC,mCAQC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,0BANW,QAAQ,0BACR,QAAQ,wBACR,QAAQ,0CAER,gBAAgB,EAU1B;IANG,sBAA+B;IAC/B,6BAAwD;IACxD,2BAAoD;IAEpD,gCAA4B;IAC5B,gCAAgD;IAGpD,mCAKC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;OAMG;IACH,uHAFW,gBAAgB,EAU1B;IANG,gCAAiD;IACjD,wBAA8B;IAE9B,4BAAkC;IAElC,gCAA4B;IAGhC,mCAMC;IAED,oCAMC;CACJ;+BAzM4B,sBAAsB;uBAD9B,yCAAyC;yBAEvC,gBAAgB;iBACtB,0CAA0C"}
+{"version":3,"file":"curveActions.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/actionProcessorOperations/curveActions.js"],"names":[],"mappings":"AAKA;IACI;;;;;;;;;;OAUG;IACH,sIATW,cAAc,EAkBxB;IARG,cAAqB;IACrB,sBAAsC;IACtC,mBAAgC;IAChC,sBAAqC;IACrC,uBAAuC;IACvC,2BAA8C;IAC9C,yBAA4C;IAC5C,mBAAgC;CAEvC;AAED;IACI;;;;;OAKG;IACH,wDAHW,QAAQ,WACR,gBAAgB,EAc1B;IAVG,0BAA2C;IAC3C,0BAAuC;IAEvC,gCAA4B;IAE5B,0BAAsE;IACtE,oCAA0C;IAM9C,mCASC;IAED,oCAMC;CACJ;AAED;IACI;;;;OAIG;IACH,0BAHW,QAAQ,WACR,gBAAgB,EAO1B;IAHG,2BAA4C;IAE5C,gCAA4B;IAGhC,mCAIC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,iCANW,cAAc,qBACd,cAAc,qBACd,cAAc,mBACd,cAAc,WACd,gBAAgB,EAW1B;IAPG,8BAAsC;IACtC,gCAAkD;IAElD,4BAAkC;IAClC,8BAA8C;IAE9C,gCAA4B;IAGhC,mCAQC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,0BANW,QAAQ,0BACR,QAAQ,wBACR,QAAQ,0CAER,gBAAgB,EAU1B;IANG,sBAA+B;IAC/B,6BAAwD;IACxD,2BAAoD;IAEpD,gCAA4B;IAC5B,gCAAgD;IAGpD,mCAKC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;OAMG;IACH,uHAFW,gBAAgB,EAU1B;IANG,gCAAiD;IACjD,wBAA8B;IAE9B,4BAAkC;IAElC,gCAA4B;IAGhC,mCAMC;IAED,oCAMC;CACJ;+BAzM4B,sBAAsB;uBAD9B,yCAAyC;iBAG7C,0CAA0C;yBADpC,gBAAgB"}

package/src/engine/animation/curve/editor/createKeyframeMarker.d.ts

@@ -1,2 +1,2 @@
-export function createKeyframeMarker(): void;
+export function createKeyframeMarker(): import("../../../../view/View.js").default;
 //# sourceMappingURL=createKeyframeMarker.d.ts.map

package/src/engine/animation/curve/editor/createKeyframeMarker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createKeyframeMarker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/createKeyframeMarker.js"],"names":[],"mappings":"AAEA,6CAQC"}
+{"version":3,"file":"createKeyframeMarker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/createKeyframeMarker.js"],"names":[],"mappings":"AAEA,mFAQC"}

package/src/engine/animation/keyed2/AnimationTrackPlayback.d.ts

@@ -21,7 +21,7 @@ declare class AnimationTrackPlayback {
     __loop: boolean;
     __valueBuffer: Float64Array;
     on: {
-        ended: Signal<any, any, any, any, any, any, any, any>;
+        ended: Signal;
     };
     /**
      *

package/src/engine/animation/keyed2/behavior/AnimationBehavior.d.ts

@@ -9,7 +9,6 @@ export class AnimationBehavior extends Behavior<any> {
      * @type {AnimationTrackPlayback}
      */
     animation: AnimationTrackPlayback;
-    initialize(_ignore_: any): void;
 }
 import { Behavior } from "../../../intelligence/behavior/Behavior.js";
 //# sourceMappingURL=AnimationBehavior.d.ts.map

package/src/engine/animation/keyed2/behavior/AnimationBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/keyed2/behavior/AnimationBehavior.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,+CAOC;IALG;;;OAGG;IACH,kCAA0B;IAqB9B,gCAEC;CACJ;yBAtCwB,4CAA4C"}
+{"version":3,"file":"AnimationBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/keyed2/behavior/AnimationBehavior.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,+CAOC;IALG;;;OAGG;IACH,kCAA0B;CAwBjC;yBAtCwB,4CAA4C"}

package/src/engine/asset/Asset.d.ts

@@ -1,7 +1,47 @@
-export class Asset<T> {
-    constructor()
-
-    public readonly byteSize: number
-
-    public create(): T
-}
+/**
+ * @template T
+ *
+ */
+export class Asset<T> {
+    /**
+     * @template T
+     * @param {function():T} [factory]
+     * @param {number} [byteSize] byte size of the asset in RAM
+     * @constructor
+     */
+    constructor(factory?: () => T_1, byteSize?: number);
+    /**
+     *
+     * @type {function(): T}
+     */
+    factory: () => T_1;
+    /**
+     *
+     * @type {number}
+     */
+    byteSize: number;
+    /**
+     * Descriptions of assets this asset depends on.
+     * Populated by the {@link AssetManager} from nested requests made by the loader during the load.
+     * @type {Array<AssetDescription>}
+     */
+    dependencies: Array<AssetDescription>;
+    /**
+     *
+     * @type {AssetDescription}
+     */
+    description: AssetDescription;
+    /**
+     *
+     * @param {Asset} other
+     * @returns {boolean}
+     */
+    equals(other: Asset<any>): boolean;
+    hash(): any;
+    /**
+     *
+     * @returns {T}
+     */
+    create(): T;
+}
+//# sourceMappingURL=Asset.d.ts.map

package/src/engine/asset/AssetManager.d.ts

@@ -1,61 +1,259 @@
-import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor";
-import {Asset} from "./Asset";
-import {AssetRequestScope} from "./AssetRequestScope";
-import {AssetTransformer} from "./AssetTransformer";
-import {CrossOriginConfig} from "./CORS/CrossOriginConfig";
-import {AssetLoader} from "./loaders/AssetLoader";
-
-interface PromiseOptions {
-    scope?: AssetRequestScope
-    skip_queue?: boolean
-    progress?: (current: number, total: number) => any
-}
-
-interface AssetManagerOptions<CTX> {
-    context: CTX,
-    executor?: ConcurrentExecutor
-}
-
-interface GetOptions<T> {
-    type: string
-    path: string
-    callback?: (asset: Asset<T>) => any
-    failure?: (reason: any) => any
-    progress?: (current: number, total: number) => any
-    skip_queue?: boolean
-    scope?: AssetRequestScope
-}
-
-export declare class AssetManager<CTX> {
-    constructor(options?: AssetManagerOptions<CTX>)
-
-    public readonly crossOriginConfig: CrossOriginConfig
-
-    load_concurrency: number
-
-    rootPath: string
-
-    startup(): void
-
-    shutdown(immediate?: boolean): Promise<void>
-
-    get<T>(options: GetOptions<T>): void
-
-    promise<T>(path: string, type: string, options?: PromiseOptions): Promise<Asset<T>>
-
-    resolveNetworkPath(path: string): string
-
-    remove(path: string, type: string): boolean
-
-    clear(): void
-
-    registerLoader<T>(type: string, loader: AssetLoader<T, CTX>): Promise<AssetLoader<T, CTX>>
-
-    unregisterLoader(type: string): Promise<void>
-
-    getLoaderByType<T>(type: string): AssetLoader<T, CTX> | undefined
-
-    registerTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): void
-
-    unregisterTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): boolean
+/**
+ * Handles loading/generating assets
+ * @template CTX
+ * @class
+ */
+export class AssetManager<CTX> {
+    /**
+     *
+     * @param {CTX} context
+     * @param {ConcurrentExecutor} executor
+     * @constructor
+     */
+    constructor({ context, executor }?: CTX);
+    /**
+     *
+     * @type {HashMap<AssetDescription, Asset>}
+     * @private
+     */
+    private assets;
+    /**
+     *
+     * @type {ObservedMap<AssetDescription, PendingAsset>}
+     */
+    request_map: ObservedMap<AssetDescription, PendingAsset>;
+    /**
+     * Maximum number of top-level requests that can be handled at the same time.
+     * Since most of the requests are handled over the network, this can help you control network concurrency,
+     * this can be useful to keep some network slots available for high-priority requests such as UI related ones.
+     * Nested requests (made by a loader while servicing another load) are dispatched immediately and never wait
+     * on this limit: their parent occupies a slot until they resolve, so queueing them would deadlock.
+     * @type {number}
+     */
+    load_concurrency: number;
+    /**
+     * This will be added to asset path for actual network resolution.
+     * Paths exchanged with the manager ({@link get}, {@link promise}, cache keys) are never prefixed;
+     * loaders apply the prefix at the fetch boundary via {@link resolveNetworkPath}.
+     * @type {string}
+     * @private
+     */
+    private rootPath;
+    /**
+     *
+     * @type {CrossOriginConfig}
+     */
+    crossOriginConfig: CrossOriginConfig;
+    startup(): void;
+    /**
+     *
+     * @param {boolean} [immediate] should we let pending work finish, or shut down immediately?
+     * Defaults to false (wait until all in-flight requests are resolved and all responses are delivered).
+     * When true, outstanding requests are failed and all responses are delivered before the method returns.
+     * @return {Promise<void>}
+     */
+    shutdown(immediate?: boolean): Promise<void>;
+    /**
+     * Resolves a caller-facing asset path to the path used for actual network retrieval.
+     * Loaders that fetch over the network should apply this at the fetch boundary; paths passed to
+     * {@link get}/{@link promise} (including nested requests made by loaders) always stay un-prefixed,
+     * so they are keyed consistently in the cache.
+     * @param {string} path
+     * @returns {string}
+     */
+    resolveNetworkPath(path: string): string;
+    /**
+     * Remove asset if it is loaded, does nothing otherwise
+     * @param {String} path
+     * @param {String} type
+     * @returns {boolean} true if asset was removed, else otherwise
+     */
+    remove(path: string, type: string): boolean;
+    /**
+     * Clear out all loaded assets
+     */
+    clear(): void;
+    dumpLoadedAssetList(): string;
+    /**
+     * @param {String} path
+     * @param {String} type
+     * @param {AssetRequestScope} [scope]
+     * @param {boolean} [skip_queue] if true will skip the queue and dispatch request immediately
+     * @param {function(loaded:number, total:number)} [progress]
+     * @returns {Promise<Asset>}
+     */
+    promise(path: string, type: string, { scope, skip_queue, progress }?: AssetRequestScope): Promise<Asset>;
+    /**
+     * @template T
+     * @param {String} path
+     * @param {String} type
+     * @param {function(asset:Asset<T>)} [callback] success callback
+     * @param {function(reason:*)} [failure]
+     * @param {function(loaded:number, total:number)} [progress]
+     * @param {boolean} [skip_queue]
+     * @param {AssetRequestScope} [scope]
+     */
+    get<T>({ path, type, callback, failure, progress, skip_queue, scope }: string): void;
+    /**
+     * Checks if an asset is currently being loaded.
+     * Useful for avoiding redundant requests.
+     *
+     * @param {string} path
+     * @param {string} type
+     * @return {boolean}
+     */
+    isPending(path: string, type: string): boolean;
+    /**
+     * Whether the most recent load attempt for the asset failed.
+     * Advisory only: a new {@link get} will still retry the load.
+     * @param {string} path
+     * @param {string} type
+     * @returns {boolean}
+     * @see isPending
+     */
+    isFailed(path: string, type: string): boolean;
+    /**
+     * Checks if an asset is loaded.
+     * If the asset is loaded, calls to {@link tryGet} are guaranteed to succeed.
+     *
+     * @param {string} path
+     * @param {string} type
+     * @return {boolean}
+     */
+    isLoaded(path: string, type: string): boolean;
+    /**
+     * Same as {@link insert}, but will register the asset as pending until loader function resolves.
+     *
+     * NOTE: {@link AssetTransformer}s are not applied to the asset
+     *
+     * NOTE: any subsequent normal requests such as {@link get} will be routed to the same loader
+     *
+     * @template T
+     * @param {string} path
+     * @param {string} type
+     * @param {function(progress?:function(current:number, total:number)):Promise<Asset<T>>} loader
+     * @returns {Promise<Asset<T>>} loaded asset
+     * @see insert
+     * @example
+     *   manager.insertAsync('path/to/asset', 'my-type', async (progress) => {
+     *       const asset = await loadAssetFromNetwork('path/to/asset', 'type', progress);
+     *       return asset;
+     *   });
+     *
+     */
+    insertAsync<T_1>(path: string, type: string, loader: any): Promise<Asset<T_1>>;
+    /**
+     * Manually add a fully resolved resource.
+     * If a load for the same description is in flight, it is squashed: the inserted asset wins,
+     * all accumulated requests are answered with it exactly once, and the loader's late resolution is dropped.
+     *
+     * NOTE: {@link AssetTransformer}s are not applied to the asset
+     *
+     * @template T
+     * @param {string} path
+     * @param {string} type
+     * @param {Asset<T>} asset
+     */
+    insert<T_2>(path: string, type: string, asset: Asset<T_2>): void;
+    /**
+     *
+     * @param {AssetDescription} assetDescription
+     * @param {AssetRequest} request
+     * @param {PendingAsset|null} [parent_pending] the in-flight load this request was made from, if any
+     * @private
+     */
+    private submitRequest;
+    /**
+     *
+     * @param {string} type
+     * @return {boolean}
+     */
+    hasLoaderForType(type: string): boolean;
+    /**
+     *
+     * @param {string} type
+     * @returns {AssetLoader|undefined}
+     */
+    getLoaderByType(type: string): AssetLoader<any, any> | undefined;
+    /**
+     * Transformer will be applied to all assets of the given type in order of registration.
+     *
+     * Does not apply retroactively, assets that were already loaded will not be transformed.
+     *
+     * @template T
+     * @param {string} type
+     * @param {AssetTransformer<T>} transformer
+     * @returns {void}
+     * @see removeTransformer
+     */
+    registerTransformer<T_3>(type: string, transformer: AssetTransformer<T_3>): void;
+    /**
+     * @template T
+     * @param {string} type
+     * @param {AssetTransformer<T>} transformer
+     * @returns {boolean} true if removed, false if not found
+     * @see registerTransformer
+     */
+    unregisterTransformer<T_4>(type: string, transformer: AssetTransformer<T_4>): boolean;
+    /**
+     * Will register loader only if none exists for this type
+     * @template T
+     * @param {string} type
+     * @param {AssetLoader<T>} loader
+     * @returns {Promise<boolean>} true if registered, false otherwise
+     */
+    tryRegisterLoader<T_5>(type: string, loader: AssetLoader<T_5, any>): Promise<boolean>;
+    /**
+     * @template T
+     * @param {string} type
+     * @param {AssetLoader<T>} loader
+     * @throws {Error} if a loader is already registered for the given type
+     */
+    registerLoader<T_6>(type: string, loader: AssetLoader<T_6, any>): Promise<AssetLoader<any, any>>;
+    /**
+     *
+     * @param {string} type
+     */
+    unregisterLoader(type: string): Promise<void>;
+    /**
+     * Retrieve an asset if it is loaded, returns null if the asset is not loaded.
+     * Does not trigger loading if the asset is not loaded.
+     * @template T
+     * @param {String} path
+     * @param {String} type
+     * @returns {Asset<T>|null}
+     */
+    tryGet<T_7>(path: string, type: string): Asset<T_7> | null;
+    /**
+     * @template T
+     * @param {string} alias
+     * @return {Promise<Asset<T>>}
+     */
+    promiseByAlias<T_8>(alias: string): Promise<Asset<T_8>>;
+    /**
+     *
+     * @param {string} alias
+     * @return {AssetDescription|undefined}
+     */
+    resolveAlias(alias: string): AssetDescription | undefined;
+    /**
+     *
+     * @param {string} alias
+     * @param {string} path
+     * @param {string} type
+     */
+    assignAlias(alias: string, path: string, type: string): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isAssetManager: boolean;
+    #private;
 }
+import { ObservedMap } from "../../core/collection/map/ObservedMap.js";
+import { AssetDescription } from "./AssetDescription.js";
+import { PendingAsset } from "./PendingAsset.js";
+import { CrossOriginConfig } from "./CORS/CrossOriginConfig.js";
+import { AssetRequestScope } from "./AssetRequestScope.js";
+import { AssetLoader } from "./loaders/AssetLoader.js";
+//# sourceMappingURL=AssetManager.d.ts.map

package/src/engine/asset/AssetRequestScope.d.ts

@@ -1,3 +1,27 @@
-export declare class AssetRequestScope{
-
-}
+export class AssetRequestScope {
+    /**
+     *
+     * @param {AssetRequestScope[]} sources
+     * @return {AssetRequestScope}
+     */
+    static from(sources: AssetRequestScope[]): AssetRequestScope;
+    id: number;
+    priority: number;
+    /**
+     *
+     * @type {AssetRequestScope[]}
+     */
+    sources: AssetRequestScope[];
+    /**
+     * Asset being loaded under this scope. Set by the {@link AssetManager} on scopes it creates when
+     * dispatching a load; lets requests made by the loader be traced back to the load they belong to.
+     * @type {AssetDescription|null}
+     */
+    description: AssetDescription | null;
+    get final_priority(): any;
+    toString(): string;
+}
+export namespace AssetRequestScope {
+    let GLOBAL: Readonly<AssetRequestScope>;
+}
+//# sourceMappingURL=AssetRequestScope.d.ts.map

package/src/engine/asset/AssetTransformer.d.ts

@@ -1,5 +1,16 @@
-import {Asset} from "./Asset";
-
-export class AssetTransformer<A extends Asset<T>, T = any> {
-    transform(source: A): Promise<A>
-}
+/**
+ * Applies a transformation to an asset. Such as performing mesh simplification, for example.
+ * Transformation is executed by the {@link AssetManager}
+ * Useful for modifying/extending post-processing done on various asset types
+ * @template {Asset<T>} A
+ * @template T
+ */
+export class AssetTransformer<A extends Asset<T>, T> {
+    /**
+     * @param {A} source
+     * @param {AssetDescription} asset_description
+     * @returns {A}
+     */
+    transform(source: A, asset_description: AssetDescription): A;
+}
+//# sourceMappingURL=AssetTransformer.d.ts.map

package/src/engine/asset/CORS/CrossOriginConfig.d.ts

@@ -1,5 +1,8 @@
-import {CrossOriginKind} from "./CrossOriginKind";
-
-export class CrossOriginConfig{
-    public kind: CrossOriginKind
-}
+export class CrossOriginConfig {
+    kind: string;
+}
+export namespace CrossOriginConfig {
+    let _default: Readonly<CrossOriginConfig>;
+    export { _default as default };
+}
+//# sourceMappingURL=CrossOriginConfig.d.ts.map

package/src/engine/asset/CORS/CrossOriginConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CrossOriginConfig.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/CORS/CrossOriginConfig.js"],"names":[],"mappings":"AAEA;IACI,sBAAiC;CACpC;;kBAMS,SAAS,iBAAiB,CAAC;;;gCAVL,sBAAsB"}
+{"version":3,"file":"CrossOriginConfig.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/CORS/CrossOriginConfig.js"],"names":[],"mappings":"AAEA;IACI,aAAiC;CACpC;;kBAMS,SAAS,iBAAiB,CAAC"}

package/src/engine/asset/CORS/CrossOriginKind.d.ts

@@ -1,4 +1,5 @@
-export enum CrossOriginKind {
-    UseCredentials = 'use-credentials',
-    Anonymous = 'anonymous'
-}
+export namespace CrossOriginKind {
+    let UseCredentials: string;
+    let Anonymous: string;
+}
+//# sourceMappingURL=CrossOriginKind.d.ts.map