@thatopen/components 2.3.14 → 2.3.16

package/dist/namespace.d.ts

@@ -7,7 +7,7 @@ export declare class Components implements Disposable {
     /**
      * The version of the @thatopen/components library.
      */
-    static readonly release = "2.3.14";
+    static readonly release = "2.3.16";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
     /**
@@ -137,48 +137,6 @@ export declare class Disposer extends Component {
     private disposeChildren;
     private static disposeMaterial;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
-import { Components } from "../Components";
-/**
- * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
- */
-export declare class Raycasters extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A Map that stores raycasters for each world.
-     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
-     */
-    list: Map<string, SimpleRaycaster>;
-    /** {@link Disposable.onDisposed} */
-    onDisposed: Event<unknown>;
-    constructor(components: Components);
-    /**
-     * Retrieves a SimpleRaycaster instance for the given world.
-     * If a SimpleRaycaster instance already exists for the world, it will be returned.
-     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
-     *
-     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
-     * @returns The SimpleRaycaster instance for the given world.
-     */
-    get(world: World): SimpleRaycaster;
-    /**
-     * Deletes the SimpleRaycaster instance associated with the given world.
-     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
-     *
-     * @param world - The world for which to delete the SimpleRaycaster instance.
-     * @returns {void}
-     */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
 import { SimpleScene, SimpleSceneConfig, SimpleSceneConfigManager } from "../Worlds";
 import { DistanceRenderer } from "./src";
 import { Configurable, Disposable } from "../Types";
@@ -238,6 +196,48 @@ export declare class ShadowedScene extends SimpleScene implements Disposable, Co
     private recomputeShadows;
 }
 import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
+import { Components } from "../Components";
+/**
+ * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
+ */
+export declare class Raycasters extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * A Map that stores raycasters for each world.
+     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     */
+    list: Map<string, SimpleRaycaster>;
+    /** {@link Disposable.onDisposed} */
+    onDisposed: Event<unknown>;
+    constructor(components: Components);
+    /**
+     * Retrieves a SimpleRaycaster instance for the given world.
+     * If a SimpleRaycaster instance already exists for the world, it will be returned.
+     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
+     *
+     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
+     * @returns The SimpleRaycaster instance for the given world.
+     */
+    get(world: World): SimpleRaycaster;
+    /**
+     * Deletes the SimpleRaycaster instance associated with the given world.
+     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the SimpleRaycaster instance.
+     * @returns {void}
+     */
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+}
+import { Component, Disposable, World, Event } from "../Types";
 import { SimpleGrid } from "./src";
 import { Components } from "../Components";
 /**
@@ -282,6 +282,59 @@ export declare class Grids extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
+import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer, DataMap } from "../Types";
+import { Components } from "../Components";
+import { SimpleWorld } from "./src";
+/**
+ * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
+ */
+export declare class Worlds extends Component implements Updateable, Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * A collection of worlds managed by this component.
+     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
+     */
+    list: DataMap<string, World>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
+     *
+     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
+     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
+     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
+     *
+     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
+     */
+    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    /**
+     * Deletes a world from the list of worlds.
+     *
+     * @param {World} world - The world to be deleted.
+     *
+     * @throws {Error} - Throws an error if the provided world is not found in the list.
+     */
+    delete(world: World): void;
+    /**
+     * Disposes of the Worlds component and all its managed worlds.
+     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
+     * and triggers the onDisposed event.
+     */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(delta?: number): void | Promise<void>;
+}
 import * as THREE from "three";
 import { Component, Configurable, Createable, Disposable, Event, Hideable, World } from "../Types";
 import { SimplePlane } from "./src";
@@ -423,59 +476,6 @@ export declare class Clipper extends Component implements Createable, Disposable
     private _onStartDragging;
     private _onEndDragging;
 }
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer, DataMap } from "../Types";
-import { Components } from "../Components";
-import { SimpleWorld } from "./src";
-/**
- * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
- */
-export declare class Worlds extends Component implements Updateable, Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * A collection of worlds managed by this component.
-     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
-     */
-    list: DataMap<string, World>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
-     *
-     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
-     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
-     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
-     *
-     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
-     */
-    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
-    /**
-     * Deletes a world from the list of worlds.
-     *
-     * @param {World} world - The world to be deleted.
-     *
-     * @throws {Error} - Throws an error if the provided world is not found in the list.
-     */
-    delete(world: World): void;
-    /**
-     * Disposes of the Worlds component and all its managed worlds.
-     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
-     * and triggers the onDisposed event.
-     */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(delta?: number): void | Promise<void>;
-}
 import * as THREE from "three";
 import { Components } from "../Components";
 import { MeshCullerRenderer } from "./src";
@@ -638,70 +638,6 @@ export declare class ConfigManager extends Component {
     constructor(components: Components);
 }
 import * as THREE from "three";
-import { Components } from "../Components";
-import { SimpleCamera } from "..";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
-/**
- * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
- */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
-    /**
-     * A ProjectionManager instance that manages the projection modes of the camera.
-     */
-    readonly projection: ProjectionManager;
-    /**
-     * A THREE.OrthographicCamera instance that represents the orthographic camera.
-     * This camera is used when the projection mode is set to orthographic.
-     */
-    readonly threeOrtho: THREE.OrthographicCamera;
-    /**
-     * A THREE.PerspectiveCamera instance that represents the perspective camera.
-     * This camera is used when the projection mode is set to perspective.
-     */
-    readonly threePersp: THREE.PerspectiveCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    protected _mode: NavigationMode | null;
-    private previousSize;
-    /**
-     * Getter for the current navigation mode.
-     * Throws an error if the mode is not found or the camera is not initialized.
-     *
-     * @returns {NavigationMode} The current navigation mode.
-     *
-     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
-     */
-    get mode(): NavigationMode;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
-     *
-     * @param mode - The {@link NavigationMode} to set.
-     */
-    set(mode: NavModeID): void;
-    /**
-     * Make the camera view fit all the specified meshes.
-     *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
-     */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
-    /**
-     * Allows or prevents all user input.
-     *
-     * @param active - whether to enable or disable user inputs.
-     */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
-}
-import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { Component, Components } from "../../core";
 /**
@@ -1014,56 +950,6 @@ export declare class BoundingBoxer extends Component implements Disposable {
     addFragmentIdMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
     private static getFragmentBounds;
 }
-import { Component, Disposable, Event, Components } from "../../core";
-/**
- * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
- */
-export declare class Exploder extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * The height of the explosion animation.
-     * This property determines the vertical distance by which fragments are moved during the explosion.
-     * Default value is 10.
-     */
-    height: number;
-    /**
-     * The group name used for the explosion animation.
-     * This property specifies the group of fragments that will be affected by the explosion.
-     * Default value is "storeys".
-     */
-    groupName: string;
-    /**
-     * A set of strings representing the exploded items.
-     * This set is used to keep track of which items have been exploded.
-     */
-    list: Set<string>;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets the explosion state of the fragments.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the explosion.
-     *
-     * @remarks
-     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
-     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
-     * If 'active' is false, the fragments are moved back to their original position.
-     *
-     * The method also keeps track of the exploded items using the 'list' set.
-     *
-     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
-     */
-    set(active: boolean): void;
-}
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { Disposable, Component, Event, Components } from "../../core";
@@ -1209,6 +1095,7 @@ export declare class Classifier extends Component implements Disposable {
     bySpatialStructure(model: FRAGS.FragmentsGroup, config?: {
         useProperties?: boolean;
         isolate?: Set<number>;
+        systemName?: string;
     }): Promise<void>;
     /**
      * Sets the color of the specified fragments.
@@ -1238,6 +1125,120 @@ export declare class Classifier extends Component implements Disposable {
     resetColor(items: FRAGS.FragmentIdMap): void;
     protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
 }
+import { Component, Disposable, Event, Components } from "../../core";
+/**
+ * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
+ */
+export declare class Exploder extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
+     */
+    height: number;
+    /**
+     * The group name used for the explosion animation.
+     * This property specifies the group of fragments that will be affected by the explosion.
+     * Default value is "storeys".
+     */
+    groupName: string;
+    /**
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
+     */
+    list: Set<string>;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets the explosion state of the fragments.
+     *
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     *
+     * @remarks
+     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
+     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
+     * If 'active' is false, the fragments are moved back to their original position.
+     *
+     * The method also keeps track of the exploded items using the 'list' set.
+     *
+     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
+     */
+    set(active: boolean): void;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { SimpleCamera } from "..";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+/**
+ * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
+ */
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
+    /**
+     * A ProjectionManager instance that manages the projection modes of the camera.
+     */
+    readonly projection: ProjectionManager;
+    /**
+     * A THREE.OrthographicCamera instance that represents the orthographic camera.
+     * This camera is used when the projection mode is set to orthographic.
+     */
+    readonly threeOrtho: THREE.OrthographicCamera;
+    /**
+     * A THREE.PerspectiveCamera instance that represents the perspective camera.
+     * This camera is used when the projection mode is set to perspective.
+     */
+    readonly threePersp: THREE.PerspectiveCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    protected _mode: NavigationMode | null;
+    private previousSize;
+    /**
+     * Getter for the current navigation mode.
+     * Throws an error if the mode is not found or the camera is not initialized.
+     *
+     * @returns {NavigationMode} The current navigation mode.
+     *
+     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+     */
+    get mode(): NavigationMode;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets a new {@link NavigationMode} and disables the previous one.
+     *
+     * @param mode - The {@link NavigationMode} to set.
+     */
+    set(mode: NavModeID): void;
+    /**
+     * Make the camera view fit all the specified meshes.
+     *
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
+     */
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    /**
+     * Allows or prevents all user input.
+     *
+     * @param active - whether to enable or disable user inputs.
+     */
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoPerspCameraAspect;
+}
 import * as FRAGS from "@thatopen/fragments";
 import { Components, Component } from "../../core";
 /**
@@ -1709,6 +1710,66 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private streamGeometries;
     private registerGeometryData;
 }
+import * as FRAGS from "@thatopen/fragments";
+import { XMLParser } from "fast-xml-parser";
+import { Component, DataMap } from "../../core/Types";
+import { IDSCheckResult, IDSInfo, IDSSpecification, IfcVersion } from "./src";
+import { Components } from "../../core";
+/**
+ * Component that manages Information Delivery Specification (IDS) data.
+ * It provides functionality for importing, exporting, and manipulating IDS data.
+ */
+export declare class IDSSpecifications extends Component {
+    static uuid: "9f0b9f78-9b2e-481a-b766-2fbfd01f342c";
+    enabled: boolean;
+    static xmlParser: XMLParser;
+    constructor(components: Components);
+    readonly list: DataMap<string, IDSSpecification>;
+    /**
+     * Retrieves a FragmentIdMap based on the given IDSCheckResult array.
+     * The map separates the IDs into two categories: pass and fail.
+     *
+     * @param model - The FragmentsGroup model from which to retrieve the fragment map.
+     * @param result - An array of IDSCheckResult objects, each representing a check result.
+     *
+     * @returns An object containing two properties:
+     * - 'pass': A FragmentIdMap that passed the checks.
+     * - 'fail': A FragmentIdMap that failed the checks.
+     */
+    getFragmentIdMap(model: FRAGS.FragmentsGroup, result: IDSCheckResult[]): {
+        pass: FRAGS.FragmentIdMap;
+        fail: FRAGS.FragmentIdMap;
+    };
+    /**
+     * Creates a new IDSSpecification instance and adds it to the list.
+     *
+     * @param name - The name of the IDSSpecification.
+     * @param ifcVersion - An array of IfcVersion values that the specification supports.
+     *
+     * @returns The newly created IDSSpecification instance.
+     */
+    create(name: string, ifcVersion: IfcVersion[], identifier?: string): IDSSpecification;
+    /**
+     * Parses and processes an XML string containing Information Delivery Specification (IDS) data.
+     * It creates IDSSpecification instances based on the parsed data and returns them in an array.
+     * Also, the instances are added to the list array.
+     *
+     * @param data - The XML string to parse.
+     *
+     * @returns An array of IDSSpecification instances created from the parsed data.
+     */
+    load(data: string): IDSSpecification[];
+    /**
+     * Exports the IDSSpecifications data into an XML string.
+     *
+     * @param info - The metadata information for the exported XML.
+     * @param specifications - An optional iterable of IDSSpecification instances to export.
+     * If not provided, all specifications in the list will be exported.
+     *
+     * @returns A string containing the exported IDSSpecifications data in XML format.
+     */
+    export(info: IDSInfo, specifications?: Iterable<IDSSpecification>): string;
+}
 import * as WEBIFC from "web-ifc";
 import * as FRAG from "@thatopen/fragments";
 import { Component, Components } from "../../core";
@@ -1734,21 +1795,135 @@ export declare class IfcJsonExporter extends Component {
      */
     export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttribute, IfcRelation } from "./src";
+import { XMLParser } from "fast-xml-parser";
+import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core";
+import { BCFTopic, Topic, BCFTopicsConfigManager, BCFTopicsConfig } from "./src";
+import { Viewpoint } from "../../core/Viewpoints";
 /**
- * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
+ * BCFTopics manages Building Collaboration Format (BCF) data the engine.
+ * It provides functionality for importing, exporting, and manipulating BCF data.
  */
-export declare class IfcRelationsIndexer extends Component implements Disposable {
+export declare class BCFTopics extends Component implements Disposable, Configurable<BCFTopicsConfigManager, BCFTopicsConfig> {
+    static uuid: "de977976-e4f6-4e4f-a01a-204727839802";
+    enabled: boolean;
+    static xmlParser: XMLParser;
+    protected _defaultConfig: Required<BCFTopicsConfig>;
+    config: BCFTopicsConfigManager;
+    readonly list: DataMap<string, Topic>;
+    readonly onSetup: Event<unknown>;
+    isSetup: boolean;
+    setup(config?: Partial<BCFTopicsConfig>): void;
+    readonly onBCFImported: Event<Topic[]>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Creates a new BCFTopic instance and adds it to the list.
+     *
+     * @param data - Optional partial BCFTopic object to initialize the new topic with.
+     * If not provided, default values will be used.
+     * @returns The newly created BCFTopic instance.
      */
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    create(data?: Partial<BCFTopic>): Topic;
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Disposes of the BCFTopics component and triggers the onDisposed event.
+     *
+     * @remarks
+     * This method clears the list of topics and triggers the onDisposed event.
+     * It also resets the onDisposed event listener.
+     */
+    dispose(): void;
+    /**
+     * Retrieves the unique set of topic types used across all topics.
+     *
+     * @returns A Set containing the unique topic types.
+     */
+    get usedTypes(): Set<string>;
+    /**
+     * Retrieves the unique set of topic statuses used across all topics.
+     *
+     * @returns A Set containing the unique topic statuses.
+     */
+    get usedStatuses(): Set<string>;
+    /**
+     * Retrieves the unique set of topic priorities used across all topics.
+     *
+     * @returns A Set containing the unique topic priorities.
+     * Note: This method filters out any null or undefined priorities.
+     */
+    get usedPriorities(): Set<string | undefined>;
+    /**
+     * Retrieves the unique set of topic stages used across all topics.
+     *
+     * @returns A Set containing the unique topic stages.
+     * Note: This method filters out any null or undefined stages.
+     */
+    get usedStages(): Set<string | undefined>;
+    /**
+     * Retrieves the unique set of users associated with topics.
+     *
+     * @returns A Set containing the unique users.
+     * Note: This method collects users from the creation author, assigned to, modified author, and comment authors.
+     */
+    get usedUsers(): Set<string>;
+    /**
+     * Retrieves the unique set of labels used across all topics.
+     *
+     * @returns A Set containing the unique labels.
+     */
+    get usedLabels(): Set<string>;
+    /**
+     * Updates the set of extensions (types, statuses, priorities, labels, stages, users) based on the current topics.
+     * This method iterates through each topic in the list and adds its properties to the corresponding sets in the config.
+     */
+    updateExtensions(): void;
+    /**
+     * Updates the references to viewpoints in the topics.
+     * This function iterates through each topic and checks if the viewpoints exist in the viewpoints list.
+     * If a viewpoint does not exist, it is removed from the topic's viewpoints.
+     */
+    updateViewpointReferences(): void;
+    /**
+     * Exports the given topics to a BCF (Building Collaboration Format) zip file.
+     *
+     * @param topics - The topics to export. Defaults to all topics in the list.
+     * @returns A promise that resolves to a Blob containing the exported BCF zip file.
+     */
+    export(topics?: Iterable<Topic>): Promise<Blob>;
+    private serializeExtensions;
+    private processMarkupComment;
+    private getMarkupComments;
+    private getMarkupLabels;
+    private getMarkupViewpoints;
+    private getMarkupRelatedTopics;
+    /**
+     * Loads BCF (Building Collaboration Format) data into the engine.
+     *
+     * @param world - The default world where the viewpoints are going to be created.
+     * @param data - The BCF data to load.
+     *
+     * @returns A promise that resolves to an object containing the created viewpoints and topics.
+     *
+     * @throws An error if the BCF version is not supported.
+     */
+    load(data: Uint8Array, world: World): Promise<{
+        viewpoints: Viewpoint[];
+        topics: Topic[];
+    }>;
+}
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttribute, IfcRelation, RelationsProcessingConfig, EntitiesRelatedEvent } from "./src";
+/**
+ * Indexer component for IFC entities, facilitating the indexing and retrieval of IFC entity relationships. It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcRelationsIndexer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcRelationsIndexer).
+ */
+export declare class IfcRelationsIndexer extends Component implements Disposable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
      * Event triggered when relations for a model have been indexed.
      * This event provides the model's UUID and the relations map generated for that model.
@@ -1778,7 +1953,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     constructor(components: Components);
     private onFragmentsDisposed;
     private indexRelations;
-    getAttributeIndex(inverseAttribute: InverseAttribute): number | null;
+    getAttributeIndex(inverseAttribute: InverseAttribute): number;
     /**
      * Adds a relation map to the model's relations map.
      *
@@ -1804,7 +1979,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      * representation of the relations indexed by entity expressIDs and relation types.
      * @throws An error if the model does not have properties loaded.
      */
-    process(model: FragmentsGroup): Promise<RelationsMap>;
+    process(model: FragmentsGroup, config?: Partial<RelationsProcessingConfig>): Promise<RelationsMap>;
     /**
      * Processes a given model from a WebIfc API to index its IFC entities relations.
      *
@@ -1821,11 +1996,10 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      *
      * @param model The 'FragmentsGroup' model containing the entity, or its UUID.
      * @param expressID The unique identifier of the entity within the model.
-     * @param relationName The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
-     * @returns An array of express IDs representing the related entities, or 'null' if no relations are found
-     * or the specified relation name is not indexed.
+     * @param attribute The IFC schema inverse attribute of the relation to search for (e.g., "IsDefinedBy", "ContainsElements").
+     * @returns An array of express IDs representing the related entities. If the array is empty, no relations were found.
      */
-    getEntityRelations(model: FragmentsGroup | string, expressID: number, relationName: InverseAttribute): number[] | null;
+    getEntityRelations(model: FragmentsGroup | string | RelationsMap, expressID: number, attribute: InverseAttribute): number[];
     /**
      * Serializes the relations of a given relation map into a JSON string.
      * This method iterates through the relations in the given map, organizing them into a structured object where each key is an expressID of an entity,
@@ -1902,7 +2076,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      * Converts the relations made into actual IFC data.
      *
      * @remarks This function iterates through the changes made to the relations and applies them to the corresponding BIM model.
-     * It only make sense to use if the relations need to be write in the IFC file.
+     * It only make sense to use it if the relations need to be write in the IFC file.
      *
      * @returns A promise that resolves when all the relation changes have been applied.
      */
@@ -1913,16 +2087,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      * The event provides information about the type of relation, the inverse attribute,
      * the IDs of the entities related, and the IDs of the entities that are being related.
      */
-    readonly onEntitiesRelated: Event<{
-        /** The type of the IFC relation. */
-        relType: IfcRelation;
-        /** The inverse attribute of the relation. */
-        invAttribute: InverseAttribute;
-        /** The IDs of the entities that are relating. */
-        relatingIDs: number[];
-        /** The IDs of the entities that are being related. */
-        relatedIDs: number[];
-    }>;
+    readonly onEntitiesRelated: Event<EntitiesRelatedEvent>;
     addEntitiesRelation(model: FragmentsGroup, relatingID: number, rel: {
         type: IfcRelation;
         inv: InverseAttribute;
@@ -2221,120 +2386,6 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
     private registerChange;
     private newSingleProperty;
 }
-import { XMLParser } from "fast-xml-parser";
-import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core";
-import { BCFTopic, Topic, BCFTopicsConfigManager, BCFTopicsConfig } from "./src";
-import { Viewpoint } from "../../core/Viewpoints";
-/**
- * BCFTopics manages Building Collaboration Format (BCF) data the engine.
- * It provides functionality for importing, exporting, and manipulating BCF data.
- */
-export declare class BCFTopics extends Component implements Disposable, Configurable<BCFTopicsConfigManager, BCFTopicsConfig> {
-    static uuid: "de977976-e4f6-4e4f-a01a-204727839802";
-    enabled: boolean;
-    static xmlParser: XMLParser;
-    protected _defaultConfig: Required<BCFTopicsConfig>;
-    config: BCFTopicsConfigManager;
-    readonly list: DataMap<string, Topic>;
-    readonly onSetup: Event<unknown>;
-    isSetup: boolean;
-    setup(config?: Partial<BCFTopicsConfig>): void;
-    readonly onBCFImported: Event<Topic[]>;
-    /**
-     * Creates a new BCFTopic instance and adds it to the list.
-     *
-     * @param data - Optional partial BCFTopic object to initialize the new topic with.
-     * If not provided, default values will be used.
-     * @returns The newly created BCFTopic instance.
-     */
-    create(data?: Partial<BCFTopic>): Topic;
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Disposes of the BCFTopics component and triggers the onDisposed event.
-     *
-     * @remarks
-     * This method clears the list of topics and triggers the onDisposed event.
-     * It also resets the onDisposed event listener.
-     */
-    dispose(): void;
-    /**
-     * Retrieves the unique set of topic types used across all topics.
-     *
-     * @returns A Set containing the unique topic types.
-     */
-    get usedTypes(): Set<string>;
-    /**
-     * Retrieves the unique set of topic statuses used across all topics.
-     *
-     * @returns A Set containing the unique topic statuses.
-     */
-    get usedStatuses(): Set<string>;
-    /**
-     * Retrieves the unique set of topic priorities used across all topics.
-     *
-     * @returns A Set containing the unique topic priorities.
-     * Note: This method filters out any null or undefined priorities.
-     */
-    get usedPriorities(): Set<string | undefined>;
-    /**
-     * Retrieves the unique set of topic stages used across all topics.
-     *
-     * @returns A Set containing the unique topic stages.
-     * Note: This method filters out any null or undefined stages.
-     */
-    get usedStages(): Set<string | undefined>;
-    /**
-     * Retrieves the unique set of users associated with topics.
-     *
-     * @returns A Set containing the unique users.
-     * Note: This method collects users from the creation author, assigned to, modified author, and comment authors.
-     */
-    get usedUsers(): Set<string>;
-    /**
-     * Retrieves the unique set of labels used across all topics.
-     *
-     * @returns A Set containing the unique labels.
-     */
-    get usedLabels(): Set<string>;
-    /**
-     * Updates the set of extensions (types, statuses, priorities, labels, stages, users) based on the current topics.
-     * This method iterates through each topic in the list and adds its properties to the corresponding sets in the config.
-     */
-    updateExtensions(): void;
-    /**
-     * Updates the references to viewpoints in the topics.
-     * This function iterates through each topic and checks if the viewpoints exist in the viewpoints list.
-     * If a viewpoint does not exist, it is removed from the topic's viewpoints.
-     */
-    updateViewpointReferences(): void;
-    /**
-     * Exports the given topics to a BCF (Building Collaboration Format) zip file.
-     *
-     * @param topics - The topics to export. Defaults to all topics in the list.
-     * @returns A promise that resolves to a Blob containing the exported BCF zip file.
-     */
-    export(topics?: Iterable<Topic>): Promise<Blob>;
-    private serializeExtensions;
-    private processMarkupComment;
-    private getMarkupComments;
-    private getMarkupLabels;
-    private getMarkupViewpoints;
-    private getMarkupRelatedTopics;
-    /**
-     * Loads BCF (Building Collaboration Format) data into the engine.
-     *
-     * @param world - The default world where the viewpoints are going to be created.
-     * @param data - The BCF data to load.
-     *
-     * @returns A promise that resolves to an object containing the created viewpoints and topics.
-     *
-     * @throws An error if the BCF version is not supported.
-     */
-    load(data: Uint8Array, world: World): Promise<{
-        viewpoints: Viewpoint[];
-        topics: Topic[];
-    }>;
-}
 import { Component, Components } from "../../core";
 import { IfcQueryGroup } from "./src/ifc-query-group";
 import { IfcFinderQuery } from "./src";
@@ -2384,90 +2435,30 @@ export declare class IfcFinder extends Component {
      */
     clear(): void;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { XMLParser } from "fast-xml-parser";
-import { Component, DataMap } from "../../core/Types";
-import { IDSCheckResult, IDSInfo, IDSSpecification, IfcVersion } from "./src";
-import { Components } from "../../core";
+import * as THREE from "three";
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
+};
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+import * as THREE from "three";
+import { Component, Components, Disposable, Event, World } from "../core";
 /**
- * Component that manages Information Delivery Specification (IDS) data.
- * It provides functionality for importing, exporting, and manipulating IDS data.
+ * Configuration interface for the VertexPicker component.
  */
-export declare class IDSSpecifications extends Component {
-    static uuid: "9f0b9f78-9b2e-481a-b766-2fbfd01f342c";
-    enabled: boolean;
-    static xmlParser: XMLParser;
-    constructor(components: Components);
-    readonly list: DataMap<string, IDSSpecification>;
-    /**
-     * Retrieves a FragmentIdMap based on the given IDSCheckResult array.
-     * The map separates the IDs into two categories: pass and fail.
-     *
-     * @param model - The FragmentsGroup model from which to retrieve the fragment map.
-     * @param result - An array of IDSCheckResult objects, each representing a check result.
-     *
-     * @returns An object containing two properties:
-     * - 'pass': A FragmentIdMap that passed the checks.
-     * - 'fail': A FragmentIdMap that failed the checks.
-     */
-    getFragmentIdMap(model: FRAGS.FragmentsGroup, result: IDSCheckResult[]): {
-        pass: FRAGS.FragmentIdMap;
-        fail: FRAGS.FragmentIdMap;
-    };
-    /**
-     * Creates a new IDSSpecification instance and adds it to the list.
-     *
-     * @param name - The name of the IDSSpecification.
-     * @param ifcVersion - An array of IfcVersion values that the specification supports.
-     *
-     * @returns The newly created IDSSpecification instance.
-     */
-    create(name: string, ifcVersion: IfcVersion[], identifier?: string): IDSSpecification;
-    /**
-     * Parses and processes an XML string containing Information Delivery Specification (IDS) data.
-     * It creates IDSSpecification instances based on the parsed data and returns them in an array.
-     * Also, the instances are added to the list array.
-     *
-     * @param data - The XML string to parse.
-     *
-     * @returns An array of IDSSpecification instances created from the parsed data.
-     */
-    load(data: string): IDSSpecification[];
-    /**
-     * Exports the IDSSpecifications data into an XML string.
-     *
-     * @param info - The metadata information for the exported XML.
-     * @param specifications - An optional iterable of IDSSpecification instances to export.
-     * If not provided, all specifications in the list will be exported.
-     *
-     * @returns A string containing the exported IDSSpecifications data in XML format.
-     */
-    export(info: IDSInfo, specifications?: Iterable<IDSSpecification>): string;
-}
-import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
-/**
- * Configuration interface for the VertexPicker component.
- */
-export interface VertexPickerConfig {
+export interface VertexPickerConfig {
     /**
      * If true, only vertices will be picked, not the closest point on the face.
      */
@@ -2635,66 +2626,12 @@ export declare class ClipperConfigManager extends Configurator<Clipper, ClipperC
 }
 export {};
 import * as WEBIFC from "web-ifc";
-/** Configuration of the IFC-fragment conversion. */
-export declare class IfcFragmentSettings {
-    /** Whether to extract the IFC properties into a JSON. */
-    includeProperties: boolean;
-    /**
-     * Generate the geometry for categories that are not included by default,
-     * like IFCSPACE.
-     */
-    optionalCategories: number[];
-    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    wasm: {
-        path: string;
-        absolute: boolean;
-        logLevel?: WEBIFC.LogLevel;
-    };
-    /** List of categories that won't be converted to fragments. */
-    excludedCategories: Set<number>;
-    /** Exclusive list of categories that will be converted to fragments. If this contains any category, any other categories will be ignored. */
-    includedCategories: Set<number>;
-    /** Whether to save the absolute location of all IFC items. */
-    saveLocations: boolean;
-    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    webIfc: WEBIFC.LoaderSettings;
-    /**
-     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * If set to true, the path will be set to the default path of the WASM file.
-     * If set to false, the path must be provided manually in the 'wasm.path' property.
-     * Default value is true.
-     */
-    autoSetWasm: boolean;
-    /**
-     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
-     * If set to null, the default file location handler will be used.
-     *
-     * @param url - The URL of the file to locate.
-     * @returns The absolute path of the file.
-     */
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
-}
-import * as FRAGS from "@thatopen/fragments";
-import * as WEBIFC from "web-ifc";
-export declare class SpatialIdsFinder {
-    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
-}
-import * as WEBIFC from "web-ifc";
 export interface IfcItemsCategories {
     [itemID: number]: number;
 }
 export declare class IfcCategories {
     getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
 }
-import * as WEBIFC from "web-ifc";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
-}
 /**
  * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
  *
@@ -2740,13 +2677,6 @@ export declare class IfcPropertiesUtils {
 export declare const ifcCategoryCase: {
     [upperCase: string]: string;
 };
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createPropertyFacets: (components: Components, elements: any) => IDSFacet[];
-/**
- * A Set of unique numbers representing different types of IFC geometries.
- */
-export declare const GeometryTypes: Set<number>;
 import * as FRAGS from "@thatopen/fragments";
 import { IfcFinderQuery } from "./ifc-finder-query";
 import { Components } from "../../../core";
@@ -2816,6 +2746,72 @@ export declare class IfcQueryGroup {
      */
     update(modelID: string, file: File): Promise<void>;
 }
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
+import * as WEBIFC from "web-ifc";
+/** Configuration of the IFC-fragment conversion. */
+export declare class IfcFragmentSettings {
+    /** Whether to extract the IFC properties into a JSON. */
+    includeProperties: boolean;
+    /**
+     * Generate the geometry for categories that are not included by default,
+     * like IFCSPACE.
+     */
+    optionalCategories: number[];
+    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    wasm: {
+        path: string;
+        absolute: boolean;
+        logLevel?: WEBIFC.LogLevel;
+    };
+    /** List of categories that won't be converted to fragments. */
+    excludedCategories: Set<number>;
+    /** Exclusive list of categories that will be converted to fragments. If this contains any category, any other categories will be ignored. */
+    includedCategories: Set<number>;
+    /** Whether to save the absolute location of all IFC items. */
+    saveLocations: boolean;
+    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    webIfc: WEBIFC.LoaderSettings;
+    /**
+     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * If set to true, the path will be set to the default path of the WASM file.
+     * If set to false, the path must be provided manually in the 'wasm.path' property.
+     * Default value is true.
+     */
+    autoSetWasm: boolean;
+    /**
+     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
+     * If set to null, the default file location handler will be used.
+     *
+     * @param url - The URL of the file to locate.
+     * @returns The absolute path of the file.
+     */
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+import * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+}
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711 | 2565941209 | 2495723537 | 3268803585 | 982818633, {
+    forRelating: InverseAttribute;
+    forRelated: InverseAttribute;
+}>;
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createPropertyFacets: (components: Components, elements: any) => IDSFacet[];
 /**
  * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
  */
@@ -2844,11 +2840,6 @@ export declare class Event<T> {
     reset(): void;
     private handlers;
 }
-import { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711 | 2565941209 | 2495723537 | 3268803585 | 982818633, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
 /**
  * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to 'this', you will need to declare the callback as an arrow function.
  */
@@ -3016,29 +3007,6 @@ export declare abstract class Base {
     /** Whether is component is {@link Configurable}. */
     isConfigurable: () => this is Configurable<any, any>;
 }
-import { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
-import { Components } from "../../Components";
-/**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
- */
-export declare abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
-    /**
-     * Event that is triggered when a world is added or removed from the 'worlds' map.
-     * The event payload contains the world instance and the action ("added" or "removed").
-     */
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
-    /**
-     * The current world this item is associated with. It can be null if no world is currently active.
-     */
-    currentWorld: World | null;
-    protected constructor(components: Components);
-}
 import * as THREE from "three";
 import CameraControls from "camera-controls";
 import { BaseWorldItem } from "./base-world-item";
@@ -3067,6 +3035,29 @@ export declare abstract class BaseCamera extends BaseWorldItem {
      */
     hasCameraControls: () => this is CameraControllable;
 }
+import { Base } from "./base";
+import { World } from "./world";
+import { Event } from "./event";
+import { Components } from "../../Components";
+/**
+ * One of the elements that make a world. It can be either a scene, a camera or a renderer.
+ */
+export declare abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
+    /**
+     * Event that is triggered when a world is added or removed from the 'worlds' map.
+     * The event payload contains the world instance and the action ("added" or "removed").
+     */
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
+    /**
+     * The current world this item is associated with. It can be null if no world is currently active.
+     */
+    currentWorld: World | null;
+    protected constructor(components: Components);
+}
 import * as THREE from "three";
 import { Vector2 } from "three";
 import { Event } from "./event";
@@ -3157,50 +3148,16 @@ export declare abstract class BaseScene extends BaseWorldItem implements Disposa
     dispose(): void;
     deleteAllLights(): void;
 }
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
+import { Event } from "./event";
 /**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ * A class that extends the built-in Set class and provides additional functionality.
+ * It triggers events when items are added, deleted, or the set is cleared.
+ *
+ * @template T - The type of elements in the set.
  */
-export interface World extends Disposable, Updateable {
+export declare class DataSet<T> extends Set<T> {
     /**
-     * A set of meshes present in the world. This is taken into account for operations like raycasting.
-     */
-    meshes: Set<THREE.Mesh>;
-    /**
-     * The base scene of the world.
-     */
-    scene: BaseScene;
-    /**
-     * The base camera of the world.
-     */
-    camera: BaseCamera;
-    /**
-     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
-     */
-    renderer: BaseRenderer | null;
-    /**
-     * A unique identifier for the world.
-     */
-    uuid: string;
-    /**
-     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
-     */
-    isDisposing: boolean;
-}
-import { Event } from "./event";
-/**
- * A class that extends the built-in Set class and provides additional functionality.
- * It triggers events when items are added, deleted, or the set is cleared.
- *
- * @template T - The type of elements in the set.
- */
-export declare class DataSet<T> extends Set<T> {
-    /**
-     * An event that is triggered when a new item is added to the set.
+     * An event that is triggered when a new item is added to the set.
      */
     readonly onItemAdded: Event<T>;
     /**
@@ -3250,6 +3207,40 @@ export declare class DataSet<T> extends Set<T> {
      */
     dispose(): void;
 }
+import * as THREE from "three";
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
+/**
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ */
+export interface World extends Disposable, Updateable {
+    /**
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
+     */
+    meshes: Set<THREE.Mesh>;
+    /**
+     * The base scene of the world.
+     */
+    scene: BaseScene;
+    /**
+     * The base camera of the world.
+     */
+    camera: BaseCamera;
+    /**
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     */
+    renderer: BaseRenderer | null;
+    /**
+     * A unique identifier for the world.
+     */
+    uuid: string;
+    /**
+     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     */
+    isDisposing: boolean;
+}
 import { Event } from "./event";
 /**
  * A class that extends the built-in Map class and provides additional events for item set, update, delete, and clear operations.
@@ -3377,364 +3368,217 @@ export interface ControlsSchema {
     [name: string]: ControlEntry | ControlsSchema;
 }
 import * as THREE from "three";
-import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
+import { Resizeable, Updateable, World, Event, Disposable, Configurable } from "../../Types";
+import { MiniMapConfig, MiniMapConfigManager } from "./mini-map-config";
 import { Components } from "../../Components";
-import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
 /**
- * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ * A class representing a 2D minimap of a 3D world.
  */
-export declare class SimpleGrid implements Hideable, Disposable, Configurable<SimpleGridConfigManager, SimpleGridConfig> {
+export declare class MiniMap implements Resizeable, Updateable, Disposable, Configurable<MiniMapConfigManager, MiniMapConfig> {
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Resizeable.onResize} */
+    readonly onResize: Event<THREE.Vector2>;
     /** {@link Configurable.onSetup} */
     readonly onSetup: Event<unknown>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /** The world instance to which this Raycaster belongs. */
+    /**
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     */
+    frontOffset: number;
+    /**
+     * The override material for the minimap.
+     * It is used to render the depth information of the world onto the minimap.
+     */
+    overrideMaterial: THREE.MeshDepthMaterial;
+    /**
+     * The background color of the minimap.
+     * It is used to set the background color of the minimap's renderer.
+     */
+    backgroundColor: THREE.Color;
+    /**
+     * The WebGL renderer for the minimap.
+     * It is used to render the minimap onto the screen.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * A flag indicating whether the minimap is enabled.
+     * If disabled, the minimap will not update or render.
+     */
+    enabled: boolean;
+    /**
+     * The world in which the minimap is displayed.
+     * It provides access to the 3D scene, camera, and other relevant world elements.
+     */
     world: World;
-    /** The components instance to which this grid belongs. */
-    components: Components;
     /** {@link Configurable.config} */
-    config: SimpleGridConfigManager;
-    protected _defaultConfig: SimpleGridConfig;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
+    config: MiniMapConfigManager;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    protected _defaultConfig: MiniMapConfig;
+    private _lockRotation;
+    private _size;
+    private _camera;
+    private _plane;
+    private _tempVector1;
+    private _tempVector2;
+    private _tempTarget;
+    private readonly down;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Gets or sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
      */
-    get fade(): boolean;
+    get lockRotation(): boolean;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     * @param active - If 'true', rotation is locked. If 'false', rotation is not locked.
      */
-    set fade(active: boolean);
-    /** The Three.js mesh that contains the infinite grid. */
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleGridConfig>): void;
+    set lockRotation(active: boolean);
+    /**
+     * Gets the current zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @returns The current zoom level of the minimap.
+     */
+    get zoom(): number;
+    /**
+     * Sets the zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @param value - The new zoom level of the minimap.
+     */
+    set zoom(value: number);
+    constructor(world: World, components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    private setupEvents;
-    private updateZoom;
+    /** Returns the camera used by the MiniMap */
+    get(): THREE.OrthographicCamera;
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Resizeable.getSize} */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize(size?: THREE.Vector2): void;
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<MiniMapConfig>): void;
+    private updatePlanes;
 }
 import * as THREE from "three";
 import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
-import { SimpleGrid } from "./simple-grid";
-type SimpleGridConfigType = {
+import { MiniMap } from "./index";
+type MiniMapConfigType = {
     visible: BooleanSettingsControl;
-    color: ColorSettingsControl;
-    primarySize: NumberSettingControl;
-    secondarySize: NumberSettingControl;
-    distance: NumberSettingControl;
+    lockRotation: BooleanSettingsControl;
+    zoom: NumberSettingControl;
+    frontOffset: NumberSettingControl;
+    sizeX: NumberSettingControl;
+    sizeY: NumberSettingControl;
+    backgroundColor: ColorSettingsControl;
 };
 /**
- * Configuration interface for the {@link SimpleGrid}.
+ * Configuration interface for the {@link MiniMap}.
  */
-export interface SimpleGridConfig {
+export interface MiniMapConfig {
     /**
-     * Whether the grid is visible or not.
+     * Whether the minimap is visible or not.
      */
     visible: boolean;
     /**
-     * The color of the grid lines.
+     * Whether to lock the rotation of the top camera in the minimap.
      */
-    color: THREE.Color;
+    lockRotation: boolean;
     /**
-     * The size of the primary grid lines.
+     * The zoom of the camera in the minimap.
      */
-    primarySize: number;
+    zoom: number;
     /**
-     * The size of the secondary grid lines.
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
      */
-    secondarySize: number;
+    frontOffset: number;
     /**
-     * The distance at which the grid lines start to fade away.
+     * The horizontal dimension of the minimap.
      */
-    distance: number;
+    sizeX: number;
+    /**
+     * The vertical dimension of the minimap.
+     */
+    sizeY: number;
+    /**
+     * The color of the background of the minimap.
+     */
+    backgroundColor: THREE.Color;
 }
-export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
-    protected _config: SimpleGridConfigType;
+export declare class MiniMapConfigManager extends Configurator<MiniMap, MiniMapConfigType> {
+    protected _config: MiniMapConfigType;
     /**
-     * Whether the grid is visible or not.
+     * Whether the minimap is visible or not.
      */
     get visible(): boolean;
     /**
-     * Whether the grid is visible or not.
+     * Whether the minimap is visible or not.
      */
     set visible(value: boolean);
     /**
-     * The color of the grid lines.
+     * Whether to lock the rotation of the top camera in the minimap.
      */
-    get color(): THREE.Color;
+    get lockRotation(): boolean;
     /**
-     * The color of the grid lines.
+     * Whether to lock the rotation of the top camera in the minimap.
      */
-    set color(value: THREE.Color);
+    set lockRotation(value: boolean);
     /**
-     * The size of the primary grid lines.
+     * The zoom of the camera in the minimap.
      */
-    get primarySize(): number;
+    get zoom(): number;
     /**
-     * The size of the primary grid lines.
+     * The zoom of the camera in the minimap.
      */
-    set primarySize(value: number);
+    set zoom(value: number);
     /**
-     * The size of the secondary grid lines.
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
      */
-    get secondarySize(): number;
-    /**
-     * The size of the secondary grid lines.
-     */
-    set secondarySize(value: number);
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    get distance(): number;
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    set distance(value: number);
-}
-export {};
-import { ControlsSchema, ControlEntry } from "../../Types";
-import { Components } from "../../Components";
-export declare abstract class Configurator<T, U extends ControlsSchema> {
-    protected abstract _config: U;
-    protected _component: T;
-    name: string;
-    uuid: string;
-    get controls(): U;
-    constructor(component: T, components: Components, name: string, uuid?: string);
-    copyEntry(controlEntry: ControlEntry): ControlEntry;
-}
-import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
-/**
- * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
- *
- * @template T - The type of the scene. Default is BaseScene.
- * @template U - The type of the camera. Default is BaseCamera.
- * @template S - The type of the renderer. Default is BaseRenderer.
- */
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
-    /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
-     */
-    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
-     */
-    isDisposing: boolean;
-    /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
-     */
-    enabled: boolean;
-    /**
-     * A unique identifier for the world. Is not meant to be changed at any moment.
-     */
-    readonly uuid: string;
-    /**
-     * An optional name for the world.
-     */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
-    /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
-     */
-    get scene(): T;
-    /**
-     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
-     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
-     * @param scene - The new scene to be set.
-     */
-    set scene(scene: T);
-    /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
-     */
-    get camera(): U;
-    /**
-     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
-     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
-     * @param camera - The new camera to be set.
-     */
-    set camera(camera: U);
-    /**
-     * Getter for the renderer.
-     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
-     */
-    get renderer(): S | null;
-    /**
-     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
-     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
-     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
-     * @param renderer - The new renderer to be set or null to remove the current renderer.
-     */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
-}
-import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
-import { Components } from "../../Components";
-import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
-/**
- * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
- */
-export declare class SimpleScene extends BaseScene implements Configurable<SimpleSceneConfigManager, SimpleSceneConfig> {
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
-     */
-    three: THREE.Scene;
-    /** {@link Configurable.config} */
-    config: SimpleSceneConfigManager;
-    protected _defaultConfig: SimpleSceneConfig;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
-    dispose(): void;
-}
-import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
- */
-export declare class SimpleRenderer extends BaseRenderer {
-    /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is 'true'.
-     */
-    enabled: boolean;
-    /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
-     */
-    container: HTMLElement;
-    /**
-     * The THREE.js WebGLRenderer instance.
-     */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
-    /**
-     * Constructor for the SimpleRenderer class.
-     *
-     * @param components - The components instance.
-     * @param container - The HTML container where the THREE.js canvas will be rendered.
-     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
-     */
-    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Resizeable.getSize}. */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize: (size?: THREE.Vector2) => void;
+    get frontOffset(): number;
     /**
-     * Sets up and manages the event listeners for the renderer.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
-     *
-     * @throws Will throw an error if the renderer does not have an HTML container.
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
      */
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
-}
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
- */
-export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<SimpleCamera>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<SimpleCamera>;
+    set frontOffset(value: number);
     /**
-     * Event that is triggered when the aspect of the camera has been updated.
-     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
+     * The horizontal dimension of the minimap.
      */
-    readonly onAspectUpdated: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    get sizeX(): number;
     /**
-     * A three.js PerspectiveCamera or OrthographicCamera instance.
-     * This camera is used for rendering the scene.
+     * The horizontal dimension of the minimap.
      */
-    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _allControls;
+    set sizeX(value: number);
     /**
-     * The object that controls the camera. An instance of
-     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
-     * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
+     * The vertical dimension of the minimap.
      */
-    get controls(): CameraControls;
+    get sizeY(): number;
     /**
-     * Getter for the enabled state of the camera controls.
-     * If the current world is null, it returns false.
-     * Otherwise, it returns the enabled state of the camera controls.
-     *
-     * @returns {boolean} The enabled state of the camera controls.
+     * The vertical dimension of the minimap.
      */
-    get enabled(): boolean;
+    set sizeY(value: number);
     /**
-     * Setter for the enabled state of the camera controls.
-     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
-     *
-     * @param {boolean} enabled - The new enabled state of the camera controls.
+     * The color of the background of the minimap.
      */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
+    get backgroundColor(): THREE.Color;
     /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
+     * The color of the background of the minimap.
      */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
+    set backgroundColor(value: THREE.Color);
 }
+export {};
 import * as THREE from "three";
 import { Components } from "../../Components";
 import { AsyncEvent, Configurable, Event, World } from "../../Types";
@@ -3811,6 +3655,7 @@ export declare class CullerRenderer implements Configurable<CullerRendererConfig
     protected increaseColor(): void;
     protected decreaseColor(): void;
 }
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 import * as THREE from "three";
 import { CullerRenderer } from "./culler-renderer";
 import { Components } from "../../Components";
@@ -3871,542 +3716,370 @@ export declare class MeshCullerRenderer extends CullerRenderer implements Dispos
     private getAvailableMaterial;
 }
 import * as THREE from "three";
-import { SimpleScene } from "./simple-scene";
-import { ColorSettingsControl, NumberSettingControl, Vector3SettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-type SimpleSceneConfigType = {
-    backgroundColor: ColorSettingsControl;
-    ambientLight: {
-        color: ColorSettingsControl;
-        intensity: NumberSettingControl;
-    };
-    directionalLight: {
-        color: ColorSettingsControl;
-        intensity: NumberSettingControl;
-        position: Vector3SettingControl;
-    };
-};
-declare class DirectionalLightConfig {
-    private _list;
-    private _scene;
-    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get intensity(): number;
-    set intensity(value: number);
-    get position(): THREE.Vector3;
-    set position(value: THREE.Vector3);
-}
-declare class AmbientLightConfig {
-    private _list;
-    private _scene;
-    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get intensity(): number;
-    set intensity(value: number);
-}
+import { Disposable, Event } from "../../Types";
 /**
- * Configuration interface for the {@link SimpleScene}.
+ * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
  */
-export interface SimpleSceneConfig {
-    backgroundColor: THREE.Color;
-    directionalLight: {
-        color: THREE.Color;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
-}
-export declare class SimpleSceneConfigManager extends Configurator<SimpleScene, SimpleSceneConfigType> {
-    protected _config: SimpleSceneConfigType;
-    ambientLight: AmbientLightConfig;
-    directionalLight: DirectionalLightConfig;
-    get backgroundColor(): THREE.Color;
-    set backgroundColor(value: THREE.Color);
+export declare class Mouse implements Disposable {
+    dom: HTMLCanvasElement;
+    private _event?;
+    private _position;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    constructor(dom: HTMLCanvasElement);
+    /**
+     * The real position of the mouse of the Three.js canvas.
+     */
+    get position(): THREE.Vector2;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private getPositionY;
+    private getPositionX;
+    private updateMouseInfo;
+    private getDataObject;
+    private setupEvents;
 }
-export {};
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 import * as THREE from "three";
-import { Resizeable, Updateable, World, Event, Disposable, Configurable } from "../../Types";
-import { MiniMapConfig, MiniMapConfigManager } from "./mini-map-config";
 import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+import { Mouse } from "./mouse";
 /**
- * A class representing a 2D minimap of a 3D world.
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
  */
-export declare class MiniMap implements Resizeable, Updateable, Disposable, Configurable<MiniMapConfigManager, MiniMapConfig> {
+export declare class SimpleRaycaster implements Disposable {
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** The components instance to which this Raycaster belongs. */
+    components: Components;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
+    /** The position of the mouse in the screen. */
+    readonly mouse: Mouse;
     /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
      */
-    frontOffset: number;
+    readonly three: THREE.Raycaster;
     /**
-     * The override material for the minimap.
-     * It is used to render the depth information of the world onto the minimap.
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
      */
-    overrideMaterial: THREE.MeshDepthMaterial;
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * The background color of the minimap.
-     * It is used to set the background color of the minimap's renderer.
+     * Throws a ray from the camera to the mouse or touch event point and returns
+     * the first item found. This also takes into account the clipping planes
+     * used by the renderer.
+     *
+     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
+     * to query. If not provided, it will query all the meshes stored in
+     * {@link Components.meshes}.
      */
-    backgroundColor: THREE.Color;
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
     /**
-     * The WebGL renderer for the minimap.
-     * It is used to render the minimap onto the screen.
+     * Casts a ray from a given origin in a given direction and returns the first item found.
+     * This method also takes into account the clipping planes used by the renderer.
+     *
+     * @param origin - The origin of the ray.
+     * @param direction - The direction of the ray.
+     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
+     * @returns The first intersection found or 'null' if no intersection was found.
      */
-    renderer: THREE.WebGLRenderer;
+    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    private intersect;
+    private filterClippingPlanes;
+}
+import * as THREE from "three";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+/**
+ * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
+ *
+ * @template T - The type of the scene. Default is BaseScene.
+ * @template U - The type of the camera. Default is BaseCamera.
+ * @template S - The type of the renderer. Default is BaseRenderer.
+ */
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
     /**
-     * A flag indicating whether the minimap is enabled.
-     * If disabled, the minimap will not update or render.
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
      */
-    enabled: boolean;
+    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * The world in which the minimap is displayed.
-     * It provides access to the 3D scene, camera, and other relevant world elements.
+     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
      */
-    world: World;
-    /** {@link Configurable.config} */
-    config: MiniMapConfigManager;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    protected _defaultConfig: MiniMapConfig;
-    private _lockRotation;
-    private _size;
-    private _camera;
-    private _plane;
-    private _tempVector1;
-    private _tempVector2;
-    private _tempTarget;
-    private readonly down;
+    isDisposing: boolean;
     /**
-     * Gets or sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
+     * Indicates whether the world is currently enabled.
+     * When disabled, the world will not be updated.
      */
-    get lockRotation(): boolean;
+    enabled: boolean;
     /**
-     * Sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     * @param active - If 'true', rotation is locked. If 'false', rotation is not locked.
+     * A unique identifier for the world. Is not meant to be changed at any moment.
      */
-    set lockRotation(active: boolean);
+    readonly uuid: string;
     /**
-     * Gets the current zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @returns The current zoom level of the minimap.
+     * An optional name for the world.
      */
-    get zoom(): number;
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
     /**
-     * Sets the zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @param value - The new zoom level of the minimap.
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
      */
-    set zoom(value: number);
-    constructor(world: World, components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** Returns the camera used by the MiniMap */
-    get(): THREE.OrthographicCamera;
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Resizeable.getSize} */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize(size?: THREE.Vector2): void;
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<MiniMapConfig>): void;
-    private updatePlanes;
-}
-import * as THREE from "three";
-import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-import { MiniMap } from "./index";
-type MiniMapConfigType = {
-    visible: BooleanSettingsControl;
-    lockRotation: BooleanSettingsControl;
-    zoom: NumberSettingControl;
-    frontOffset: NumberSettingControl;
-    sizeX: NumberSettingControl;
-    sizeY: NumberSettingControl;
-    backgroundColor: ColorSettingsControl;
-};
-/**
- * Configuration interface for the {@link MiniMap}.
- */
-export interface MiniMapConfig {
+    get scene(): T;
     /**
-     * Whether the minimap is visible or not.
+     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
+     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
+     * @param scene - The new scene to be set.
      */
-    visible: boolean;
+    set scene(scene: T);
     /**
-     * Whether to lock the rotation of the top camera in the minimap.
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
      */
-    lockRotation: boolean;
+    get camera(): U;
     /**
-     * The zoom of the camera in the minimap.
+     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
+     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
+     * @param camera - The new camera to be set.
      */
-    zoom: number;
+    set camera(camera: U);
     /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     * Getter for the renderer.
+     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
      */
-    frontOffset: number;
+    get renderer(): S | null;
     /**
-     * The horizontal dimension of the minimap.
-     */
-    sizeX: number;
-    /**
-     * The vertical dimension of the minimap.
-     */
-    sizeY: number;
-    /**
-     * The color of the background of the minimap.
+     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
+     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
+     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
+     * @param renderer - The new renderer to be set or null to remove the current renderer.
      */
-    backgroundColor: THREE.Color;
+    set renderer(renderer: S | null);
+    /** {@link Updateable.update} */
+    update(delta?: number): void;
+    /** {@link Disposable.dispose} */
+    dispose(disposeResources?: boolean): void;
 }
-export declare class MiniMapConfigManager extends Configurator<MiniMap, MiniMapConfigType> {
-    protected _config: MiniMapConfigType;
-    /**
-     * Whether the minimap is visible or not.
-     */
-    get visible(): boolean;
-    /**
-     * Whether the minimap is visible or not.
-     */
-    set visible(value: boolean);
-    /**
-     * Whether to lock the rotation of the top camera in the minimap.
-     */
-    get lockRotation(): boolean;
-    /**
-     * Whether to lock the rotation of the top camera in the minimap.
-     */
-    set lockRotation(value: boolean);
-    /**
-     * The zoom of the camera in the minimap.
-     */
-    get zoom(): number;
-    /**
-     * The zoom of the camera in the minimap.
-     */
-    set zoom(value: number);
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    get frontOffset(): number;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    set frontOffset(value: number);
-    /**
-     * The horizontal dimension of the minimap.
-     */
-    get sizeX(): number;
-    /**
-     * The horizontal dimension of the minimap.
-     */
-    set sizeX(value: number);
-    /**
-     * The vertical dimension of the minimap.
-     */
-    get sizeY(): number;
-    /**
-     * The vertical dimension of the minimap.
-     */
-    set sizeY(value: number);
-    /**
-     * The color of the background of the minimap.
-     */
-    get backgroundColor(): THREE.Color;
+import * as THREE from "three";
+import { BaseScene, Configurable, Event } from "../../Types";
+import { Components } from "../../Components";
+import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
+/**
+ * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
+ */
+export declare class SimpleScene extends BaseScene implements Configurable<SimpleSceneConfigManager, SimpleSceneConfig> {
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
     /**
-     * The color of the background of the minimap.
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
      */
-    set backgroundColor(value: THREE.Color);
+    three: THREE.Scene;
+    /** {@link Configurable.config} */
+    config: SimpleSceneConfigManager;
+    protected _defaultConfig: SimpleSceneConfig;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
+    dispose(): void;
 }
-export {};
 import * as THREE from "three";
-import { Event, World } from "../../Types";
+import CameraControls from "camera-controls";
+import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
 import { Components } from "../../Components";
 /**
- * A base renderer to determine visibility on screen.
+ * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
  */
-export declare class DistanceRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onDistanceComputed: Event<number>;
-    /**
-     * Objects that won't be taken into account in the distance check.
-     */
-    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
+export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<SimpleCamera>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<SimpleCamera>;
     /**
-     * Whether this renderer is active or not. If not, it won't render anything.
+     * Event that is triggered when the aspect of the camera has been updated.
+     * This event is useful when you need to perform actions after the aspect of the camera has been changed.
      */
-    enabled: boolean;
+    readonly onAspectUpdated: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
+     * A three.js PerspectiveCamera or OrthographicCamera instance.
+     * This camera is used for rendering the scene.
      */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
+    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    private _allControls;
     /**
-     * The scene where the distance is computed.
+     * The object that controls the camera. An instance of
+     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
+     * Transforming the camera directly will have no effect: you need to use this
+     * object to move, rotate, look at objects, etc.
      */
-    scene: THREE.Scene;
+    get controls(): CameraControls;
     /**
-     * The camera used to compute the distance.
+     * Getter for the enabled state of the camera controls.
+     * If the current world is null, it returns false.
+     * Otherwise, it returns the enabled state of the camera controls.
+     *
+     * @returns {boolean} The enabled state of the camera controls.
      */
-    camera: THREE.OrthographicCamera;
+    get enabled(): boolean;
     /**
-     * The material used to compute the distance.
+     * Setter for the enabled state of the camera controls.
+     * If the current world is not null, it sets the enabled state of the camera controls to the provided value.
+     *
+     * @param {boolean} enabled - The new enabled state of the camera controls.
      */
-    depthMaterial: THREE.ShaderMaterial;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected readonly worker: Worker;
-    private _width;
-    private _height;
-    private readonly _postQuad;
-    private readonly tempRT;
-    private readonly resultRT;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World);
+    set enabled(enabled: boolean);
+    constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
     /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
      */
-    compute: () => Promise<void>;
-    private handleWorkerMessage;
-}
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: OrthoPerspectiveCamera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
-}
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
- */
-export declare class FirstPersonMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "FirstPerson";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
- */
-export declare class PlanMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Plan";
-    private mouseAction1?;
-    private mouseAction2?;
-    private mouseInitialized;
-    private readonly defaultAzimuthSpeed;
-    private readonly defaultPolarSpeed;
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
+import { ControlsSchema, ControlEntry } from "../../Types";
+import { Components } from "../../Components";
+export declare abstract class Configurator<T, U extends ControlsSchema> {
+    protected abstract _config: U;
+    protected _component: T;
+    name: string;
+    uuid: string;
+    get controls(): U;
+    constructor(component: T, components: Components, name: string, uuid?: string);
+    copyEntry(controlEntry: ControlEntry): ControlEntry;
 }
 import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
- */
-export declare class ProjectionManager {
-    /**
-     * Event that fires when the {@link CameraProjection} changes.
-     */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
-    /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
-     */
-    current: CameraProjection;
-    /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
-     */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
-    /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
-     *
-     * @param projection - the new projection to set. If it is the current projection,
-     * it will have no effect.
-     */
-    set(projection: CameraProjection): Promise<void>;
-    /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
-     */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
-}
-/**
- * The projection system of the camera.
- */
-export type CameraProjection = "Perspective" | "Orthographic";
-/**
- * The extensible list of supported navigation modes.
- */
-export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
-/**
- * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
- */
-export interface NavigationMode {
-    /** The unique ID of this navigation mode. */
-    id: NavModeID;
-    /**
-     * Enable or disable this navigation mode.
-     * When a new navigation mode is enabled, the previous navigation mode
-     * must be disabled.
-     *
-     * @param active - whether to enable or disable this mode.
-     * @param options - any additional data required to enable or disable it.
-     * */
-    set: (active: boolean, options?: any) => void;
-    /** Whether this navigation mode is active or not. */
-    enabled: boolean;
+import { SimpleScene } from "./simple-scene";
+import { ColorSettingsControl, NumberSettingControl, Vector3SettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+type SimpleSceneConfigType = {
+    backgroundColor: ColorSettingsControl;
+    ambientLight: {
+        color: ColorSettingsControl;
+        intensity: NumberSettingControl;
+    };
+    directionalLight: {
+        color: ColorSettingsControl;
+        intensity: NumberSettingControl;
+        position: Vector3SettingControl;
+    };
+};
+declare class DirectionalLightConfig {
+    private _list;
+    private _scene;
+    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get intensity(): number;
+    set intensity(value: number);
+    get position(): THREE.Vector3;
+    set position(value: THREE.Vector3);
+}
+declare class AmbientLightConfig {
+    private _list;
+    private _scene;
+    constructor(list: SimpleSceneConfigType, scene: SimpleScene);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get intensity(): number;
+    set intensity(value: number);
 }
-import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
 /**
- * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
+ * Configuration interface for the {@link SimpleScene}.
  */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
-    /**
-     * The real position of the mouse of the Three.js canvas.
-     */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private getDataObject;
-    private setupEvents;
+export interface SimpleSceneConfig {
+    backgroundColor: THREE.Color;
+    directionalLight: {
+        color: THREE.Color;
+        intensity: number;
+        position: THREE.Vector3;
+    };
+    ambientLight: {
+        color: THREE.Color;
+        intensity: number;
+    };
+}
+export declare class SimpleSceneConfigManager extends Configurator<SimpleScene, SimpleSceneConfigType> {
+    protected _config: SimpleSceneConfigType;
+    ambientLight: AmbientLightConfig;
+    directionalLight: DirectionalLightConfig;
+    get backgroundColor(): THREE.Color;
+    set backgroundColor(value: THREE.Color);
 }
+export {};
 import * as THREE from "three";
+import { BaseRenderer, Event } from "../../Types";
 import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
 /**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
  */
-export declare class SimpleRaycaster implements Disposable {
-    /** {@link Component.enabled} */
+export declare class SimpleRenderer extends BaseRenderer {
+    /**
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
+     */
     enabled: boolean;
-    /** The components instance to which this Raycaster belongs. */
-    components: Components;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
     /**
-     * A reference to the Three.js Raycaster instance.
-     * This is used for raycasting operations.
+     * The HTML container of the THREE.js canvas where the scene is rendered.
      */
-    readonly three: THREE.Raycaster;
+    container: HTMLElement;
     /**
-     * A reference to the world instance to which this Raycaster belongs.
-     * This is used to access the camera and meshes.
+     * The THREE.js WebGLRenderer instance.
      */
-    world: World;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
     /**
-     * Throws a ray from the camera to the mouse or touch event point and returns
-     * the first item found. This also takes into account the clipping planes
-     * used by the renderer.
+     * Constructor for the SimpleRenderer class.
      *
-     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
-     * to query. If not provided, it will query all the meshes stored in
-     * {@link Components.meshes}.
+     * @param components - The components instance.
+     * @param container - The HTML container where the THREE.js canvas will be rendered.
+     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
      */
-    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Resizeable.getSize}. */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize: (size?: THREE.Vector2) => void;
     /**
-     * Casts a ray from a given origin in a given direction and returns the first item found.
-     * This method also takes into account the clipping planes used by the renderer.
+     * Sets up and manages the event listeners for the renderer.
      *
-     * @param origin - The origin of the ray.
-     * @param direction - The direction of the ray.
-     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
-     * @returns The first intersection found or 'null' if no intersection was found.
+     * @param active - A boolean indicating whether to activate or deactivate the event listeners.
+     *
+     * @throws Will throw an error if the renderer does not have an HTML container.
      */
-    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
-    private intersect;
-    private filterClippingPlanes;
+    setupEvents(active: boolean): void;
+    private resizeEvent;
+    private setupRenderer;
+    private onContextLost;
+    private onContextBack;
 }
 import { SimplePlane } from "../../Clipper";
 import { DataSet } from "../../Types";
@@ -4581,65 +4254,193 @@ export declare class Viewpoint implements BCFViewpoint {
      *
      * @returns The viewpoint instance with the updated properties.
      */
-    set(data: Partial<BCFViewpoint>): this;
+    set(data: Partial<BCFViewpoint>): this;
+    /**
+     * Sets the viewpoint of the camera in the world.
+     *
+     * @remarks
+     * This function calculates the target position based on the viewpoint information.
+     * It sets the visibility of the viewpoint components and then applies the viewpoint using the camera's controls.
+     *
+     * @param transition - Indicates whether the camera movement should have a transition effect.
+     *                      Default value is 'true'.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     *
+     * @returns A Promise that resolves when the camera has been set.
+     */
+    go(transition?: boolean): Promise<void>;
+    /**
+     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
+     *
+     * @remarks
+     * This function retrieves the camera's position, direction, and aspect ratio from the world's camera and renderer.
+     * It then calculates the camera's perspective or orthographic settings based on the camera type.
+     * Finally, it updates the viewpoint's camera settings and updates the viewpoint to the Viewpoints manager.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     * @throws An error if the world's renderer is not available.
+     */
+    updateCamera(): void;
+    applyVisibility(): void;
+    /**
+     * Applies color to the components in the viewpoint based on their GUIDs.
+     *
+     * This function iterates through the 'componentColors' map, retrieves the fragment IDs
+     * corresponding to each color, and then uses the 'Classifier' to apply the color to those fragments.
+     *
+     * @remarks
+     * The color is applied using the 'Classifier.setColor' method, which sets the color of the specified fragments.
+     * The color is provided as a hexadecimal string, prefixed with a '#'.
+     */
+    applyColors(): void;
+    /**
+     * Resets the colors of all components in the viewpoint to their original color.
+     */
+    resetColors(): void;
+    private createComponentTags;
+    private createColorTags;
+    /**
+     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
+     *
+     * @param version - The version of the BCF Manager to use for serialization.
+     *                   If not provided, the current version of the manager will be used.
+     *
+     * @returns A Promise that resolves to an XML string representing the viewpoint.
+     *          The XML string follows the BCF VisualizationInfo schema.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     * @throws An error if the world's renderer is not available.
+     */
+    serialize(version?: string): Promise<string>;
+}
+import * as THREE from "three";
+import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+import { SimpleGrid } from "./simple-grid";
+type SimpleGridConfigType = {
+    visible: BooleanSettingsControl;
+    color: ColorSettingsControl;
+    primarySize: NumberSettingControl;
+    secondarySize: NumberSettingControl;
+    distance: NumberSettingControl;
+};
+/**
+ * Configuration interface for the {@link SimpleGrid}.
+ */
+export interface SimpleGridConfig {
+    /**
+     * Whether the grid is visible or not.
+     */
+    visible: boolean;
+    /**
+     * The color of the grid lines.
+     */
+    color: THREE.Color;
+    /**
+     * The size of the primary grid lines.
+     */
+    primarySize: number;
+    /**
+     * The size of the secondary grid lines.
+     */
+    secondarySize: number;
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
+    distance: number;
+}
+export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
+    protected _config: SimpleGridConfigType;
+    /**
+     * Whether the grid is visible or not.
+     */
+    get visible(): boolean;
+    /**
+     * Whether the grid is visible or not.
+     */
+    set visible(value: boolean);
+    /**
+     * The color of the grid lines.
+     */
+    get color(): THREE.Color;
+    /**
+     * The color of the grid lines.
+     */
+    set color(value: THREE.Color);
+    /**
+     * The size of the primary grid lines.
+     */
+    get primarySize(): number;
+    /**
+     * The size of the primary grid lines.
+     */
+    set primarySize(value: number);
     /**
-     * Sets the viewpoint of the camera in the world.
-     *
-     * @remarks
-     * This function calculates the target position based on the viewpoint information.
-     * It sets the visibility of the viewpoint components and then applies the viewpoint using the camera's controls.
-     *
-     * @param transition - Indicates whether the camera movement should have a transition effect.
-     *                      Default value is 'true'.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     *
-     * @returns A Promise that resolves when the camera has been set.
+     * The size of the secondary grid lines.
      */
-    go(transition?: boolean): Promise<void>;
+    get secondarySize(): number;
     /**
-     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
-     *
-     * @remarks
-     * This function retrieves the camera's position, direction, and aspect ratio from the world's camera and renderer.
-     * It then calculates the camera's perspective or orthographic settings based on the camera type.
-     * Finally, it updates the viewpoint's camera settings and updates the viewpoint to the Viewpoints manager.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
+     * The size of the secondary grid lines.
      */
-    updateCamera(): void;
-    applyVisibility(): void;
+    set secondarySize(value: number);
     /**
-     * Applies color to the components in the viewpoint based on their GUIDs.
-     *
-     * This function iterates through the 'componentColors' map, retrieves the fragment IDs
-     * corresponding to each color, and then uses the 'Classifier' to apply the color to those fragments.
-     *
-     * @remarks
-     * The color is applied using the 'Classifier.setColor' method, which sets the color of the specified fragments.
-     * The color is provided as a hexadecimal string, prefixed with a '#'.
+     * The distance at which the grid lines start to fade away.
      */
-    applyColors(): void;
+    get distance(): number;
     /**
-     * Resets the colors of all components in the viewpoint to their original color.
+     * The distance at which the grid lines start to fade away.
      */
-    resetColors(): void;
-    private createComponentTags;
-    private createColorTags;
+    set distance(value: number);
+}
+export {};
+import * as THREE from "three";
+import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
+import { Components } from "../../Components";
+import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
+/**
+ * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ */
+export declare class SimpleGrid implements Hideable, Disposable, Configurable<SimpleGridConfigManager, SimpleGridConfig> {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    /** The world instance to which this Raycaster belongs. */
+    world: World;
+    /** The components instance to which this grid belongs. */
+    components: Components;
+    /** {@link Configurable.config} */
+    config: SimpleGridConfigManager;
+    protected _defaultConfig: SimpleGridConfig;
+    /** {@link Hideable.visible} */
+    get visible(): boolean;
+    /** {@link Hideable.visible} */
+    set visible(visible: boolean);
+    /** The material of the grid. */
+    get material(): THREE.ShaderMaterial;
     /**
-     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
-     *
-     * @param version - The version of the BCF Manager to use for serialization.
-     *                   If not provided, the current version of the manager will be used.
-     *
-     * @returns A Promise that resolves to an XML string representing the viewpoint.
-     *          The XML string follows the BCF VisualizationInfo schema.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
      */
-    serialize(version?: string): Promise<string>;
+    get fade(): boolean;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    set fade(active: boolean);
+    /** The Three.js mesh that contains the infinite grid. */
+    readonly three: THREE.Mesh;
+    private _fade;
+    constructor(components: Components, world: World);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleGridConfig>): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private setupEvents;
+    private updateZoom;
 }
 import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
@@ -4740,135 +4541,195 @@ export declare class SimplePlane implements Disposable, Hideable {
     private newHelper;
     private static newPlaneMesh;
 }
-import { IfcFragmentSettings } from "../../IfcLoader/src";
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
 /**
- * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
  */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
-    /**
-     * Amount of properties to be streamed.
-     * Defaults to 100 properties.
-     */
-    propertiesSize: number;
-}
-import * as THREE from "three";
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-export declare class CivilReader {
-    defLineMat: THREE.LineBasicMaterial;
-    read(webIfc: WEBIFC.IfcAPI): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    get(civilItems: any): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    private getCurves;
-}
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+export declare class FirstPersonMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "FirstPerson";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
 }
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createEntityFacets: (components: Components, elements: any) => IDSFacet[];
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createAttributeFacets: (components: Components, elements: any) => IDSFacet[];
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "../facets";
-export declare const createClassificationFacets: (components: Components, elements: any) => IDSFacet[];
-export type IfcVersion = "IFC2X3" | "IFC4" | "IFC4X3_ADD2";
-export type IDSFacetParameterName = "Name" | "PredefinedType" | "Value" | "System" | "URI" | "PropertySet" | "BaseName" | "DataType" | "Value" | "Entity" | "Relation";
-export type IDSSimpleCardinality = "required" | "prohibited";
-export type IDSConditionalCardinaltiy = IDSSimpleCardinality | "optional";
-export type IDSSimpleParameter = string | number | boolean;
-export type IDSEnumerationParameter = string[] | number[] | boolean[];
-export type IDSPatternParameter = string;
-export type IDSBoundsParameter = {
-    min?: number;
-    minInclusive?: boolean;
-    max?: number;
-    maxInclusive?: boolean;
-};
-export type IDSLengthParameter = {
-    min?: number;
-    length?: number;
-    max?: number;
-};
-export interface IDSRestrictionParameter {
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: OrthoPerspectiveCamera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
 }
-export type IDSFacetParameterType = "simple" | "enumeration" | "pattern" | "bounds" | "length";
-export interface IDSFacetParameter {
-    type: IDSFacetParameterType;
-    parameter: IDSSimpleParameter | IDSEnumerationParameter | IDSPatternParameter | IDSBoundsParameter | IDSLengthParameter;
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
+     */
+    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    /**
+     * Current projection mode of the camera.
+     * Default is "Perspective".
+     */
+    current: CameraProjection;
+    /**
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     */
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    private _component;
+    private _previousDistance;
+    constructor(camera: OrthoPerspectiveCamera);
+    /**
+     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     *
+     * @param projection - the new projection to set. If it is the current projection,
+     * it will have no effect.
+     */
+    set(projection: CameraProjection): Promise<void>;
+    /**
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
+     */
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getPerspectiveDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
 }
-export interface IDSCheck {
-    parameter: IDSFacetParameterName;
-    currentValue: string | number | boolean | null;
-    requiredValue: any;
-    pass: boolean;
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
+ */
+export declare class PlanMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Plan";
+    private mouseAction1?;
+    private mouseAction2?;
+    private mouseInitialized;
+    private readonly defaultAzimuthSpeed;
+    private readonly defaultPolarSpeed;
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
 }
 /**
- * Represents the result of a check performed by an IDSFacet test.
+ * The projection system of the camera.
  */
-export interface IDSCheckResult {
-    guid?: string;
-    expressID: number;
-    pass: boolean;
-    checks: IDSCheck[];
-    cardinality: IDSConditionalCardinaltiy;
-}
-export interface IDSInfo {
-    title: string;
-    description?: string;
-    copyright?: string;
-    version?: string;
-    author?: string;
-    date?: Date;
-    purpose?: string;
-    milestone?: string;
-}
-import * as FRAGS from "@thatopen/fragments";
-import { Components } from "../../../core/Components";
-import { DataSet } from "../../../core/Types";
-import { IDSCheckResult, IfcVersion } from "./types";
-import { IDSFacet } from "./facets";
+export type CameraProjection = "Perspective" | "Orthographic";
 /**
- * Represents a single specification from the Information Delivery Specification (IDS) standard.
- *
- * @remarks This class provides methods for testing a model against the specification,
- * as well as serializing the specification into XML format.
+ * The extensible list of supported navigation modes.
  */
-export declare class IDSSpecification {
-    name: string;
-    ifcVersion: Set<IfcVersion>;
-    identifier: string;
-    description?: string;
-    instructions?: string;
-    requirementsDescription?: string;
-    applicability: DataSet<IDSFacet>;
-    requirements: DataSet<IDSFacet>;
-    protected components: Components;
-    constructor(components: Components, name: string, ifcVersion: IfcVersion[]);
+export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
+/**
+ * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ */
+export interface NavigationMode {
+    /** The unique ID of this navigation mode. */
+    id: NavModeID;
     /**
-     * Tests the model to test against the specification's requirements.
+     * Enable or disable this navigation mode.
+     * When a new navigation mode is enabled, the previous navigation mode
+     * must be disabled.
      *
-     * @param model - The model to be tested.
-     * @returns An array representing the test results.
-     * If no requirements are defined for the specification, an empty array is returned.
+     * @param active - whether to enable or disable this mode.
+     * @param options - any additional data required to enable or disable it.
+     * */
+    set: (active: boolean, options?: any) => void;
+    /** Whether this navigation mode is active or not. */
+    enabled: boolean;
+}
+import * as THREE from "three";
+import { Event, World } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class DistanceRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
      */
-    test(model: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
+    readonly onDistanceComputed: Event<number>;
     /**
-     * Serializes the IDSSpecification instance into XML format.
-     *
-     * @remarks This method is not meant to be used directly. It is used by the IDSSpecifications component.
-     *
-     * @returns The XML representation of the IDSSpecification.
+     * Objects that won't be taken into account in the distance check.
      */
-    serialize(): string;
+    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
+    /**
+     * Whether this renderer is active or not. If not, it won't render anything.
+     */
+    enabled: boolean;
+    /**
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
+     */
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /**
+     * The scene where the distance is computed.
+     */
+    scene: THREE.Scene;
+    /**
+     * The camera used to compute the distance.
+     */
+    camera: THREE.OrthographicCamera;
+    /**
+     * The material used to compute the distance.
+     */
+    depthMaterial: THREE.ShaderMaterial;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected readonly worker: Worker;
+    private _width;
+    private _height;
+    private readonly _postQuad;
+    private readonly tempRT;
+    private readonly resultRT;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    compute: () => Promise<void>;
+    private handleWorkerMessage;
 }
 /**
  * A rule for the {@link IfcFinder} to search items based on their category.
@@ -5131,6 +4992,21 @@ export declare class IfcPropertyQuery extends IfcFinderQuery {
 import { IfcRelName } from "./types";
 import { IfcRelation } from "../../IfcRelationsIndexer";
 export declare const ifcRelClassNames: Record<IfcRelation, IfcRelName>;
+import * as THREE from "three";
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+export declare class CivilReader {
+    defLineMat: THREE.LineBasicMaterial;
+    read(webIfc: WEBIFC.IfcAPI): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    get(civilItems: any): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    private getCurves;
+}
 export type IfcRelationNames = [
     "IfcRelAssignsToControl",
     "IfcRelAssignsToGroup",
@@ -5150,6 +5026,25 @@ export type IfcRelationNames = [
 ];
 export type IfcRelName = IfcRelationNames[number];
 import * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+}
+import { IfcFragmentSettings } from "../../IfcLoader/src";
+/**
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ */
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
+     */
+    propertiesSize: number;
+}
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createEntityFacets: (components: Components, elements: any) => IDSFacet[];
+import * as WEBIFC from "web-ifc";
 import * as THREE from "three";
 export declare class Units {
     factor: number;
@@ -5159,114 +5054,102 @@ export declare class Units {
     private getLengthUnits;
     private getScaleMatrix;
 }
-import { IDSFacetParameter } from "../types";
-export declare const getParameterValue: (property: any) => IDSFacetParameter | undefined;
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/**
- * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
- */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
-    /**
-     * Minimum number of geometries to be streamed.
-     * Defaults to 10 geometries.
-     */
-    minGeometrySize: number;
-    /**
-     * Minimum amount of assets to be streamed.
-     * Defaults to 1000 assets.
-     */
-    minAssetsSize: number;
-    /**
-     * Maximum amount of triangles per fragment. Useful for controlling the maximum size of fragment files.
-     */
-    maxTriangles: number | null;
-}
-/**
- * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
- */
-export interface StreamedGeometries {
-    [id: number]: {
-        /** The bounding box of the geometry as a Float32Array. */
-        boundingBox: Float32Array;
-        /** A boolean indicating whether the geometry has holes. */
-        hasHoles: boolean;
-        /** An optional file path for the geometry data. */
-        geometryFile?: string;
-    };
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createAttributeFacets: (components: Components, elements: any) => IDSFacet[];
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "../facets";
+export declare const createClassificationFacets: (components: Components, elements: any) => IDSFacet[];
+export type IfcVersion = "IFC2X3" | "IFC4" | "IFC4X3_ADD2";
+export type IDSFacetParameterName = "Name" | "PredefinedType" | "Value" | "System" | "URI" | "PropertySet" | "BaseName" | "DataType" | "Value" | "Entity" | "Relation";
+export type IDSSimpleCardinality = "required" | "prohibited";
+export type IDSConditionalCardinaltiy = IDSSimpleCardinality | "optional";
+export type IDSSimpleParameter = string | number | boolean;
+export type IDSEnumerationParameter = string[] | number[] | boolean[];
+export type IDSPatternParameter = string;
+export type IDSBoundsParameter = {
+    min?: number;
+    minInclusive?: boolean;
+    max?: number;
+    maxInclusive?: boolean;
+};
+export type IDSLengthParameter = {
+    min?: number;
+    length?: number;
+    max?: number;
+};
+export interface IDSRestrictionParameter {
 }
-/**
- * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
- */
-export interface StreamedAsset {
-    /** The unique identifier of the asset. */
-    id: number;
-    /** An array of geometries associated with the asset. */
-    geometries: {
-        /** The unique identifier of the geometry. */
-        geometryID: number;
-        /** The transformation matrix of the geometry as a number array. */
-        transformation: number[];
-        /** The color of the geometry as a number array. */
-        color: number[];
-    }[];
+export type IDSFacetParameterType = "simple" | "enumeration" | "pattern" | "bounds" | "length";
+export interface IDSFacetParameter {
+    type: IDSFacetParameterType;
+    parameter: IDSSimpleParameter | IDSEnumerationParameter | IDSPatternParameter | IDSBoundsParameter | IDSLengthParameter;
 }
-import * as WEBIFC from "web-ifc";
-export type RelationsMap = Map<number, Map<number, number[]>>;
-export interface ModelsRelationMap {
-    [modelID: string]: RelationsMap;
+export interface IDSCheck {
+    parameter: IDSFacetParameterName;
+    currentValue: string | number | boolean | null;
+    requiredValue: any;
+    pass: boolean;
 }
 /**
- * Type alias for an array of inverse attribute names.
+ * Represents the result of a check performed by an IDSFacet test.
  */
-export type InverseAttributes = [
-    "IsDecomposedBy",
-    "Decomposes",
-    "AssociatedTo",
-    "HasAssociations",
-    "ClassificationForObjects",
-    "IsGroupedBy",
-    "HasAssignments",
-    "IsDefinedBy",
-    "DefinesOcurrence",
-    "IsTypedBy",
-    "Types",
-    "Defines",
-    "ContainedInStructure",
-    "ContainsElements",
-    "HasControlElements",
-    "AssignedToFlowElement",
-    "ConnectedTo",
-    "ConnectedFrom",
-    "ReferencedBy",
-    "Declares",
-    "HasContext",
-    "Controls",
-    "IsNestedBy",
-    "Nests",
-    "DocumentRefForObjects"
-];
-export type InverseAttribute = InverseAttributes[number];
+export interface IDSCheckResult {
+    guid?: string;
+    expressID: number;
+    pass: boolean;
+    checks: IDSCheck[];
+    cardinality: IDSConditionalCardinaltiy;
+}
+export interface IDSInfo {
+    title: string;
+    description?: string;
+    copyright?: string;
+    version?: string;
+    author?: string;
+    date?: Date;
+    purpose?: string;
+    milestone?: string;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { Components } from "../../../core/Components";
+import { DataSet } from "../../../core/Types";
+import { IDSCheckResult, IfcVersion } from "./types";
+import { IDSFacet } from "./facets";
 /**
- * Type alias for an array of IfcRelation types from WebIfc.
+ * Represents a single specification from the Information Delivery Specification (IDS) standard.
+ *
+ * @remarks This class provides methods for testing a model against the specification,
+ * as well as serializing the specification into XML format.
  */
-export type IfcRelations = [
-    typeof WEBIFC.IFCRELAGGREGATES,
-    typeof WEBIFC.IFCRELASSOCIATESMATERIAL,
-    typeof WEBIFC.IFCRELASSOCIATESCLASSIFICATION,
-    typeof WEBIFC.IFCRELASSIGNSTOGROUP,
-    typeof WEBIFC.IFCRELDEFINESBYPROPERTIES,
-    typeof WEBIFC.IFCRELDEFINESBYTYPE,
-    typeof WEBIFC.IFCRELDEFINESBYTEMPLATE,
-    typeof WEBIFC.IFCRELCONTAINEDINSPATIALSTRUCTURE,
-    typeof WEBIFC.IFCRELFLOWCONTROLELEMENTS,
-    typeof WEBIFC.IFCRELCONNECTSELEMENTS,
-    typeof WEBIFC.IFCRELASSIGNSTOPRODUCT,
-    typeof WEBIFC.IFCRELDECLARES,
-    typeof WEBIFC.IFCRELASSIGNSTOCONTROL,
-    typeof WEBIFC.IFCRELNESTS,
-    typeof WEBIFC.IFCRELASSOCIATESDOCUMENT
-];
-export type IfcRelation = IfcRelations[number];
+export declare class IDSSpecification {
+    name: string;
+    ifcVersion: Set<IfcVersion>;
+    identifier: string;
+    description?: string;
+    instructions?: string;
+    requirementsDescription?: string;
+    applicability: DataSet<IDSFacet>;
+    requirements: DataSet<IDSFacet>;
+    protected components: Components;
+    constructor(components: Components, name: string, ifcVersion: IfcVersion[]);
+    /**
+     * Tests the model to test against the specification's requirements.
+     *
+     * @param model - The model to be tested.
+     * @returns An array representing the test results.
+     * If no requirements are defined for the specification, an empty array is returned.
+     */
+    test(model: FRAGS.FragmentsGroup): Promise<IDSCheckResult[]>;
+    /**
+     * Serializes the IDSSpecification instance into XML format.
+     *
+     * @remarks This method is not meant to be used directly. It is used by the IDSSpecifications component.
+     *
+     * @returns The XML representation of the IDSSpecification.
+     */
+    serialize(): string;
+}
 import { Components } from "../../../core/Components";
 import { Viewpoint } from "../../../core/Viewpoints";
 import { Comment } from "./Comment";
@@ -5571,17 +5454,81 @@ export declare class BCFTopicsConfigManager extends Configurator<BCFTopics, BCFT
     set ignoreIncompleteTopicsOnImport(value: boolean);
 }
 export {};
-import * as FRAGS from "@thatopen/fragments";
-import { IDSCheckResult, IDSFacetParameter } from "../types";
-import { Components } from "../../../../core/Components";
-import { IDSFacet } from "./Facet";
-export declare class IDSAttribute extends IDSFacet {
-    name: IDSFacetParameter;
-    value?: IDSFacetParameter;
-    constructor(components: Components, name: IDSFacetParameter);
-    serialize(type: "applicability" | "requirement"): string;
-    getEntities(): Promise<never[]>;
-    test(entities: FRAGS.IfcProperties): Promise<IDSCheckResult[]>;
+import { IDSFacetParameter } from "../types";
+export declare const getParameterValue: (property: any) => IDSFacetParameter | undefined;
+import * as WEBIFC from "web-ifc";
+export type RelationsMap = Map<number, Map<number, number[]>>;
+export interface ModelsRelationMap {
+    [modelID: string]: RelationsMap;
+}
+/**
+ * Type alias for an array of inverse attribute names.
+ */
+export type InverseAttributes = [
+    "IsDecomposedBy",
+    "Decomposes",
+    "AssociatedTo",
+    "HasAssociations",
+    "ClassificationForObjects",
+    "IsGroupedBy",
+    "HasAssignments",
+    "IsDefinedBy",
+    "DefinesOcurrence",
+    "IsTypedBy",
+    "Types",
+    "Defines",
+    "ContainedInStructure",
+    "ContainsElements",
+    "HasControlElements",
+    "AssignedToFlowElement",
+    "ConnectedTo",
+    "ConnectedFrom",
+    "ReferencedBy",
+    "Declares",
+    "HasContext",
+    "Controls",
+    "IsNestedBy",
+    "Nests",
+    "DocumentRefForObjects"
+];
+export type InverseAttribute = InverseAttributes[number];
+/**
+ * Type alias for an array of IfcRelation types from WebIfc.
+ */
+export type IfcRelations = [
+    typeof WEBIFC.IFCRELAGGREGATES,
+    typeof WEBIFC.IFCRELASSOCIATESMATERIAL,
+    typeof WEBIFC.IFCRELASSOCIATESCLASSIFICATION,
+    typeof WEBIFC.IFCRELASSIGNSTOGROUP,
+    typeof WEBIFC.IFCRELDEFINESBYPROPERTIES,
+    typeof WEBIFC.IFCRELDEFINESBYTYPE,
+    typeof WEBIFC.IFCRELDEFINESBYTEMPLATE,
+    typeof WEBIFC.IFCRELCONTAINEDINSPATIALSTRUCTURE,
+    typeof WEBIFC.IFCRELFLOWCONTROLELEMENTS,
+    typeof WEBIFC.IFCRELCONNECTSELEMENTS,
+    typeof WEBIFC.IFCRELASSIGNSTOPRODUCT,
+    typeof WEBIFC.IFCRELDECLARES,
+    typeof WEBIFC.IFCRELASSIGNSTOCONTROL,
+    typeof WEBIFC.IFCRELNESTS,
+    typeof WEBIFC.IFCRELASSOCIATESDOCUMENT
+];
+export type IfcRelation = IfcRelations[number];
+export interface RelationsProcessingConfig {
+    relationsToProcess: IfcRelation[];
+}
+/**
+ * Interface definition of an Entities Related Event from the IfcRelationsIndexer.
+ * This event gets triggered when two or more entities has been related with each other.
+ */
+export interface EntitiesRelatedEvent {
+    /** The type of the IFC relation. */
+    relType: IfcRelation;
+    /** The inverse attribute of the relation. */
+    invAttribute: InverseAttribute;
+    /** The IDs of the entities that are relating. */
+    relatingIDs: number[];
+    /** The IDs of the entities that are being related. */
+    relatedIDs: number[];
 }
 import { BooleanSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
@@ -5657,6 +5604,67 @@ export declare class CullerRendererConfigManager extends Configurator<CullerRend
     private resetInterval;
 }
 export {};
+import { IfcFragmentSettings } from "../../IfcLoader/src";
+/**
+ * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
+ */
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Minimum number of geometries to be streamed.
+     * Defaults to 10 geometries.
+     */
+    minGeometrySize: number;
+    /**
+     * Minimum amount of assets to be streamed.
+     * Defaults to 1000 assets.
+     */
+    minAssetsSize: number;
+    /**
+     * Maximum amount of triangles per fragment. Useful for controlling the maximum size of fragment files.
+     */
+    maxTriangles: number | null;
+}
+/**
+ * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
+ */
+export interface StreamedGeometries {
+    [id: number]: {
+        /** The bounding box of the geometry as a Float32Array. */
+        boundingBox: Float32Array;
+        /** A boolean indicating whether the geometry has holes. */
+        hasHoles: boolean;
+        /** An optional file path for the geometry data. */
+        geometryFile?: string;
+    };
+}
+/**
+ * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
+ */
+export interface StreamedAsset {
+    /** The unique identifier of the asset. */
+    id: number;
+    /** An array of geometries associated with the asset. */
+    geometries: {
+        /** The unique identifier of the geometry. */
+        geometryID: number;
+        /** The transformation matrix of the geometry as a number array. */
+        transformation: number[];
+        /** The color of the geometry as a number array. */
+        color: number[];
+    }[];
+}
+import * as FRAGS from "@thatopen/fragments";
+import { IDSCheckResult, IDSFacetParameter } from "../types";
+import { Components } from "../../../../core/Components";
+import { IDSFacet } from "./Facet";
+export declare class IDSAttribute extends IDSFacet {
+    name: IDSFacetParameter;
+    value?: IDSFacetParameter;
+    constructor(components: Components, name: IDSFacetParameter);
+    serialize(type: "applicability" | "requirement"): string;
+    getEntities(): Promise<never[]>;
+    test(entities: FRAGS.IfcProperties): Promise<IDSCheckResult[]>;
+}
 import * as FRAGS from "@thatopen/fragments";
 import { Components } from "../../../../core/Components";
 import { IDSCheckResult, IDSFacetParameter } from "../types";
@@ -5747,6 +5755,59 @@ import * as THREE from "three";
 export declare class TransformHelper {
     getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
 }
+declare const actual: {
+    186: {
+        7: number[];
+    };
+    250: {
+        8: number[];
+    };
+    253: {
+        8: number[];
+    };
+    257: {
+        8: number[];
+    };
+};
+declare const newVersion: {
+    186: {
+        7: ({
+            259: number[];
+            263?: undefined;
+            266?: undefined;
+        } | {
+            263: number[];
+            259?: undefined;
+            266?: undefined;
+        } | {
+            266: number[];
+            259?: undefined;
+            263?: undefined;
+        })[];
+    };
+    190: {
+        7: {
+            259: number[];
+        }[];
+    };
+    250: {
+        8: {
+            259: number[];
+        }[];
+    };
+};
+interface V2Schema {
+    [expressID: number]: {
+        [invAttrIndex: number]: {
+            [IfcRelationship: number]: number[];
+        };
+    };
+}
+type RelationsMap = Map<number, Map<number, {
+    [ifcRel: number]: number[];
+}>>;
+import { IDSFacetParameterName, IDSFacetParameter } from "../types";
+export declare const getParameterXML: (name: IDSFacetParameterName, parameter?: IDSFacetParameter) => string;
 import { IDSFacetParameter } from "../types";
 import { IDSFacet } from "./Facet";
 export declare class IdsMaterialFacet extends IDSFacet {
@@ -5756,8 +5817,6 @@ export declare class IdsMaterialFacet extends IDSFacet {
     getEntities(): Promise<number[]>;
     test(): Promise<import("../types").IDSCheckResult[]>;
 }
-import { IDSFacetParameterName, IDSFacetParameter } from "../types";
-export declare const getParameterXML: (name: IDSFacetParameterName, parameter?: IDSFacetParameter) => string;
 import * as FRAGS from "@thatopen/fragments";
 import { Components } from "../../../../core/Components";
 import { IDSFacet } from "./Facet";