@babylonjs/viewer 7.31.2 → 7.32.0-alpha

package/dist/chunks/workerPool-BUOov2K1.esm.js

@@ -0,0 +1,122 @@
+/**
+ * Helper class to push actions to a pool of workers.
+ */
+class WorkerPool {
+    /**
+     * Constructor
+     * @param workers Array of workers to use for actions
+     */
+    constructor(workers) {
+        this._pendingActions = new Array();
+        this._workerInfos = workers.map((worker) => ({
+            workerPromise: Promise.resolve(worker),
+            idle: true,
+        }));
+    }
+    /**
+     * Terminates all workers and clears any pending actions.
+     */
+    dispose() {
+        for (const workerInfo of this._workerInfos) {
+            workerInfo.workerPromise.then((worker) => {
+                worker.terminate();
+            });
+        }
+        this._workerInfos.length = 0;
+        this._pendingActions.length = 0;
+    }
+    /**
+     * Pushes an action to the worker pool. If all the workers are active, the action will be
+     * pended until a worker has completed its action.
+     * @param action The action to perform. Call onComplete when the action is complete.
+     */
+    push(action) {
+        if (!this._executeOnIdleWorker(action)) {
+            this._pendingActions.push(action);
+        }
+    }
+    _executeOnIdleWorker(action) {
+        for (const workerInfo of this._workerInfos) {
+            if (workerInfo.idle) {
+                this._execute(workerInfo, action);
+                return true;
+            }
+        }
+        return false;
+    }
+    _execute(workerInfo, action) {
+        workerInfo.idle = false;
+        workerInfo.workerPromise.then((worker) => {
+            action(worker, () => {
+                const nextAction = this._pendingActions.shift();
+                if (nextAction) {
+                    this._execute(workerInfo, nextAction);
+                }
+                else {
+                    workerInfo.idle = true;
+                }
+            });
+        });
+    }
+}
+/**
+ * Similar to the WorkerPool class except it creates and destroys workers automatically with a maximum of `maxWorkers` workers.
+ * Workers are terminated when it is idle for at least `idleTimeElapsedBeforeRelease` milliseconds.
+ */
+class AutoReleaseWorkerPool extends WorkerPool {
+    constructor(maxWorkers, createWorkerAsync, options = AutoReleaseWorkerPool.DefaultOptions) {
+        super([]);
+        this._maxWorkers = maxWorkers;
+        this._createWorkerAsync = createWorkerAsync;
+        this._options = options;
+    }
+    push(action) {
+        if (!this._executeOnIdleWorker(action)) {
+            if (this._workerInfos.length < this._maxWorkers) {
+                const workerInfo = {
+                    workerPromise: this._createWorkerAsync(),
+                    idle: false,
+                };
+                this._workerInfos.push(workerInfo);
+                this._execute(workerInfo, action);
+            }
+            else {
+                this._pendingActions.push(action);
+            }
+        }
+    }
+    _execute(workerInfo, action) {
+        // Reset the idle timeout.
+        if (workerInfo.timeoutId) {
+            clearTimeout(workerInfo.timeoutId);
+            delete workerInfo.timeoutId;
+        }
+        super._execute(workerInfo, (worker, onComplete) => {
+            action(worker, () => {
+                onComplete();
+                if (workerInfo.idle) {
+                    // Schedule the worker to be terminated after the elapsed time.
+                    workerInfo.timeoutId = setTimeout(() => {
+                        workerInfo.workerPromise.then((worker) => {
+                            worker.terminate();
+                        });
+                        const indexOf = this._workerInfos.indexOf(workerInfo);
+                        if (indexOf !== -1) {
+                            this._workerInfos.splice(indexOf, 1);
+                        }
+                    }, this._options.idleTimeElapsedBeforeRelease);
+                }
+            });
+        });
+    }
+}
+/**
+ * Default options for the constructor.
+ * Override to change the defaults.
+ */
+AutoReleaseWorkerPool.DefaultOptions = {
+    idleTimeElapsedBeforeRelease: 1000,
+};
+
+export { AutoReleaseWorkerPool as A };
+//# sourceMappingURL=workerPool-BUOov2K1.esm.js.map

package/dist/chunks/workerPool-BUOov2K1.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerPool-BUOov2K1.esm.js","sources":["../../../../../dev/core/dist/Misc/workerPool.js"],"sourcesContent":["/**\n * Helper class to push actions to a pool of workers.\n */\nexport class WorkerPool {\n    /**\n     * Constructor\n     * @param workers Array of workers to use for actions\n     */\n    constructor(workers) {\n        this._pendingActions = new Array();\n        this._workerInfos = workers.map((worker) => ({\n            workerPromise: Promise.resolve(worker),\n            idle: true,\n        }));\n    }\n    /**\n     * Terminates all workers and clears any pending actions.\n     */\n    dispose() {\n        for (const workerInfo of this._workerInfos) {\n            workerInfo.workerPromise.then((worker) => {\n                worker.terminate();\n            });\n        }\n        this._workerInfos.length = 0;\n        this._pendingActions.length = 0;\n    }\n    /**\n     * Pushes an action to the worker pool. If all the workers are active, the action will be\n     * pended until a worker has completed its action.\n     * @param action The action to perform. Call onComplete when the action is complete.\n     */\n    push(action) {\n        if (!this._executeOnIdleWorker(action)) {\n            this._pendingActions.push(action);\n        }\n    }\n    _executeOnIdleWorker(action) {\n        for (const workerInfo of this._workerInfos) {\n            if (workerInfo.idle) {\n                this._execute(workerInfo, action);\n                return true;\n            }\n        }\n        return false;\n    }\n    _execute(workerInfo, action) {\n        workerInfo.idle = false;\n        workerInfo.workerPromise.then((worker) => {\n            action(worker, () => {\n                const nextAction = this._pendingActions.shift();\n                if (nextAction) {\n                    this._execute(workerInfo, nextAction);\n                }\n                else {\n                    workerInfo.idle = true;\n                }\n            });\n        });\n    }\n}\n/**\n * Similar to the WorkerPool class except it creates and destroys workers automatically with a maximum of `maxWorkers` workers.\n * Workers are terminated when it is idle for at least `idleTimeElapsedBeforeRelease` milliseconds.\n */\nexport class AutoReleaseWorkerPool extends WorkerPool {\n    constructor(maxWorkers, createWorkerAsync, options = AutoReleaseWorkerPool.DefaultOptions) {\n        super([]);\n        this._maxWorkers = maxWorkers;\n        this._createWorkerAsync = createWorkerAsync;\n        this._options = options;\n    }\n    push(action) {\n        if (!this._executeOnIdleWorker(action)) {\n            if (this._workerInfos.length < this._maxWorkers) {\n                const workerInfo = {\n                    workerPromise: this._createWorkerAsync(),\n                    idle: false,\n                };\n                this._workerInfos.push(workerInfo);\n                this._execute(workerInfo, action);\n            }\n            else {\n                this._pendingActions.push(action);\n            }\n        }\n    }\n    _execute(workerInfo, action) {\n        // Reset the idle timeout.\n        if (workerInfo.timeoutId) {\n            clearTimeout(workerInfo.timeoutId);\n            delete workerInfo.timeoutId;\n        }\n        super._execute(workerInfo, (worker, onComplete) => {\n            action(worker, () => {\n                onComplete();\n                if (workerInfo.idle) {\n                    // Schedule the worker to be terminated after the elapsed time.\n                    workerInfo.timeoutId = setTimeout(() => {\n                        workerInfo.workerPromise.then((worker) => {\n                            worker.terminate();\n                        });\n                        const indexOf = this._workerInfos.indexOf(workerInfo);\n                        if (indexOf !== -1) {\n                            this._workerInfos.splice(indexOf, 1);\n                        }\n                    }, this._options.idleTimeElapsedBeforeRelease);\n                }\n            });\n        });\n    }\n}\n/**\n * Default options for the constructor.\n * Override to change the defaults.\n */\nAutoReleaseWorkerPool.DefaultOptions = {\n    idleTimeElapsedBeforeRelease: 1000,\n};\n//# sourceMappingURL=workerPool.js.map"],"names":[],"mappings":"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"}

package/dist/chunks/workerPool-BWHiDmEZ.esm.min.js

@@ -0,0 +1,2 @@
+class e{constructor(e){this._pendingActions=new Array,this._workerInfos=e.map((e=>({workerPromise:Promise.resolve(e),idle:!0})))}dispose(){for(const e of this._workerInfos)e.workerPromise.then((e=>{e.terminate()}));this._workerInfos.length=0,this._pendingActions.length=0}push(e){this._executeOnIdleWorker(e)||this._pendingActions.push(e)}_executeOnIdleWorker(e){for(const s of this._workerInfos)if(s.idle)return this._execute(s,e),!0;return!1}_execute(e,s){e.idle=!1,e.workerPromise.then((t=>{s(t,(()=>{const s=this._pendingActions.shift();s?this._execute(e,s):e.idle=!0}))}))}}class s extends e{constructor(e,t,i=s.DefaultOptions){super([]),this._maxWorkers=e,this._createWorkerAsync=t,this._options=i}push(e){if(!this._executeOnIdleWorker(e))if(this._workerInfos.length<this._maxWorkers){const s={workerPromise:this._createWorkerAsync(),idle:!1};this._workerInfos.push(s),this._execute(s,e)}else this._pendingActions.push(e)}_execute(e,s){e.timeoutId&&(clearTimeout(e.timeoutId),delete e.timeoutId),super._execute(e,((t,i)=>{s(t,(()=>{i(),e.idle&&(e.timeoutId=setTimeout((()=>{e.workerPromise.then((e=>{e.terminate()}));const s=this._workerInfos.indexOf(e);-1!==s&&this._workerInfos.splice(s,1)}),this._options.idleTimeElapsedBeforeRelease))}))}))}}s.DefaultOptions={idleTimeElapsedBeforeRelease:1e3};export{s as A};
+//# sourceMappingURL=workerPool-BWHiDmEZ.esm.min.js.map

package/dist/chunks/workerPool-BWHiDmEZ.esm.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerPool-BWHiDmEZ.esm.min.js","sources":["../../../../../dev/core/dist/Misc/workerPool.js"],"sourcesContent":["/**\n * Helper class to push actions to a pool of workers.\n */\nexport class WorkerPool {\n    /**\n     * Constructor\n     * @param workers Array of workers to use for actions\n     */\n    constructor(workers) {\n        this._pendingActions = new Array();\n        this._workerInfos = workers.map((worker) => ({\n            workerPromise: Promise.resolve(worker),\n            idle: true,\n        }));\n    }\n    /**\n     * Terminates all workers and clears any pending actions.\n     */\n    dispose() {\n        for (const workerInfo of this._workerInfos) {\n            workerInfo.workerPromise.then((worker) => {\n                worker.terminate();\n            });\n        }\n        this._workerInfos.length = 0;\n        this._pendingActions.length = 0;\n    }\n    /**\n     * Pushes an action to the worker pool. If all the workers are active, the action will be\n     * pended until a worker has completed its action.\n     * @param action The action to perform. Call onComplete when the action is complete.\n     */\n    push(action) {\n        if (!this._executeOnIdleWorker(action)) {\n            this._pendingActions.push(action);\n        }\n    }\n    _executeOnIdleWorker(action) {\n        for (const workerInfo of this._workerInfos) {\n            if (workerInfo.idle) {\n                this._execute(workerInfo, action);\n                return true;\n            }\n        }\n        return false;\n    }\n    _execute(workerInfo, action) {\n        workerInfo.idle = false;\n        workerInfo.workerPromise.then((worker) => {\n            action(worker, () => {\n                const nextAction = this._pendingActions.shift();\n                if (nextAction) {\n                    this._execute(workerInfo, nextAction);\n                }\n                else {\n                    workerInfo.idle = true;\n                }\n            });\n        });\n    }\n}\n/**\n * Similar to the WorkerPool class except it creates and destroys workers automatically with a maximum of `maxWorkers` workers.\n * Workers are terminated when it is idle for at least `idleTimeElapsedBeforeRelease` milliseconds.\n */\nexport class AutoReleaseWorkerPool extends WorkerPool {\n    constructor(maxWorkers, createWorkerAsync, options = AutoReleaseWorkerPool.DefaultOptions) {\n        super([]);\n        this._maxWorkers = maxWorkers;\n        this._createWorkerAsync = createWorkerAsync;\n        this._options = options;\n    }\n    push(action) {\n        if (!this._executeOnIdleWorker(action)) {\n            if (this._workerInfos.length < this._maxWorkers) {\n                const workerInfo = {\n                    workerPromise: this._createWorkerAsync(),\n                    idle: false,\n                };\n                this._workerInfos.push(workerInfo);\n                this._execute(workerInfo, action);\n            }\n            else {\n                this._pendingActions.push(action);\n            }\n        }\n    }\n    _execute(workerInfo, action) {\n        // Reset the idle timeout.\n        if (workerInfo.timeoutId) {\n            clearTimeout(workerInfo.timeoutId);\n            delete workerInfo.timeoutId;\n        }\n        super._execute(workerInfo, (worker, onComplete) => {\n            action(worker, () => {\n                onComplete();\n                if (workerInfo.idle) {\n                    // Schedule the worker to be terminated after the elapsed time.\n                    workerInfo.timeoutId = setTimeout(() => {\n                        workerInfo.workerPromise.then((worker) => {\n                            worker.terminate();\n                        });\n                        const indexOf = this._workerInfos.indexOf(workerInfo);\n                        if (indexOf !== -1) {\n                            this._workerInfos.splice(indexOf, 1);\n                        }\n                    }, this._options.idleTimeElapsedBeforeRelease);\n                }\n            });\n        });\n    }\n}\n/**\n * Default options for the constructor.\n * Override to change the defaults.\n */\nAutoReleaseWorkerPool.DefaultOptions = {\n    idleTimeElapsedBeforeRelease: 1000,\n};\n//# sourceMappingURL=workerPool.js.map"],"names":["WorkerPool","constructor","workers","this","_pendingActions","Array","_workerInfos","map","worker","workerPromise","Promise","resolve","idle","dispose","workerInfo","then","terminate","length","push","action","_executeOnIdleWorker","_execute","nextAction","shift","AutoReleaseWorkerPool","maxWorkers","createWorkerAsync","options","DefaultOptions","super","_maxWorkers","_createWorkerAsync","_options","timeoutId","clearTimeout","onComplete","setTimeout","indexOf","splice","idleTimeElapsedBeforeRelease"],"mappings":"AAGO,MAAMA,EAKT,WAAAC,CAAYC,GACRC,KAAKC,gBAAkB,IAAIC,MAC3BF,KAAKG,aAAeJ,EAAQK,KAAKC,IAAY,CACzCC,cAAeC,QAAQC,QAAQH,GAC/BI,MAAM,KAElB,CAII,OAAAC,GACI,IAAK,MAAMC,KAAcX,KAAKG,aAC1BQ,EAAWL,cAAcM,MAAMP,IAC3BA,EAAOQ,WAAW,IAG1Bb,KAAKG,aAAaW,OAAS,EAC3Bd,KAAKC,gBAAgBa,OAAS,CACtC,CAMI,IAAAC,CAAKC,GACIhB,KAAKiB,qBAAqBD,IAC3BhB,KAAKC,gBAAgBc,KAAKC,EAEtC,CACI,oBAAAC,CAAqBD,GACjB,IAAK,MAAML,KAAcX,KAAKG,aAC1B,GAAIQ,EAAWF,KAEX,OADAT,KAAKkB,SAASP,EAAYK,IACnB,EAGf,OAAO,CACf,CACI,QAAAE,CAASP,EAAYK,GACjBL,EAAWF,MAAO,EAClBE,EAAWL,cAAcM,MAAMP,IAC3BW,EAAOX,GAAQ,KACX,MAAMc,EAAanB,KAAKC,gBAAgBmB,QACpCD,EACAnB,KAAKkB,SAASP,EAAYQ,GAG1BR,EAAWF,MAAO,CACtC,GACc,GAEd,EAMO,MAAMY,UAA8BxB,EACvC,WAAAC,CAAYwB,EAAYC,EAAmBC,EAAUH,EAAsBI,gBACvEC,MAAM,IACN1B,KAAK2B,YAAcL,EACnBtB,KAAK4B,mBAAqBL,EAC1BvB,KAAK6B,SAAWL,CACxB,CACI,IAAAT,CAAKC,GACD,IAAKhB,KAAKiB,qBAAqBD,GAC3B,GAAIhB,KAAKG,aAAaW,OAASd,KAAK2B,YAAa,CAC7C,MAAMhB,EAAa,CACfL,cAAeN,KAAK4B,qBACpBnB,MAAM,GAEVT,KAAKG,aAAaY,KAAKJ,GACvBX,KAAKkB,SAASP,EAAYK,EAC1C,MAEgBhB,KAAKC,gBAAgBc,KAAKC,EAG1C,CACI,QAAAE,CAASP,EAAYK,GAEbL,EAAWmB,YACXC,aAAapB,EAAWmB,kBACjBnB,EAAWmB,WAEtBJ,MAAMR,SAASP,GAAY,CAACN,EAAQ2B,KAChChB,EAAOX,GAAQ,KACX2B,IACIrB,EAAWF,OAEXE,EAAWmB,UAAYG,YAAW,KAC9BtB,EAAWL,cAAcM,MAAMP,IAC3BA,EAAOQ,WAAW,IAEtB,MAAMqB,EAAUlC,KAAKG,aAAa+B,QAAQvB,IACzB,IAAbuB,GACAlC,KAAKG,aAAagC,OAAOD,EAAS,EAC9D,GACuBlC,KAAK6B,SAASO,8BACrC,GACc,GAEd,EAMAf,EAAsBI,eAAiB,CACnCW,6BAA8B"}

package/lib/index.d.ts

@@ -0,0 +1,327 @@
+import { Nullable, AssetContainer, HotSpotQuery, IDisposable, AbstractEngine, LoadAssetContainerOptions, AbstractEngineOptions, EngineOptions, WebGPUEngineOptions } from '@babylonjs/core/index.js';
+import { Observable } from '@babylonjs/core/Misc/observable.js';
+import { Scene } from '@babylonjs/core/scene.js';
+import * as lit_html from 'lit-html';
+import * as lit from 'lit';
+import { LitElement, PropertyValues } from 'lit';
+import { Color4 } from '@babylonjs/core/Maths/math.color.js';
+
+type ViewerDetails = {
+    /**
+     * Gets the Viewer instance.
+     */
+    viewer: Viewer;
+    /**
+     * Provides access to the Scene managed by the Viewer.
+     */
+    scene: Scene;
+    /**
+     * Provides access to the currently loaded model.
+     */
+    model: Nullable<AssetContainer>;
+};
+type ViewerOptions = Partial<Readonly<{
+    /**
+     * Called once when the viewer is initialized and provides viewer details that can be used for advanced customization.
+     */
+    onInitialized: (details: Readonly<ViewerDetails>) => void;
+}>>;
+type ViewerHotSpotQuery = {
+    /**
+     * The index of the mesh within the loaded model.
+     */
+    meshIndex: number;
+} & HotSpotQuery;
+/**
+ * Information computed from the hot spot surface data, canvas and mesh datas
+ */
+type ViewerHotSpot = {
+    /**
+     * 2D canvas position in pixels
+     */
+    screenPosition: [number, number];
+    /**
+     * 3D world coordinates
+     */
+    worldPosition: [number, number, number];
+};
+/**
+ * Provides an experience for viewing a single 3D model.
+ * @remarks
+ * The Viewer is not tied to a specific UI framework and can be used with Babylon.js in a browser or with Babylon Native.
+ * Includes (or will include) support for common model viewing requirements such as:
+ * - Loading different model formats.
+ * - Setting up a camera and providing default behaviors like auto orbit and pose interpolation.
+ * - Framing the loaded model in the camera's view.
+ * - Setting up the environment, lighting, and tone mapping.
+ * - Enumerating and playing (or auto playing) animations.
+ * - Enumerating and switching between material variants.
+ * - Full screen and XR modes.
+ */
+declare class Viewer implements IDisposable {
+    private readonly _engine;
+    /**
+     * Fired when the environment has changed.
+     */
+    readonly onEnvironmentChanged: Observable<void>;
+    /**
+     * Fired when an error occurs while loading the environment.
+     */
+    readonly onEnvironmentError: Observable<unknown>;
+    /**
+     * Fired when a model is loaded into the viewer (or unloaded from the viewer).
+     */
+    readonly onModelChanged: Observable<void>;
+    /**
+     * Fired when an error occurs while loading a model.
+     */
+    readonly onModelError: Observable<unknown>;
+    /**
+     * Fired when the selected animation changes.
+     */
+    readonly onSelectedAnimationChanged: Observable<void>;
+    /**
+     * Fired when the animation speed changes.
+     */
+    readonly onAnimationSpeedChanged: Observable<void>;
+    /**
+     * Fired when the selected animation is playing or paused.
+     */
+    readonly onIsAnimationPlayingChanged: Observable<void>;
+    /**
+     * Fired when the current point on the selected animation timeline changes.
+     */
+    readonly onAnimationProgressChanged: Observable<void>;
+    private readonly _details;
+    private readonly _snapshotHelper;
+    private readonly _camera;
+    private readonly _autoRotationBehavior;
+    private readonly _renderLoopController;
+    private _skybox;
+    private _light;
+    private _isDisposed;
+    private readonly _loadModelLock;
+    private _loadModelAbortController;
+    private readonly _loadEnvironmentLock;
+    private _environment;
+    private _loadEnvironmentAbortController;
+    private _selectedAnimation;
+    private _activeAnimationObservers;
+    private _animationSpeed;
+    constructor(_engine: AbstractEngine, options?: ViewerOptions);
+    /**
+     * The list of animation names for the currently loaded model.
+     */
+    get animations(): readonly string[];
+    /**
+     * The currently selected animation index.
+     */
+    get selectedAnimation(): number;
+    set selectedAnimation(value: number);
+    /**
+     * True if an animation is currently playing.
+     */
+    get isAnimationPlaying(): boolean;
+    /**
+     * The speed scale at which animations are played.
+     */
+    get animationSpeed(): number;
+    set animationSpeed(value: number);
+    /**
+     * The current point on the selected animation timeline, normalized between 0 and 1.
+     */
+    get animationProgress(): number;
+    set animationProgress(value: number);
+    private get _activeAnimation();
+    /**
+     * Loads a 3D model from the specified URL.
+     * @remarks
+     * If a model is already loaded, it will be unloaded before loading the new model.
+     * @param source A url or File or ArrayBufferView that points to the model to load.
+     * @param options The options to use when loading the model.
+     * @param abortSignal An optional signal that can be used to abort the loading process.
+     */
+    loadModel(source: string | File | ArrayBufferView, options?: LoadAssetContainerOptions, abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Unloads the current 3D model if one is loaded.
+     * @param abortSignal An optional signal that can be used to abort the reset.
+     */
+    resetModel(abortSignal?: AbortSignal): Promise<void>;
+    private _updateModel;
+    /**
+     * Loads an environment texture from the specified url and sets up a corresponding skybox.
+     * @remarks
+     * If an environment is already loaded, it will be unloaded before loading the new environment.
+     * @param url The url of the environment texture to load.
+     * @param options The options to use when loading the environment.
+     * @param abortSignal An optional signal that can be used to abort the loading process.
+     */
+    loadEnvironment(url: string, options?: {}, abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Unloads the current environment if one is loaded.
+     * @param abortSignal An optional signal that can be used to abort the reset.
+     */
+    resetEnvironment(abortSignal?: AbortSignal): Promise<void>;
+    private _updateEnvironment;
+    /**
+     * Toggles the play/pause animation state if there is a selected animation.
+     */
+    toggleAnimation(): void;
+    /**
+     * Plays the selected animation if there is one.
+     */
+    playAnimation(): void;
+    /**
+     * Pauses the selected animation if there is one.
+     */
+    pauseAnimation(): Promise<void>;
+    /**
+     * Disposes of the resources held by the Viewer.
+     */
+    dispose(): void;
+    /**
+     * retrun world and canvas coordinates of an hot spot
+     * @param hotSpotQuery mesh index and surface information to query the hot spot positions
+     * @param res Query a Hot Spot and does the conversion for Babylon Hot spot to a more generic HotSpotPositions, without Vector types
+     * @returns true if hotspot found
+     */
+    getHotSpotToRef(hotSpotQuery: Readonly<ViewerHotSpotQuery>, res: ViewerHotSpot): boolean;
+    private _updateCamera;
+    private _updateLight;
+    private _applyAnimationSpeed;
+    /**
+     * Check for disposed or aborted state (basically everything that can interrupt an async operation).
+     * @param abortSignals A set of optional AbortSignals to also check.
+     */
+    private _throwIfDisposedOrAborted;
+}
+
+/**
+ * Options for creating a Viewer instance that is bound to an HTML canvas.
+ */
+type CanvasViewerOptions = ViewerOptions & (({
+    engine?: undefined;
+} & AbstractEngineOptions) | ({
+    engine: "WebGL";
+} & EngineOptions) | ({
+    engine: "WebGPU";
+} & WebGPUEngineOptions));
+/**
+ * Chooses a default engine for the current browser environment.
+ * @returns The default engine to use.
+ */
+declare function getDefaultEngine(): NonNullable<CanvasViewerOptions["engine"]>;
+/**
+ * Creates a Viewer instance that is bound to an HTML canvas.
+ * @remarks
+ * This function can be shared across multiple UI integrations (e.g. Web Components, React, etc.).
+ * @param canvas The canvas element to bind the Viewer to.
+ * @param options The options to use when creating the Viewer and binding it to the specified canvas.
+ * @returns A Viewer instance that is bound to the specified canvas.
+ */
+declare function createViewerForCanvas(canvas: HTMLCanvasElement, options?: CanvasViewerOptions): Promise<Viewer>;
+
+interface HTML3DElementEventMap extends HTMLElementEventMap {
+    viewerready: Event;
+    environmentchange: Event;
+    environmenterror: ErrorEvent;
+    modelchange: Event;
+    modelerror: ErrorEvent;
+    selectedanimationchange: Event;
+    animationspeedchange: Event;
+    animationplayingchange: Event;
+    animationprogresschange: Event;
+}
+/**
+ * Represents a custom element that displays a 3D model using the Babylon.js Viewer.
+ */
+declare class HTML3DElement extends LitElement {
+    private readonly _viewerLock;
+    private _viewerDetails?;
+    static styles: lit.CSSResult;
+    /**
+     * Gets the underlying viewer details (when the underlying viewer is in a loaded state).
+     * This is useful for advanced scenarios where direct access to the viewer or Babylon scene is needed.
+     */
+    get viewerDetails(): Readonly<ViewerDetails> | undefined;
+    /**
+     * Get hotspot world and screen values from a named hotspot
+     * @param name slot of the hot spot
+     * @param result resulting world and screen positions
+     * @returns world and screen space coordinates
+     */
+    queryHotSpot(name: string, result: ViewerHotSpot): boolean;
+    /**
+     * The engine to use for rendering.
+     */
+    engine: NonNullable<CanvasViewerOptions["engine"]>;
+    /**
+     * The model URL.
+     */
+    source: Nullable<string>;
+    /**
+     * Forces the model to be loaded with the specified extension.
+     * @remarks
+     * If this property is not set, the extension will be inferred from the model URL when possible.
+     */
+    extension: Nullable<string>;
+    /**
+     * The environment URL.
+     */
+    environment: Nullable<string>;
+    /**
+     * The clear color (e.g. background color) for the viewer.
+     */
+    clearColor: Nullable<Color4>;
+    /**
+     * A string value that encodes one or more hotspots.
+     */
+    hotspots: Nullable<Record<string, ViewerHotSpotQuery>>;
+    /**
+     * The list of animation names for the currently loaded model.
+     */
+    get animations(): readonly string[];
+    /**
+     * The currently selected animation index.
+     */
+    get selectedAnimation(): number;
+    /**
+     * True if an animation is currently playing.
+     */
+    get isAnimationPlaying(): boolean;
+    /**
+     * The speed scale at which animations are played.
+     */
+    animationSpeed: number;
+    /**
+     * The current point on the selected animation timeline, normalized between 0 and 1.
+     */
+    animationProgress: number;
+    private _animations;
+    private _selectedAnimation;
+    private _isAnimationPlaying;
+    private _canvasContainer;
+    /**
+     * Toggles the play/pause animation state if there is a selected animation.
+     */
+    toggleAnimation(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    update(changedProperties: PropertyValues): void;
+    render(): lit_html.TemplateResult<1>;
+    addEventListener<K extends keyof HTML3DElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTML3DElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    private _dispatchCustomEvent;
+    private _onSelectedAnimationChanged;
+    private _onAnimationSpeedChanged;
+    private _onProgressChanged;
+    private _onProgressPointerDown;
+    private _setupViewer;
+    private _tearDownViewer;
+    private _updateClearColor;
+    private _updateAnimationSpeed;
+    private _updateSelectedAnimation;
+    private _updateModel;
+    private _updateEnv;
+}
+
+export { type CanvasViewerOptions, HTML3DElement, Viewer, type ViewerDetails, type ViewerHotSpot, type ViewerHotSpotQuery, type ViewerOptions, createViewerForCanvas, getDefaultEngine };