@combeenation/3d-viewer 9.3.0 → 10.0.0-alpha3

package/dist/lib-cjs/api/manager/sceneManager.d.ts

@@ -1,33 +1,33 @@
-import { ParameterObservable } from '../classes/parameterObservable';
-import { TextureLoadManager } from './textureLoadManager';
-import { Camera } from '@babylonjs/core/Cameras/camera';
-import { Scene as BabylonScene } from '@babylonjs/core/scene';
-export declare class SceneManager extends ParameterObservable {
-    scene: BabylonScene;
-    protected readonly _parameterObservers: Map<string, ParameterObserver[]>;
-    protected _textureLoadManager: TextureLoadManager | null;
-    /**
-     * Constructor.
-     */
-    protected constructor(scene: BabylonScene);
-    /**
-     * Creates a {@link SceneManager} based on given Babylon.js scene.
-     */
-    static create(scene: BabylonScene): Promise<SceneManager>;
-    /**
-     * The active `Camera`.
-     */
-    get activeCamera(): Camera;
-    /**
-     * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
-     * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
-     *
-     * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
-     */
-    commitParameters(parameters?: ParameterBag): Promise<SceneManager>;
-    protected addParameterObservers(): SceneManager;
-    /**
-     * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
-     */
-    protected bootstrapParameters(parameters?: ParameterBag): Promise<SceneManager>;
-}
+import { ParameterObservable } from '../classes/parameterObservable';
+import { TextureLoadManager } from './textureLoadManager';
+import { Camera } from '@babylonjs/core/Cameras/camera';
+import { Scene as BabylonScene } from '@babylonjs/core/scene';
+export declare class SceneManager extends ParameterObservable {
+    scene: BabylonScene;
+    protected readonly _parameterObservers: Map<string, ParameterObserver[]>;
+    protected _textureLoadManager: TextureLoadManager | null;
+    /**
+     * Constructor.
+     */
+    protected constructor(scene: BabylonScene);
+    /**
+     * Creates a {@link SceneManager} based on given Babylon.js scene.
+     */
+    static create(scene: BabylonScene): Promise<SceneManager>;
+    /**
+     * The active `Camera`.
+     */
+    get activeCamera(): Camera;
+    /**
+     * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
+     * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
+     *
+     * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters?: ParameterBag): Promise<SceneManager>;
+    protected addParameterObservers(): SceneManager;
+    /**
+     * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
+     */
+    protected bootstrapParameters(parameters?: ParameterBag): Promise<SceneManager>;
+}

package/dist/lib-cjs/api/manager/sceneManager.js

@@ -1,129 +1,129 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SceneManager = void 0;
-const event_1 = require("../classes/event");
-const parameter_1 = require("../classes/parameter");
-const parameterObservable_1 = require("../classes/parameterObservable");
-const specStorage_1 = require("../store/specStorage");
-const babylonHelper_1 = require("../util/babylonHelper");
-const resourceHelper_1 = require("../util/resourceHelper");
-const textureLoadManager_1 = require("./textureLoadManager");
-const lodash_es_1 = require("lodash-es");
-class SceneManager extends parameterObservable_1.ParameterObservable {
-    /**
-     * Constructor.
-     */
-    constructor(scene) {
-        super();
-        this.scene = scene;
-        this._parameterObservers = new Map();
-        this._textureLoadManager = null;
-        this._textureLoadManager = textureLoadManager_1.TextureLoadManager.create(scene);
-        this.addParameterObservers();
-    }
-    /**
-     * Creates a {@link SceneManager} based on given Babylon.js scene.
-     */
-    static create(scene) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sceneManager = new SceneManager(scene);
-            yield sceneManager.bootstrapParameters(specStorage_1.SpecStorage.get('scene.parameters'));
-            return sceneManager;
-        });
-    }
-    /**
-     * The active `Camera`.
-     */
-    get activeCamera() {
-        if (!this.scene.activeCamera) {
-            throw new Error('Scene has no active camera.');
-        }
-        return this.scene.activeCamera;
-    }
-    /**
-     * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
-     * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
-     *
-     * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
-     */
-    commitParameters(parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!parameters) {
-                parameters = {};
-            }
-            const oldParameters = (0, lodash_es_1.cloneDeep)(this.parameters);
-            (0, lodash_es_1.merge)(this.parameters, parameters);
-            // handle parameter observers
-            let observerPromises = [];
-            for (const parameter in this.parameters) {
-                const oldParameterValue = oldParameters[parameter];
-                const newParameterValue = this.parameters[parameter];
-                this.assertParameter(parameter_1.Parameter.declarations, parameter, newParameterValue);
-                if (oldParameterValue === newParameterValue) {
-                    continue;
-                }
-                // parameter changed
-                const parameterObservers = (0, resourceHelper_1.mergeMaps)(this._parameterObservers, this.parameterObservers);
-                if (parameterObservers.has(parameter)) {
-                    const observers = parameterObservers.get(parameter);
-                    observerPromises = (0, lodash_es_1.concat)(observerPromises, observers.map(observer => {
-                        const observerPromise = observer(this, oldParameterValue, newParameterValue);
-                        return Promise.resolve(observerPromise).then(() => {
-                            this.broadcastEvent(event_1.Event.SCENE_PARAMETER_COMMITTED, this, parameter, oldParameterValue, newParameterValue);
-                        });
-                    }));
-                }
-            }
-            yield Promise.all(observerPromises);
-            return this;
-        });
-    }
-    addParameterObservers() {
-        const handleEnvParamChange = (manager, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
-            const params = {
-                color: manager.parameters[parameter_1.Parameter.ENVIRONMENT_COLOR],
-                intensity: manager.parameters[parameter_1.Parameter.ENVIRONMENT_INTENSITY],
-                env: manager.parameters[parameter_1.Parameter.ENVIRONMENT],
-                background: manager.parameters[parameter_1.Parameter.ENVIRONMENT_BACKGROUND],
-                rotation: manager.parameters[parameter_1.Parameter.ENVIRONMENT_ROTATION],
-                useDefault: manager.parameters[parameter_1.Parameter.ENVIRONMENT_USEDEFAULT],
-            };
-            const envDef = {
-                environmentColor: params.color ? parameter_1.Parameter.parseColor(params.color) : undefined,
-                environmentIntensity: params.intensity !== undefined ? parameter_1.Parameter.parseNumber(params.intensity) : undefined,
-                environment: params.env ? params.env : undefined,
-                environmentBackground: params.background ? params.background : undefined,
-                environmentRotation: params.rotation !== undefined ? parameter_1.Parameter.parseNumber(params.rotation) : undefined,
-                environmentUseDefault: params.useDefault ? parameter_1.Parameter.parseBoolean(params.useDefault) : undefined,
-            };
-            (0, babylonHelper_1.changeEnvironment)(manager.scene, envDef);
-        });
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_COLOR, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_ROTATION, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_USEDEFAULT, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_BACKGROUND, [handleEnvParamChange]);
-        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_INTENSITY, [handleEnvParamChange]);
-        return this;
-    }
-    /**
-     * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
-     */
-    bootstrapParameters(parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.commitParameters((0, lodash_es_1.merge)((0, lodash_es_1.cloneDeep)(this.parameters), parameters));
-            return this;
-        });
-    }
-}
-exports.SceneManager = SceneManager;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneManager = void 0;
+const event_1 = require("../classes/event");
+const parameter_1 = require("../classes/parameter");
+const parameterObservable_1 = require("../classes/parameterObservable");
+const specStorage_1 = require("../store/specStorage");
+const babylonHelper_1 = require("../util/babylonHelper");
+const resourceHelper_1 = require("../util/resourceHelper");
+const textureLoadManager_1 = require("./textureLoadManager");
+const lodash_es_1 = require("lodash-es");
+class SceneManager extends parameterObservable_1.ParameterObservable {
+    /**
+     * Constructor.
+     */
+    constructor(scene) {
+        super();
+        this.scene = scene;
+        this._parameterObservers = new Map();
+        this._textureLoadManager = null;
+        this._textureLoadManager = textureLoadManager_1.TextureLoadManager.create(scene);
+        this.addParameterObservers();
+    }
+    /**
+     * Creates a {@link SceneManager} based on given Babylon.js scene.
+     */
+    static create(scene) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sceneManager = new SceneManager(scene);
+            yield sceneManager.bootstrapParameters(specStorage_1.SpecStorage.get('scene.parameters'));
+            return sceneManager;
+        });
+    }
+    /**
+     * The active `Camera`.
+     */
+    get activeCamera() {
+        if (!this.scene.activeCamera) {
+            throw new Error('Scene has no active camera.');
+        }
+        return this.scene.activeCamera;
+    }
+    /**
+     * Places the given {@link ParameterBag} in the {@link SceneManager}'s parameters, replaces all patterns in the
+     * {@link StructureJson} and broadcasts all {@link ParameterObserver}s.
+     *
+     * @emit {@link Event.SCENE_PARAMETER_COMMITTED}
+     */
+    commitParameters(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!parameters) {
+                parameters = {};
+            }
+            const oldParameters = (0, lodash_es_1.cloneDeep)(this.parameters);
+            (0, lodash_es_1.merge)(this.parameters, parameters);
+            // handle parameter observers
+            let observerPromises = [];
+            for (const parameter in this.parameters) {
+                const oldParameterValue = oldParameters[parameter];
+                const newParameterValue = this.parameters[parameter];
+                this.assertParameter(parameter_1.Parameter.declarations, parameter, newParameterValue);
+                if (oldParameterValue === newParameterValue) {
+                    continue;
+                }
+                // parameter changed
+                const parameterObservers = (0, resourceHelper_1.mergeMaps)(this._parameterObservers, this.parameterObservers);
+                if (parameterObservers.has(parameter)) {
+                    const observers = parameterObservers.get(parameter);
+                    observerPromises = (0, lodash_es_1.concat)(observerPromises, observers.map(observer => {
+                        const observerPromise = observer(this, oldParameterValue, newParameterValue);
+                        return Promise.resolve(observerPromise).then(() => {
+                            this.broadcastEvent(event_1.Event.SCENE_PARAMETER_COMMITTED, this, parameter, oldParameterValue, newParameterValue);
+                        });
+                    }));
+                }
+            }
+            yield Promise.all(observerPromises);
+            return this;
+        });
+    }
+    addParameterObservers() {
+        const handleEnvParamChange = (manager, oldValue, newValue) => __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                color: manager.parameters[parameter_1.Parameter.ENVIRONMENT_COLOR],
+                intensity: manager.parameters[parameter_1.Parameter.ENVIRONMENT_INTENSITY],
+                env: manager.parameters[parameter_1.Parameter.ENVIRONMENT],
+                background: manager.parameters[parameter_1.Parameter.ENVIRONMENT_BACKGROUND],
+                rotation: manager.parameters[parameter_1.Parameter.ENVIRONMENT_ROTATION],
+                useDefault: manager.parameters[parameter_1.Parameter.ENVIRONMENT_USEDEFAULT],
+            };
+            const envDef = {
+                environmentColor: params.color ? parameter_1.Parameter.parseColor(params.color) : undefined,
+                environmentIntensity: params.intensity !== undefined ? parameter_1.Parameter.parseNumber(params.intensity) : undefined,
+                environment: params.env ? params.env : undefined,
+                environmentBackground: params.background ? params.background : undefined,
+                environmentRotation: params.rotation !== undefined ? parameter_1.Parameter.parseNumber(params.rotation) : undefined,
+                environmentUseDefault: params.useDefault ? parameter_1.Parameter.parseBoolean(params.useDefault) : undefined,
+            };
+            (0, babylonHelper_1.changeEnvironment)(manager.scene, envDef);
+        });
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_COLOR, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_ROTATION, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_USEDEFAULT, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_BACKGROUND, [handleEnvParamChange]);
+        this._parameterObservers.set(parameter_1.Parameter.ENVIRONMENT_INTENSITY, [handleEnvParamChange]);
+        return this;
+    }
+    /**
+     * Bootstrapping for parameters. It sets the `parametersInitialized` to true for all ancestors.
+     */
+    bootstrapParameters(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.commitParameters((0, lodash_es_1.merge)((0, lodash_es_1.cloneDeep)(this.parameters), parameters));
+            return this;
+        });
+    }
+}
+exports.SceneManager = SceneManager;
 //# sourceMappingURL=sceneManager.js.map

package/dist/lib-cjs/api/manager/tagManager.d.ts

@@ -1,118 +1,118 @@
-import { Viewer } from '../classes/viewer';
-import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
-export declare class TagManager {
-    protected viewer: Viewer;
-    readonly parameters: TagManagerParameterBag;
-    readonly parameterObservers: TagManagerParameterObserverBag;
-    /**
-     * Constructor.
-     */
-    constructor(viewer: Viewer);
-    /**
-     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
-     * nodes with given tagName.
-     */
-    setTagParameterValue(tagName: string, parameterName: string, value: ParameterValue): Promise<TagManagerParameterObserverResultBag>;
-    /**
-     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
-     * nodes with given nodeName.
-     */
-    setNodeParameterValue(nodeName: string, parameterName: string, value: ParameterValue): Promise<TagManagerParameterObserverResultBag>;
-    /**
-     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
-     * materials with given materialName.
-     */
-    setMaterialParameterValue(materialName: string, parameterName: string, value: ParameterValue): Promise<TagManagerParameterObserverResultBag>;
-    /**
-     * Splits the passed {@link TagManagerParameterValue}s into individual values and calls all {@link ParameterObserver}s
-     * of all {@link Parameter}s with the respective {@link TagManagerSubject} and {@link ParameterValue}. The result is a
-     * map of passed {@link TagManagerParameterValue}s and the associated {@link TagManagerParameterObserverResult} of the
-     * {@link ParameterObserver}.
-     */
-    setParameterValues(values: TagManagerParameterValue[]): Promise<Map<TagManagerParameterValue, TagManagerParameterObserverResultBag>>;
-    /**
-     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
-     * {@link parameters} and the given object.
-     */
-    getSubjectsFor(object: TransformNode | Material): TagManagerSubject[];
-    /**
-     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
-     * {@link parameters} and the given objects.
-     */
-    getApplicableSubjectsFor(objects: (TransformNode | Material)[]): TagManagerSubject[];
-    /**
-     * Applies all existing states of the {@link TagManager}'s {@link parameters} for given {@link TagManagerSubject}s.
-     */
-    applyExistingParameterValuesFor(subjects: TagManagerSubject[]): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>>;
-    /**
-     * Does the same as {@link setParameterValues} with the difference that all existing states of the
-     * {@link TagManager}'s {@link parameters} are applied to all given nodes.
-     */
-    applyExistingParameterValuesTo(objects: (TransformNode | Material)[]): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>>;
-    /**
-     * Applies all existing states of the {@link TagManager}'s {@link parameters} for all {@link TagManagerSubject}s.
-     */
-    applyExistingParameterValues(): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>>;
-    /**
-     * Maps all tags on given nodes with the {@link TagMapping} and updates the state of the {@link TagManager}'s
-     * {@link parameters} for all new tags.
-     * Also updates the state of all nodes in the tag managers parameter state.
-     */
-    mapNodesAndTags(nodes: TransformNode[], tagMapping: TagMapping): TagManager;
-    /**
-     * Gets a distinct list of all tags within the current scene.
-     */
-    getAllTags(): string[];
-    /**
-     * Prints the state of the {@link TagManager}'s {@link parameters} to the console.
-     */
-    printAllTags(): void;
-    /**
-     * Prints the state of the {@link TagManager}'s {@link parameters} for one tagName to the console.
-     */
-    printTagInfo(tagName: string): void;
-    /**
-     * Sets a {@link ParameterObserver} for the given {@link Parameter}.
-     *
-     * The observer should return `false` in cases where the given value was not actually applied. E.g. when wanting to
-     * apply a property on the given `node`s material which doesn't exist at the time the observer is called etc.
-     */
-    setParameterObserver(parameter: string, observer: TagManagerParameterObserver): TagManager;
-    /**
-     * Gets all nodes for given {@link TagManagerSubject} on the Babylon.js scene.
-     */
-    getNodesBySubject(subject: TagManagerSubject, predicate?: (node: TransformNode) => boolean): TransformNode[];
-    /**
-     * Gets all materials for given {@link TagManagerSubject} on the Babylon.js scene.
-     */
-    getMaterialsBySubject(subject: TagManagerSubject, predicate?: (material: Material) => boolean): Material[];
-    /**
-     * Registers observers that are called on every new object added to the Babylon.js scene.
-     * The observers ensure that each new object gets the state of the {@link TagManager}'s {@link parameters} applied.
-     */
-    registerNewObjectObservers(scene: Scene): void;
-    /**
-     * Adds the default {@link ParameterObserver}s.
-     * @protected
-     */
-    protected addParameterObservers(): TagManager;
-    /**
-     * Passes all {@link ParameterValue}s of the given {@link ParameterBag} for given {@link TagManagerSubject} to
-     * {@link handleParameter}.
-     * @protected
-     */
-    protected handleParameterBag(subject: TagManagerSubject, parameters: ParameterBag): Promise<TagManagerParameterObserverResultBag>[];
-    /**
-     * Asserts the given {@link Parameter} and its {@link ParameterValue}, stores the state in the {@link TagManager}'s
-     * {@link parameters}, calculates the applicable nodes, injects the {@link ParameterValue} in the node's metadata,
-     * calls the responsible {@link ParameterObserver}s and emits the event {@link Event.TAG_MANAGER_PARAMETER_COMMITTED}.
-     * @protected
-     */
-    protected handleParameter(subject: TagManagerSubject, parameter: string, parameterValue: ParameterValue): Promise<TagManagerParameterObserverResultBag>;
-    /**
-     * Updates the state of the {@link TagManager}'s {@link parameters} for all new nodes and tags given in
-     * {@link TagMapping}.
-     * @protected
-     */
-    protected updateParametersWithNodeAndTagMapping(nodes: TransformNode[], tagMapping: TagMapping): void;
-}
+import { Viewer } from '../classes/viewer';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+export declare class TagManager {
+    protected viewer: Viewer;
+    readonly parameters: TagManagerParameterBag;
+    readonly parameterObservers: TagManagerParameterObserverBag;
+    /**
+     * Constructor.
+     */
+    constructor(viewer: Viewer);
+    /**
+     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+     * nodes with given tagName.
+     */
+    setTagParameterValue(tagName: string, parameterName: string, value: ParameterValue): Promise<TagManagerParameterObserverResultBag>;
+    /**
+     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+     * nodes with given nodeName.
+     */
+    setNodeParameterValue(nodeName: string, parameterName: string, value: ParameterValue): Promise<TagManagerParameterObserverResultBag>;
+    /**
+     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+     * materials with given materialName.
+     */
+    setMaterialParameterValue(materialName: string, parameterName: string, value: ParameterValue): Promise<TagManagerParameterObserverResultBag>;
+    /**
+     * Splits the passed {@link TagManagerParameterValue}s into individual values and calls all {@link ParameterObserver}s
+     * of all {@link Parameter}s with the respective {@link TagManagerSubject} and {@link ParameterValue}. The result is a
+     * map of passed {@link TagManagerParameterValue}s and the associated {@link TagManagerParameterObserverResult} of the
+     * {@link ParameterObserver}.
+     */
+    setParameterValues(values: TagManagerParameterValue[]): Promise<Map<TagManagerParameterValue, TagManagerParameterObserverResultBag>>;
+    /**
+     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
+     * {@link parameters} and the given object.
+     */
+    getSubjectsFor(object: TransformNode | Material): TagManagerSubject[];
+    /**
+     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
+     * {@link parameters} and the given objects.
+     */
+    getApplicableSubjectsFor(objects: (TransformNode | Material)[]): TagManagerSubject[];
+    /**
+     * Applies all existing states of the {@link TagManager}'s {@link parameters} for given {@link TagManagerSubject}s.
+     */
+    applyExistingParameterValuesFor(subjects: TagManagerSubject[]): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>>;
+    /**
+     * Does the same as {@link setParameterValues} with the difference that all existing states of the
+     * {@link TagManager}'s {@link parameters} are applied to all given nodes.
+     */
+    applyExistingParameterValuesTo(objects: (TransformNode | Material)[]): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>>;
+    /**
+     * Applies all existing states of the {@link TagManager}'s {@link parameters} for all {@link TagManagerSubject}s.
+     */
+    applyExistingParameterValues(): Promise<Map<TagManagerSubject, TagManagerParameterObserverResultBag>>;
+    /**
+     * Maps all tags on given nodes with the {@link TagMapping} and updates the state of the {@link TagManager}'s
+     * {@link parameters} for all new tags.
+     * Also updates the state of all nodes in the tag managers parameter state.
+     */
+    mapNodesAndTags(nodes: TransformNode[], tagMapping: TagMapping): TagManager;
+    /**
+     * Gets a distinct list of all tags within the current scene.
+     */
+    getAllTags(): string[];
+    /**
+     * Prints the state of the {@link TagManager}'s {@link parameters} to the console.
+     */
+    printAllTags(): void;
+    /**
+     * Prints the state of the {@link TagManager}'s {@link parameters} for one tagName to the console.
+     */
+    printTagInfo(tagName: string): void;
+    /**
+     * Sets a {@link ParameterObserver} for the given {@link Parameter}.
+     *
+     * The observer should return `false` in cases where the given value was not actually applied. E.g. when wanting to
+     * apply a property on the given `node`s material which doesn't exist at the time the observer is called etc.
+     */
+    setParameterObserver(parameter: string, observer: TagManagerParameterObserver): TagManager;
+    /**
+     * Gets all nodes for given {@link TagManagerSubject} on the Babylon.js scene.
+     */
+    getNodesBySubject(subject: TagManagerSubject, predicate?: (node: TransformNode) => boolean): TransformNode[];
+    /**
+     * Gets all materials for given {@link TagManagerSubject} on the Babylon.js scene.
+     */
+    getMaterialsBySubject(subject: TagManagerSubject, predicate?: (material: Material) => boolean): Material[];
+    /**
+     * Registers observers that are called on every new object added to the Babylon.js scene.
+     * The observers ensure that each new object gets the state of the {@link TagManager}'s {@link parameters} applied.
+     */
+    registerNewObjectObservers(scene: Scene): void;
+    /**
+     * Adds the default {@link ParameterObserver}s.
+     * @protected
+     */
+    protected addParameterObservers(): TagManager;
+    /**
+     * Passes all {@link ParameterValue}s of the given {@link ParameterBag} for given {@link TagManagerSubject} to
+     * {@link handleParameter}.
+     * @protected
+     */
+    protected handleParameterBag(subject: TagManagerSubject, parameters: ParameterBag): Promise<TagManagerParameterObserverResultBag>[];
+    /**
+     * Asserts the given {@link Parameter} and its {@link ParameterValue}, stores the state in the {@link TagManager}'s
+     * {@link parameters}, calculates the applicable nodes, injects the {@link ParameterValue} in the node's metadata,
+     * calls the responsible {@link ParameterObserver}s and emits the event {@link Event.TAG_MANAGER_PARAMETER_COMMITTED}.
+     * @protected
+     */
+    protected handleParameter(subject: TagManagerSubject, parameter: string, parameterValue: ParameterValue): Promise<TagManagerParameterObserverResultBag>;
+    /**
+     * Updates the state of the {@link TagManager}'s {@link parameters} for all new nodes and tags given in
+     * {@link TagMapping}.
+     * @protected
+     */
+    protected updateParametersWithNodeAndTagMapping(nodes: TransformNode[], tagMapping: TagMapping): void;
+}