@thatopen/components 2.0.8 → 2.0.10

package/dist/namespace.d.ts

@@ -1,273 +1,104 @@
 declare namespace OBC {
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
+import * as THREE from "three";
+import { Components } from "../Components";
+import { Component } from "../Types";
 /**
- * Indexer 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.
+ * A tool to safely remove meshes and geometries from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
  */
-export declare class IfcRelationsIndexer extends Component implements Disposable {
-    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+export declare class Disposer extends Component {
+    private _disposedComponents;
+    /** {@link Component.enabled} */
     enabled: boolean;
-    readonly onRelationsIndexed: Event<{
-        modelID: string;
-        relationsMap: RelationsMap;
-    }>;
-    private _relToAttributesMap;
-    private _inverseAttributes;
-    private _ifcRels;
     /**
-     * Holds the relationship mappings for each model processed by the indexer.
-     * The structure is a map where each key is a model's UUID, and the value is another map.
-     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
-     * representing a specific relation type, and the value is an array of expressIDs of entities
-     * that are related through that relation type. This structure allows for efficient querying
-     * of entity relationships within a model.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    readonly relationMaps: ModelsRelationMap;
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
     constructor(components: Components);
-    private onFragmentsDisposed;
-    /**
-     * Adds a relation map to the model's relations map.
-     *
-     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
-     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
-     *
-     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
-     */
-    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
-    /**
-     * Processes a given model to index its IFC entities relations based on predefined inverse attributes.
-     * This method iterates through each specified inverse attribute, retrieves the corresponding relations,
-     * and maps them in a structured way to facilitate quick access to related entities.
-     *
-     * The process involves querying the model for each relation type associated with the inverse attributes
-     * and updating the internal relationMaps with the relationships found. This map is keyed by the model's UUID
-     * and contains a nested map where each key is an entity's expressID and its value is another map.
-     * This inner map's keys are the indices of the inverse attributes, and its values are arrays of expressIDs
-     * of entities that are related through that attribute.
-     *
-     * @param model The 'FragmentsGroup' model to be processed. It must have properties loaded.
-     * @returns A promise that resolves to the relations map for the processed model. This map is a detailed
-     * 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>;
-    /**
-     * Processes a given model from a WebIfc API to index its IFC entities relations.
-     *
-     * @param ifcApi - The WebIfc API instance from which to retrieve the model's properties.
-     * @param modelID - The unique identifier of the model within the WebIfc API.
-     * @returns A promise that resolves to the relations map for the processed model.
-     *          This map is a detailed representation of the relations indexed by entity expressIDs and relation types.
-     */
-    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
     /**
-     * Retrieves the relations of a specific entity within a model based on the given relation name.
-     * This method searches the indexed relation maps for the specified model and entity,
-     * returning the IDs of related entities if a match is found.
-     *
-     * @param model The 'FragmentsGroup' model containing the entity.
-     * @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.
+     * Return the UUIDs of all disposed components.
      */
-    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute): number[] | null;
+    get(): Set<string>;
     /**
-     * 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,
-     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
-     * The resulting object is then serialized into a JSON string.
+     * Removes a mesh, its geometry and its materials from memory. If you are
+     * using any of these in other parts of the application, make sure that you
+     * remove them from the mesh before disposing it.
      *
-     * @param relationMap - The map of relations to be serialized. The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
-     * @returns A JSON string representing the serialized relations of the given relation map.
-     */
-    serializeRelations(relationMap: RelationsMap): string;
-    /**
-     * Serializes the relations of a specific model into a JSON string.
-     * This method iterates through the relations indexed for the given model,
-     * organizing them into a structured object where each key is an expressID of an entity,
-     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
-     * The resulting object is then serialized into a JSON string.
+     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
+     * to remove.
      *
-     * @param model The 'FragmentsGroup' model whose relations are to be serialized.
-     * @returns A JSON string representing the serialized relations of the specified model.
-     * If the model has no indexed relations, 'null' is returned.
-     */
-    serializeModelRelations(model: FragmentsGroup): string | null;
-    /**
-     * Serializes all relations of every model processed by the indexer into a JSON string.
-     * This method iterates through each model's relations indexed in 'relationMaps', organizing them
-     * into a structured JSON object. Each top-level key in this object corresponds to a model's UUID,
-     * and its value is another object mapping entity expressIDs to their related entities, categorized
-     * by relation types. The structure facilitates easy access to any entity's relations across all models.
+     * @param materials - whether to dispose the materials of the mesh.
      *
-     * @returns A JSON string representing the serialized relations of all models processed by the indexer.
-     *          If no relations have been indexed, an empty object is returned as a JSON string.
+     * @param recursive - whether to recursively dispose the children of the mesh.
      */
-    serializeAllRelations(): string;
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
     /**
-     * Converts a JSON string representing relations between entities into a structured map.
-     * This method parses the JSON string to reconstruct the relations map that indexes
-     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
-     * and the values are maps where each key is a relation type ID and its value is an array
-     * of express IDs of entities related through that relation type.
+     * Disposes a geometry from memory.
      *
-     * @param json The JSON string to be parsed into the relations map.
-     * @returns A 'Map' where the key is the express ID of an entity as a number, and the value
-     * is another 'Map'. This inner map's key is the relation type ID as a number, and its value
-     * is an array of express IDs (as numbers) of entities related through that relation type.
-     */
-    getRelationsMapFromJSON(json: string): RelationsMap;
-    /**
-     * Disposes the component, cleaning up resources and detaching event listeners.
-     * This ensures that the component is properly cleaned up and does not leave behind any
-     * references that could prevent garbage collection.
-     */
-    dispose(): void;
-}
-export type { InverseAttribute, RelationsMap } from "./src/types";
-import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Object to export all the properties from an IFC to a JS object.
- */
-export declare class IfcJsonExporter extends Component {
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc]{@link https://github.com/ThatOpen/engine_web-ifc} to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
      */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
-}
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
-import { Components } from "../Components";
-export declare class Raycasters extends Component implements Disposable {
-    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
-    enabled: boolean;
-    list: Map<string, SimpleRaycaster>;
-    onDisposed: Event<unknown>;
-    constructor(components: Components);
-    get(world: World): SimpleRaycaster;
-    delete(world: World): void;
-    dispose(): void;
-}
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Disposable, Event, Components } from "../../core";
-type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
-type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
-type NumericPropTypes = "IfcInteger" | "IfcReal";
-interface ChangeMap {
-    [modelID: string]: Set<number>;
-}
-interface AttributeListener {
-    [modelID: string]: {
-        [expressID: number]: {
-            [attributeName: string]: Event<String | Boolean | Number>;
-        };
-    };
-}
-export declare class IfcPropertiesManager extends Component implements Disposable {
-    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    readonly onRequestFile: Event<unknown>;
-    ifcToExport: ArrayBuffer | null;
-    readonly onElementToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        elementID: number;
-    }>;
-    readonly onPropToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        propID: number;
-    }>;
-    readonly onPsetRemoved: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-    }>;
-    readonly onDataChanged: Event<{
-        model: FragmentsGroup;
-        expressID: number;
-    }>;
-    wasm: {
-        path: string;
-        absolute: boolean;
-    };
-    enabled: boolean;
-    attributeListeners: AttributeListener;
-    selectedModel?: FragmentsGroup;
-    changeMap: ChangeMap;
-    constructor(components: Components);
-    dispose(): void;
-    private increaseMaxID;
-    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
-    private newGUID;
-    private getOwnerHistory;
-    private registerChange;
-    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
-    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
-        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
-        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
-    }>;
-    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
-    private newSingleProperty;
-    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
-    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
-    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
-    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
-    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
 }
-export {};
 import { Component, Disposable, Event } from "../Types";
 /**
- * The entry point of the Components library.
- * It can:
- * - Create and access all the components of the library.
- * - Update all the updatable components automatically.
- * - Dispose all the components, preventing memory leaks.
+ * The entry point of the Components library. It can create and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
  */
 export declare class Components implements Disposable {
-    static readonly release = "1.4.21";
+    /**
+     * The version of the @thatopen/components library.
+     */
+    static readonly release = "2.0.8";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<void>;
-    /** The list of components created in this app. */
+    /**
+     * The list of components created in this app.
+     * The keys are UUIDs and the values are instances of the components.
+     */
     readonly list: Map<string, Component>;
-    /** If disabled, the animation loop will be stopped. */
+    /**
+     * If disabled, the animation loop will be stopped.
+     * Default value is false.
+     */
     enabled: boolean;
     private _clock;
+    /**
+   * Adds a component to the list of components.
+   * Throws an error if a component with the same UUID already exists.
+   *
+   * @param uuid - The unique identifier of the component.
+   * @param instance - The instance of the component to be added.
+   *
+   * @throws Will throw an error if a component with the same UUID already exists.
+   *
+   * @internal
+   */
     add(uuid: string, instance: Component): void;
     /**
-     * Retrieves a component. If it already exists in this app, it returns the instance of the component. If it
-     * doesn't exist, it will instance it automatically.
-     *
-     * @param Component - The component to get or create.
-     */
+   * Retrieves a component instance by its constructor function.
+   * If the component does not exist in the list, it will be created and added.
+   *
+   * @template U - The type of the component to retrieve.
+   * @param Component - The constructor function of the component to retrieve.
+   *
+   * @returns The instance of the requested component.
+   *
+   * @throws Will throw an error if a component with the same UUID already exists.
+   *
+   * @internal
+   */
     get<U extends Component>(Component: new (components: Components) => U): U;
     constructor();
     /**
-     * Initializes the library. It should be called at the start of the app after
-     * initializing the scene, the renderer and the
-     * camera. Additionally, if any component that need a raycaster is
-     * used, the {@link raycaster} will need to be initialized.
+     * Initializes the Components instance.
+     * This method starts the animation loop, sets the enabled flag to true,
+     * and calls the update method.
+     *
+     * @returns {void}
      */
     init(): void;
     /**
@@ -278,7 +109,7 @@ export declare class Components implements Disposable {
      * called. This is especially relevant in Single Page Applications (React,
      * Angular, Vue, etc).
      *
-     * - Any of the objects of this instance (meshes, geometries, etc) is
+     * - Any of the objects of this instance (meshes, geometries,materials, etc) is
      * referenced by a reference type (object or array).
      *
      * You can learn more about how Three.js handles memory leaks
@@ -289,108 +120,82 @@ export declare class Components implements Disposable {
     private update;
     private static setupBVH;
 }
-import * as THREE from "three";
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
-import { Component } from "../Types";
 /**
- * A tool to safely remove meshes and geometries from memory to
- * [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ * A component that manages raycasters for different worlds. It uses a Map to store raycasters for each world, and automatically disposes them when the world is disposed.
  */
-export declare class Disposer extends Component {
-    private _disposedComponents;
+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;
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
     /**
-     * {@link Component.uuid}.
-     * @return the list of UUIDs of deleted components.
+     * A Map that stores raycasters for each world.
+     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
      */
-    get(): Set<string>;
+    list: Map<string, SimpleRaycaster>;
+    /** {@link Disposable.onDisposed} */
+    onDisposed: Event<unknown>;
+    constructor(components: Components);
     /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
+     * 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 recursive - whether to recursively dispose the children of the mesh.
+     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
+     * @returns The SimpleRaycaster instance for the given world.
      */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
+    get(world: World): SimpleRaycaster;
     /**
-     * Disposes a geometry from memory.
+     * 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 geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
+     * @param world - The world for which to delete the SimpleRaycaster instance.
+     * @returns {void}
      */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}
-import * as THREE from "three";
-import { Component, Components } from "../../core";
-export interface MeasureEdge {
-    distance: number;
-    points: THREE.Vector3[];
-}
-export declare class MeasurementUtils extends Component {
-    enabled: boolean;
-    static uuid: string;
-    constructor(components: Components);
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    private getFaceData;
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    private round;
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
 }
 import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } 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.
+ */
 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";
-    /**
-     * Event triggered after the update process of all worlds.
-     * Subscribers can listen to this event to perform actions post-update.
-     */
+    /** {@link Updateable.onAfterUpdate} */
     readonly onAfterUpdate: Event<unknown>;
-    /**
-     * Event triggered before the update process of all worlds.
-     * Subscribers can listen to this event to perform actions pre-update.
-     */
+    /** {@link Updateable.onBeforeUpdate} */
     readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * Event triggered when the Worlds component is disposed.
-     * Subscribers can listen to this event to perform cleanup actions.
+     * An event that is triggered when a new world is created.
+     * The event passes the newly created world as a parameter.
      */
-    readonly onDisposed: Event<unknown>;
     readonly onWorldCreated: Event<World>;
+    /**
+     * An event that is triggered when a world is deleted.
+     * The event passes the UUID of the deleted world as a parameter.
+     */
     readonly onWorldDeleted: Event<string>;
     /**
      * 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: Map<string, World>;
-    /**
-     * A flag indicating whether the Worlds component is enabled.
-     * If false, the update process will be skipped.
-     */
+    /** {@link Component.enabled} */
     enabled: boolean;
     constructor(components: Components);
     /**
@@ -403,81 +208,122 @@ export declare class Worlds extends Component implements Updateable, Disposable
      * @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.
+   *
+   * @returns {void}
+   */
     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.
+   *
+   * @returns {void}
+   */
     dispose(): void;
+    /** {@link Updateable.update} */
     update(delta?: number): void | Promise<void>;
 }
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-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 class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
-import * as THREE from "three";
-import { Component, Components, Event, World } from "../core";
-export interface VertexPickerConfig {
-    showOnlyVertex: boolean;
-    snapDistance: number;
-    previewElement: HTMLElement;
-}
-export declare class VertexPicker extends Component {
-    onVertexFound: Event<THREE.Vector3>;
-    onVertexLost: Event<THREE.Vector3>;
-    components: Components;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
-    private _workingPlane;
-    set enabled(value: boolean);
-    get enabled(): boolean;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    set workingPlane(plane: THREE.Plane | null);
-    get workingPlane(): THREE.Plane | null;
-    set config(value: Partial<VertexPickerConfig>);
-    get config(): Partial<VertexPickerConfig>;
+import { Component, Disposable, World, Event } from "../Types";
+import { GridConfig, SimpleGrid } from "./src";
+import { Components } from "../Components";
+/**
+ * A component that manages and provides access to multiple grid instances. Each grid is associated with a unique world.
+ */
+export declare class Grids 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: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    /**
+     * A map of world UUIDs to their corresponding grid instances.
+     */
+    list: Map<string, SimpleGrid>;
+    /**
+     * The default configuration for grid creation.
+     */
+    config: Required<GridConfig>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+   * Creates a new grid for the given world.
+   * Throws an error if a grid already exists for the world.
+   *
+   * @param world - The world to create the grid for.
+   * @returns The newly created grid.
+   *
+   * @throws Will throw an error if a grid already exists for the given world.
+   */
+    create(world: World): SimpleGrid;
+    /**
+     * Deletes the grid associated with the given world.
+     * If a grid does not exist for the given world, this method does nothing.
+     *
+     * @param world - The world for which to delete the grid.
+     *
+     * @remarks
+     * This method will dispose of the grid and remove it from the internal list.
+     * If the world is disposed before calling this method, the grid will be automatically deleted.
+     */
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
     dispose(): void;
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
 }
 import * as THREE from "three";
 import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
 import { SimplePlane } from "./src";
 import { Components } from "../Components";
 /**
- * A lightweight component to easily create and handle
- * [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes).
+ * A lightweight component to easily create and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes).
  *
  * @param components - the instance of {@link Components} used.
  * E.g. {@link SimplePlane}.
  */
 export declare class Clipper extends Component implements Createable, Disposable, Hideable {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
     static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
-    /** {@link Createable.onAfterCreate} */
-    readonly onAfterCreate: Event<SimplePlane>;
-    /** {@link Createable.onAfterDelete} */
-    readonly onAfterDelete: Event<SimplePlane>;
     /** Event that fires when the user starts dragging a clipping plane. */
     readonly onBeforeDrag: Event<void>;
     /** Event that fires when the user stops dragging a clipping plane. */
     readonly onAfterDrag: Event<void>;
+    /**
+     * Event that fires when the user starts creating a clipping plane.
+     */
     readonly onBeforeCreate: Event<unknown>;
+    /**
+     * Event that fires when the user cancels the creation of a clipping plane.
+     */
     readonly onBeforeCancel: Event<unknown>;
+    /**
+     * Event that fires after the user cancels the creation of a clipping plane.
+     */
     readonly onAfterCancel: Event<unknown>;
+    /**
+     * Event that fires when the user starts deleting a clipping plane.
+     */
     readonly onBeforeDelete: Event<unknown>;
+    /**
+     * Event that fires after a clipping plane has been created.
+     * @param plane - The newly created clipping plane.
+     */
+    readonly onAfterCreate: Event<SimplePlane>;
+    /**
+     * Event that fires after a clipping plane has been deleted.
+     * @param plane - The deleted clipping plane.
+     */
+    readonly onAfterDelete: Event<SimplePlane>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
     /**
@@ -493,7 +339,14 @@ export declare class Clipper extends Component implements Createable, Disposable
      * has to be 'true' for this to apply.
      */
     toleranceOrthogonalY: number;
+    /**
+     * The type of clipping plane to be created.
+     * Default is {@link SimplePlane}.
+     */
     Type: new (...args: any) => SimplePlane;
+    /**
+     * A list of all the clipping planes created by this component.
+     */
     list: SimplePlane[];
     /** The material used in all the clipping planes. */
     private _material;
@@ -552,69 +405,96 @@ export declare class Clipper extends Component implements Createable, Disposable
     private _onStartDragging;
     private _onEndDragging;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
-import { Components } from "../Components";
-export declare class Grids extends Component implements Disposable {
-    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
-    list: Map<string, SimpleGrid>;
-    readonly onDisposed: Event<unknown>;
-    config: Required<GridConfig>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    create(world: World): SimpleGrid;
-    delete(world: World): void;
+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, Event, World } from "../core";
+export interface VertexPickerConfig {
+    showOnlyVertex: boolean;
+    snapDistance: number;
+    previewElement: HTMLElement;
+}
+export declare class VertexPicker extends Component {
+    onVertexFound: Event<THREE.Vector3>;
+    onVertexLost: Event<THREE.Vector3>;
+    components: Components;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
+    private _workingPlane;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    set workingPlane(plane: THREE.Plane | null);
+    get workingPlane(): THREE.Plane | null;
+    set config(value: Partial<VertexPickerConfig>);
+    get config(): Partial<VertexPickerConfig>;
     dispose(): void;
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
 }
 import { Components } from "../Components";
 import { MeshCullerRenderer, CullerRendererSettings } from "./src";
 import { Component, Event, Disposable, World } from "../Types";
 /**
- * A tool to handle big scenes efficiently by automatically hiding the objects
- * that are not visible to the camera.
+ * A component that manages and provides culling functionality for meshes in a 3D scene.
  */
 export declare class Cullers extends Component implements Disposable {
     /**
-     * A unique identifier for the Cullers component.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
     static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
     /**
-     * Indicates whether the Cullers component is enabled.
-     */
-    private _enabled;
-    /**
-     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
-     */
-    list: Map<string, MeshCullerRenderer>;
-    /**
-     * An event that is triggered when the Cullers component is disposed.
-     */
+   * An event that is triggered when the Cullers component is disposed.
+   */
     readonly onDisposed: Event<unknown>;
+    private _enabled;
     /**
-     * Gets the enabled state of the Cullers component.
-     *
-     * @returns The current enabled state.
+     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
      */
+    list: Map<string, MeshCullerRenderer>;
+    /** {@link Component.enabled} */
     get enabled(): boolean;
-    /**
-     * Sets the enabled state of the Cullers component.
-     * Also sets the enabled state of all MeshCullerRenderer instances.
-     *
-     * @param value - The new enabled state.
-     */
+    /** {@link Component.enabled} */
     set enabled(value: boolean);
     constructor(components: Components);
     /**
-   * Creates a new MeshCullerRenderer for the given world.
-   * If a MeshCullerRenderer already exists for the world, it will return the existing one.
-   *
-   * @param world - The world for which to create the MeshCullerRenderer.
-   * @param config - Optional configuration settings for the MeshCullerRenderer.
-   *
-   * @returns The newly created or existing MeshCullerRenderer for the given world.
-   */
+     * Creates a new MeshCullerRenderer for the given world.
+     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
+     *
+     * @param world - The world for which to create the MeshCullerRenderer.
+     * @param config - Optional configuration settings for the MeshCullerRenderer.
+     *
+     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     */
     create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
+    /**
+     * Deletes the MeshCullerRenderer associated with the given world.
+     * If a MeshCullerRenderer exists for the given world, it will be disposed and removed from the list.
+     *
+     * @param world - The world for which to delete the MeshCullerRenderer.
+     *
+     * @returns {void}
+     */
     delete(world: World): void;
     /** {@link Disposable.dispose} */
     dispose(): void;
@@ -622,17 +502,48 @@ export declare class Cullers extends Component implements Disposable {
 import { MiniMap } from "./src";
 import { Component, Updateable, World, Event, Disposable } from "../Types";
 import { Components } from "../Components";
+/**
+ * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID.
+ */
 export declare class MiniMaps 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: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    /** {@link Updateable.onAfterUpdate} */
     readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
     readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
     enabled: boolean;
+    /**
+   * A collection of {@link MiniMap} instances, each associated with a unique world ID.
+   */
     list: Map<string, MiniMap>;
     constructor(components: Components);
+    /**
+   * Creates a new {@link MiniMap} instance associated with the given world.
+   * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
+   *
+   * @param world - The {@link World} for which to create a {@link MiniMap} instance.
+   * @returns The newly created {@link MiniMap} instance.
+   * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
+   */
     create(world: World): MiniMap;
+    /**
+   * Deletes a {@link MiniMap} instance associated with the given world ID.
+   * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
+   *
+   * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
+   * @returns {void}
+   */
     delete(id: string): void;
+    /** {@link Disposable.dispose} */
     dispose(): void;
+    /** {@link Updateable.update} */
     update(): void;
 }
 import * as THREE from "three";
@@ -640,23 +551,36 @@ 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
- * easily control the camera in 2D and 3D. It supports multiple navigation
- * modes, such as 2D floor plan navigation, first person and 3D orbit.
+ * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to easily 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.
  */
 export declare class OrthoPerspectiveCamera extends SimpleCamera {
     /**
-     * The current {@link NavigationMode}.
+     * A ProjectionManager instance that manages the projection modes of the camera.
      */
-    _mode: NavigationMode | null;
     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} */
@@ -674,25 +598,290 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
      * evaluate {@link Components.meshes}.
      * @param offset the distance to the fit object
      */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    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 WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Object to export all the properties from an IFC to a JS object.
+ */
+export declare class IfcJsonExporter extends Component {
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc]{@link https://github.com/ThatOpen/engine_web-ifc} to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
+     */
+    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 { Component, Disposable, Event, Components } from "../../core";
+type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
+type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
+type NumericPropTypes = "IfcInteger" | "IfcReal";
+interface ChangeMap {
+    [modelID: string]: Set<number>;
+}
+interface AttributeListener {
+    [modelID: string]: {
+        [expressID: number]: {
+            [attributeName: string]: Event<String | Boolean | Number>;
+        };
+    };
+}
+export declare class IfcPropertiesManager extends Component implements Disposable {
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    readonly onRequestFile: Event<unknown>;
+    ifcToExport: ArrayBuffer | null;
+    readonly onElementToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        elementID: number;
+    }>;
+    readonly onPropToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        propID: number;
+    }>;
+    readonly onPsetRemoved: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+    }>;
+    readonly onDataChanged: Event<{
+        model: FragmentsGroup;
+        expressID: number;
+    }>;
+    wasm: {
+        path: string;
+        absolute: boolean;
+    };
+    enabled: boolean;
+    attributeListeners: AttributeListener;
+    selectedModel?: FragmentsGroup;
+    changeMap: ChangeMap;
+    constructor(components: Components);
+    dispose(): void;
+    private increaseMaxID;
+    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    private newGUID;
+    private getOwnerHistory;
+    private registerChange;
+    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
+    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
+        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
+        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
+    }>;
+    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
+    private newSingleProperty;
+    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
+    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
+    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
+    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+}
+export {};
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Disposable, Event, Component, Components } from "../../core";
+import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
+/**
+ * Indexer 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.
+ */
+export declare class IfcRelationsIndexer extends Component implements Disposable {
+    static readonly uuid: "23a889ab-83b3-44a4-8bee-ead83438370b";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    enabled: boolean;
+    readonly onRelationsIndexed: Event<{
+        modelID: string;
+        relationsMap: RelationsMap;
+    }>;
+    private _relToAttributesMap;
+    private _inverseAttributes;
+    private _ifcRels;
+    /**
+     * Holds the relationship mappings for each model processed by the indexer.
+     * The structure is a map where each key is a model's UUID, and the value is another map.
+     * This inner map's keys are entity expressIDs, and its values are maps where each key is an index
+     * representing a specific relation type, and the value is an array of expressIDs of entities
+     * that are related through that relation type. This structure allows for efficient querying
+     * of entity relationships within a model.
+     */
+    readonly relationMaps: ModelsRelationMap;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    private indexRelations;
+    /**
+     * Adds a relation map to the model's relations map.
+     *
+     * @param model - The 'FragmentsGroup' model to which the relation map will be added.
+     * @param relationMap - The 'RelationsMap' to be added to the model's relations map.
+     *
+     * @fires onRelationsIndexed - Triggers an event with the model's UUID and the added relation map.
+     */
+    setRelationMap(model: FragmentsGroup, relationMap: RelationsMap): void;
+    /**
+     * Processes a given model to index its IFC entities relations based on predefined inverse attributes.
+     * This method iterates through each specified inverse attribute, retrieves the corresponding relations,
+     * and maps them in a structured way to facilitate quick access to related entities.
+     *
+     * The process involves querying the model for each relation type associated with the inverse attributes
+     * and updating the internal relationMaps with the relationships found. This map is keyed by the model's UUID
+     * and contains a nested map where each key is an entity's expressID and its value is another map.
+     * This inner map's keys are the indices of the inverse attributes, and its values are arrays of expressIDs
+     * of entities that are related through that attribute.
+     *
+     * @param model The 'FragmentsGroup' model to be processed. It must have properties loaded.
+     * @returns A promise that resolves to the relations map for the processed model. This map is a detailed
+     * 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>;
+    /**
+     * Processes a given model from a WebIfc API to index its IFC entities relations.
+     *
+     * @param ifcApi - The WebIfc API instance from which to retrieve the model's properties.
+     * @param modelID - The unique identifier of the model within the WebIfc API.
+     * @returns A promise that resolves to the relations map for the processed model.
+     *          This map is a detailed representation of the relations indexed by entity expressIDs and relation types.
+     */
+    processFromWebIfc(ifcApi: WEBIFC.IfcAPI, modelID: number): Promise<RelationsMap>;
+    /**
+     * Retrieves the relations of a specific entity within a model based on the given relation name.
+     * This method searches the indexed relation maps for the specified model and entity,
+     * returning the IDs of related entities if a match is found.
+     *
+     * @param model The 'FragmentsGroup' model containing the entity.
+     * @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.
+     */
+    getEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute): number[] | null;
+    /**
+     * 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,
+     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
+     * The resulting object is then serialized into a JSON string.
+     *
+     * @param relationMap - The map of relations to be serialized. The map keys are expressIDs of entities, and the values are maps where each key is a relation type ID and its value is an array of expressIDs of entities related through that relation type.
+     * @returns A JSON string representing the serialized relations of the given relation map.
+     */
+    serializeRelations(relationMap: RelationsMap): string;
+    /**
+     * Serializes the relations of a specific model into a JSON string.
+     * This method iterates through the relations indexed for the given model,
+     * organizing them into a structured object where each key is an expressID of an entity,
+     * and its value is another object mapping relation indices to arrays of related entity expressIDs.
+     * The resulting object is then serialized into a JSON string.
+     *
+     * @param model The 'FragmentsGroup' model whose relations are to be serialized.
+     * @returns A JSON string representing the serialized relations of the specified model.
+     * If the model has no indexed relations, 'null' is returned.
+     */
+    serializeModelRelations(model: FragmentsGroup): string | null;
+    /**
+     * Serializes all relations of every model processed by the indexer into a JSON string.
+     * This method iterates through each model's relations indexed in 'relationMaps', organizing them
+     * into a structured JSON object. Each top-level key in this object corresponds to a model's UUID,
+     * and its value is another object mapping entity expressIDs to their related entities, categorized
+     * by relation types. The structure facilitates easy access to any entity's relations across all models.
+     *
+     * @returns A JSON string representing the serialized relations of all models processed by the indexer.
+     *          If no relations have been indexed, an empty object is returned as a JSON string.
+     */
+    serializeAllRelations(): string;
     /**
-     * Allows or prevents all user input.
+     * Converts a JSON string representing relations between entities into a structured map.
+     * This method parses the JSON string to reconstruct the relations map that indexes
+     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
+     * and the values are maps where each key is a relation type ID and its value is an array
+     * of express IDs of entities related through that relation type.
      *
-     * @param active - whether to enable or disable user inputs.
+     * @param json The JSON string to be parsed into the relations map.
+     * @returns A 'Map' where the key is the express ID of an entity as a number, and the value
+     * is another 'Map'. This inner map's key is the relation type ID as a number, and its value
+     * is an array of express IDs (as numbers) of entities related through that relation type.
      */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
+    getRelationsMapFromJSON(json: string): RelationsMap;
+    /**
+     * Disposes the component, cleaning up resources and detaching event listeners.
+     * This ensures that the component is properly cleaned up and does not leave behind any
+     * references that could prevent garbage collection.
+     */
+    dispose(): void;
+}
+export type { InverseAttribute, RelationsMap } from "./src/types";
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Disposable, Component, Event, Components } from "../../core";
+export interface Classification {
+    [system: string]: {
+        [className: string]: FRAGS.FragmentIdMap;
+    };
+}
+export declare class Classifier extends Component implements Disposable {
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    list: Classification;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    dispose(): void;
+    remove(guid: string): void;
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    byEntity(group: FRAGS.FragmentsGroup): void;
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    resetColor(items: FRAGS.FragmentIdMap): void;
+    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+export declare class Hider extends Component {
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    enabled: boolean;
+    constructor(components: Components);
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Component, Components, Disposable, Event } from "../../core";
 /**
- * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but
- * it's fast, and should suffice for general use cases such as camera zooming or general boundary determination.
+ * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but it's fast, and should suffice for general use cases such as camera zooming or general boundary determination.
  */
 export declare class BoundingBoxer extends Component implements Disposable {
     static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
@@ -722,37 +911,6 @@ export declare class BoundingBoxer extends Component implements Disposable {
     addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
     private static getFragmentBounds;
 }
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
-export interface Classification {
-    [system: string]: {
-        [className: string]: FRAGS.FragmentIdMap;
-    };
-}
-export declare class Classifier extends Component implements Disposable {
-    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    list: Classification;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    dispose(): void;
-    remove(guid: string): void;
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
-    byEntity(group: FRAGS.FragmentsGroup): void;
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
-    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
-}
 import { Component, Disposable, Event, Components } from "../../core";
 export declare class Exploder extends Component implements Disposable {
     static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
@@ -797,24 +955,13 @@ export declare class IfcLoader extends Component implements Disposable {
     private getGeometry;
     private autoSetWasm;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
-export declare class Hider extends Component {
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
-    enabled: boolean;
-    constructor(components: Components);
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
-}
 import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { Component, Components, Event, Disposable } from "../../core";
 import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
 /**
- * Object that can efficiently load binary files that contain
- * [fragment geometry](https://github.com/ThatOpen/engine_fragment).
+ * Object that can efficiently load binary files that contain [fragment geometry](https://github.com/ThatOpen/engine_fragment).
  */
 export declare class FragmentsManager extends Component implements Disposable {
     static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
@@ -858,47 +1005,29 @@ export declare class FragmentsManager extends Component implements Disposable {
      * @returns the exported data as binary buffer.
      */
     export(group: FragmentsGroup): Uint8Array;
+    /**
+     * Gets a map of model IDs to sets of express IDs for the given fragment ID map.
+     * @param fragmentIdMap - A map of fragment IDs to their corresponding express IDs.
+     * @returns A map of model IDs to sets of express IDs.
+     */
+    getModelIdMap(fragmentIdMap: FRAGS.FragmentIdMap): {
+        [modelID: string]: Set<number>;
+    };
+    /**
+     * Converts a map of model IDs to sets of express IDs to a fragment ID map.
+     * @param modelIdMap - A map of model IDs to their corresponding express IDs.
+     * @returns A fragment ID map.
+     * @remarks
+     * This method iterates through the provided model ID map, retrieves the corresponding model from the 'groups' map,
+     * and then calls the 'getFragmentMap' method of the model to obtain a fragment ID map for the given express IDs.
+     * The fragment ID maps are then merged into a single map and returned.
+     * If a model with a given ID is not found in the 'groups' map, the method skips that model and continues with the next one.
+     */
+    modelIdToFragmentIdMap(modelIdMap: {
+        [modelID: string]: Set<number>;
+    }): FRAGS.FragmentIdMap;
     coordinate(models?: FragmentsGroup[]): void;
 }
-export declare const IfcElements: {
-    [key: number]: string;
-};
-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 FRAGS from "@thatopen/fragments";
-export declare class IfcPropertiesUtils {
-    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
-    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
-        [attribute: string]: any;
-    } | null>;
-    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
-        [relatingID: number]: number[];
-    }>;
-    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
-    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
-    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
-    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
-        key: string | null;
-        name: string | null;
-    }>;
-    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
-        key: string | null;
-        value: number | null;
-    }>;
-    static isRel(expressID: number): boolean;
-    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
-    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
-}
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
-export declare const GeometryTypes: Set<number>;
 import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
 import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
@@ -965,24 +1094,112 @@ export declare class IfcPropertiesTiler extends Component implements Disposable
     private streamAllProperties;
     private cleanUp;
 }
-import { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<number, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
+import * as THREE from "three";
+import { Component, Components } from "../../core";
+export interface MeasureEdge {
+    distance: number;
+    points: THREE.Vector3[];
+}
+export declare class MeasurementUtils extends Component {
+    enabled: boolean;
+    static uuid: string;
+    constructor(components: Components);
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    private getFaceData;
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    private round;
+}
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+}
+export declare const IfcElements: {
+    [key: number]: string;
+};
+import * as FRAGS from "@thatopen/fragments";
+export declare class IfcPropertiesUtils {
+    static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
+    static findItemByGuid(model: FRAGS.FragmentsGroup, guid: string): Promise<{
+        [attribute: string]: any;
+    } | null>;
+    static getRelationMap(model: FRAGS.FragmentsGroup, relationType: number, onElementsFound?: (relatingID: number, relatedIDs: number[]) => Promise<void>): Promise<{
+        [relatingID: number]: number[];
+    }>;
+    static getQsetQuantities(model: FRAGS.FragmentsGroup, expressID: number, onQuantityFound?: (expressID: number) => void): Promise<number[] | null>;
+    static getPsetProps(model: FRAGS.FragmentsGroup, expressID: number, onPropFound?: (expressID: number) => void): Promise<number[] | null>;
+    static getPsetRel(model: FRAGS.FragmentsGroup, psetID: number): Promise<number | null>;
+    static getQsetRel(model: FRAGS.FragmentsGroup, qsetID: number): Promise<number | null>;
+    static getEntityName(model: FRAGS.FragmentsGroup, entityID: number): Promise<{
+        key: string | null;
+        name: string | null;
+    }>;
+    static getQuantityValue(model: FRAGS.FragmentsGroup, quantityID: number): Promise<{
+        key: string | null;
+        value: number | null;
+    }>;
+    static isRel(expressID: number): boolean;
+    static attributeExists(model: FRAGS.FragmentsGroup, expressID: number, attribute: string): Promise<boolean>;
+    static groupEntitiesByType(model: FRAGS.FragmentsGroup, expressIDs: Set<number> | number[]): Promise<Map<number, Set<number>>>;
+}
+export declare const IfcCategoryMap: {
+    [key: number]: string;
+};
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
+/**
+ * A class representing a 2D minimap in a 3D world.
+ */
 export declare class MiniMap implements Resizeable, Updateable, Disposable {
     /** {@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>;
+    /**
+     * 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;
     private _lockRotation;
     private _camera;
@@ -992,69 +1209,94 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     private _tempVector2;
     private _tempTarget;
     private readonly down;
+    /**
+   * 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 lockRotation(): 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.
+   */
     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);
+    /** {@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;
     private updatePlanes;
 }
-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;
-}
+export declare const GeometryTypes: Set<number>;
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<number, {
+    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.
+ * 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.
  */
-export declare class AsyncEvent<T> {
+export declare class Event<T> {
     /**
      * Add a callback to this event instance.
      * @param handler - the callback to be added to this event.
      */
     add(handler: T extends void ? {
-        (): Promise<void>;
+        (): void;
     } : {
-        (data: T): Promise<void>;
+        (data: T): void;
     }): void;
     /**
      * Removes a callback from this event instance.
      * @param handler - the callback to be removed from this event.
      */
     remove(handler: T extends void ? {
-        (): Promise<void>;
+        (): void;
     } : {
-        (data: T): Promise<void>;
+        (data: T): void;
     }): void;
     /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => Promise<void>;
+    trigger: (data?: T) => void;
     /** Gets rid of all the suscribed events. */
     reset(): void;
     private handlers;
 }
+import { Base } from "./base";
+/**
+ * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
+ */
+export declare abstract class Component extends Base {
+    /**
+     * Whether this component is active or not. The behaviour can vary depending
+     * on the type of component. E.g. a disabled dimension tool will stop creating
+     * dimensions, while a disabled camera will stop moving. A disabled component
+     * will not be updated automatically each frame.
+     */
+    abstract enabled: boolean;
+}
 import * as THREE from "three";
 import CameraControls from "camera-controls";
 import { Event } from "./event";
 /**
- * Whether this component has to be manually destroyed once you are done with
- * it to prevent
- * [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- * This also ensures that the DOM events created by that component will be
- * cleaned up.
+ * Whether this component has to be manually destroyed once you are done with it to prevent [memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects). This also ensures that the DOM events created by that component will be cleaned up.
  */
 export interface Disposable {
     /**
@@ -1062,13 +1304,11 @@ export interface Disposable {
      * [memory leak](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      */
     dispose: () => void | Promise<void>;
-    /** Fired after the tool has been {@link Disposable.dispose()}  */
+    /** Fired after the tool has been disposed.  */
     readonly onDisposed: Event<any>;
 }
 /**
- * Whether the geometric representation of this component can be
- * hidden or shown in the
- * [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
+ * Whether the geometric representation of this component can be hidden or shown in the [Three.js scene](https://threejs.org/docs/#api/en/scenes/Scene).
  */
 export interface Hideable {
     /**
@@ -1079,11 +1319,7 @@ export interface Hideable {
     visible: boolean;
 }
 /**
- * Whether this component can be resized. The meaning of this can vary depending
- * on the component: resizing a
- * [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer)
- * component could mean changing its resolution, whereas resizing a
- * [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
+ * Whether this component can be resized. The meaning of this can vary depending on the component: resizing a [Renderer](https://threejs.org/docs/#api/en/renderers/WebGLRenderer) component could mean changing its resolution, whereas resizing a [Mesh](https://threejs.org/docs/#api/en/objects/Mesh) would change its scale.
  */
 export interface Resizeable {
     /**
@@ -1121,9 +1357,7 @@ export interface Progress {
     total: number;
 }
 /**
- * Whether this component supports create and destroy operations. This generally
- * applies for components that work with instances, such as clipping planes or
- * dimensions.
+ * Whether this component supports create and destroy operations. This generally applies for components that work with instances, such as clipping planes or dimensions.
  */
 export interface Createable {
     /** Creates a new instance of an element (e.g. a new Dimension). */
@@ -1156,104 +1390,91 @@ export interface Configurable<T extends Record<string, any>> {
      */
     config: Required<T>;
 }
-/**
- * An interface to make [three-mesh-bvh](https://github.com/gkjohnson/three-mesh-bvh) compatible with typescript.
- */
-export interface BVHGeometry extends THREE.BufferGeometry {
-    boundsTree: Object | undefined;
-    disposeBoundsTree: () => void;
-}
 /**
  * Whether a camera uses the Camera Controls library.
  */
 export interface CameraControllable {
+    /**
+     * An instance of CameraControls that provides camera control functionalities.
+     * This instance is used to manipulate the camera.
+     */
     controls: CameraControls;
 }
-import { Base } from "./base";
+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 { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
+import { Components } from "../../Components";
 /**
- * Components are the building blocks of this library. Components are singleton
- * elements that contain specific functionality. For instance, the SimpleClipper
- * Component can create, delete and handle 3D clipping planes. Components must be
- * unique (they can't be instanced more than once), and have a static UUID that
- * identifies them uniquely. The can be accessed globally using the {@link Components}
- * instance.
+ * Base class of the library. Useful for finding out the interfaces something implements.
  */
-export declare abstract class Component extends Base {
-    /**
-     * Whether this component is active or not. The behaviour can vary depending
-     * on the type of component. E.g. a disabled dimension tool will stop creating
-     * dimensions, while a disabled camera will stop moving. A disabled component
-     * will not be updated automatically each frame.
-     */
-    abstract enabled: boolean;
+export declare abstract class Base {
+    components: Components;
+    constructor(components: Components);
+    /** Whether is component is {@link Disposable}. */
+    isDisposeable: () => this is Disposable;
+    /** Whether is component is {@link Resizeable}. */
+    isResizeable: () => this is Resizeable;
+    /** Whether is component is {@link Updateable}. */
+    isUpdateable: () => this is Updateable;
+    /** Whether is component is {@link Hideable}. */
+    isHideable: () => this is Hideable;
+    /** Whether is component is {@link Configurable}. */
+    isConfigurable: () => this is Configurable<any>;
 }
 /**
- * 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.
+ * 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.
  */
-export declare class Event<T> {
+export declare class AsyncEvent<T> {
     /**
      * Add a callback to this event instance.
      * @param handler - the callback to be added to this event.
      */
     add(handler: T extends void ? {
-        (): void;
+        (): Promise<void>;
     } : {
-        (data: T): void;
+        (data: T): Promise<void>;
     }): void;
     /**
      * Removes a callback from this event instance.
      * @param handler - the callback to be removed from this event.
      */
     remove(handler: T extends void ? {
-        (): void;
+        (): Promise<void>;
     } : {
-        (data: T): void;
+        (data: T): Promise<void>;
     }): void;
     /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
+    trigger: (data?: T) => Promise<void>;
     /** Gets rid of all the suscribed events. */
     reset(): void;
     private handlers;
 }
-import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
-import { Components } from "../../Components";
-/**
- * Base class of the library. Useful for finding out the interfaces it implements.
- */
-export declare abstract class Base {
-    components: Components;
-    constructor(components: Components);
-    /** Whether is component is {@link Disposable}. */
-    isDisposeable: () => this is Disposable;
-    /** Whether is component is {@link Resizeable}. */
-    isResizeable: () => this is Resizeable;
-    /** Whether is component is {@link Updateable}. */
-    isUpdateable: () => this is Updateable;
-    /** Whether is component is {@link Hideable}. */
-    isHideable: () => this is Hideable;
-    /** Whether is component is {@link Configurable}. */
-    isConfigurable: () => this is Configurable<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.
+ * 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);
 }
@@ -1261,11 +1482,28 @@ import * as THREE from "three";
 import CameraControls from "camera-controls";
 import { BaseWorldItem } from "./base-world-item";
 import { CameraControllable } from "./interfaces";
+/**
+ * Abstract class representing a camera in the 3D world. All cameras should use this class as a base.
+ */
 export declare abstract class BaseCamera extends BaseWorldItem {
+    /**
+     * Whether the camera is enabled or not.
+     */
     abstract enabled: boolean;
+    /**
+     * The Three.js camera instance.
+     */
     abstract three: THREE.Camera;
+    /**
+     * Optional CameraControls instance for controlling the camera.
+     * This property is only available if the camera is controllable.
+     */
     abstract controls?: CameraControls;
-    /** Whether is instance is {@link CameraControllable}. */
+    /**
+     * Checks whether the instance is {@link CameraControllable}.
+     *
+     * @returns True if the instance is controllable, false otherwise.
+     */
     hasCameraControls: () => this is CameraControllable;
 }
 import * as THREE from "three";
@@ -1273,7 +1511,16 @@ import { Vector2 } from "three";
 import { Event } from "./event";
 import { BaseWorldItem } from "./base-world-item";
 import { Disposable, Resizeable, Updateable } from "./interfaces";
+/**
+ * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
+ */
 export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
+    /**
+     * The three.js WebGLRenderer instance associated with this renderer.
+     *
+     * @abstract
+     * @type {THREE.WebGLRenderer}
+     */
     abstract three: THREE.WebGLRenderer;
     /** {@link Updateable.onBeforeUpdate} */
     onAfterUpdate: Event<unknown>;
@@ -1281,31 +1528,47 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
     onBeforeUpdate: Event<unknown>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<undefined>;
+    /** {@link Resizeable.onResize} */
     readonly onResize: Event<THREE.Vector2>;
     /**
      * Event that fires when there has been a change to the list of clipping
      * planes used by the active renderer.
      */
     readonly onClippingPlanesUpdated: Event<unknown>;
+    /** {@link Updateable.update} */
     abstract update(delta?: number): void | Promise<void>;
+    /** {@link Disposable.dispose} */
     abstract dispose(): void;
+    /** {@link Resizeable.getSize} */
     abstract getSize(): Vector2;
+    /** {@link Resizeable.resize} */
     abstract resize(size: Vector2 | undefined): void;
     /**
-     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this
-     * instance of the renderer.
+     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
      */
     clippingPlanes: THREE.Plane[];
     /**
-     * Forces the update of the clipping planes and all components that depend
-     * on them that are subscribed to 'onClippingPlanesUpdated'.
-     */
+   * Updates the clipping planes and triggers the 'onClippingPlanesUpdated' event.
+   *
+   * @remarks
+   * This method is typically called when there is a change to the list of clipping planes
+   * used by the active renderer.
+   */
     updateClippingPlanes(): void;
     /**
-     * Adds or removes a
-     * [clipping plane](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes)
-     * to the renderer.
-     */
+   * Sets or removes a clipping plane from the renderer.
+   *
+   * @param active - A boolean indicating whether the clipping plane should be active or not.
+   * @param plane - The clipping plane to be added or removed.
+   * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to 'false'.
+   *
+   * @remarks
+   * This method adds or removes a clipping plane from the 'clippingPlanes' array.
+   * If 'active' is 'true' and the plane is not already in the array, it is added.
+   * If 'active' is 'false' and the plane is in the array, it is removed.
+   * The 'three.clippingPlanes' property is then updated to reflect the current state of the 'clippingPlanes' array,
+   * excluding any planes marked as local.
+   */
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
 import * as THREE from "three";
@@ -1313,9 +1576,16 @@ import { Disposable } from "./interfaces";
 import { Event } from "./event";
 import { Components } from "../../Components";
 import { BaseWorldItem } from "./base-world-item";
+/**
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
+ */
 export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    /**
+    * Abstract property representing the three.js object associated with this scene.
+    * It should be implemented by subclasses.
+    */
     abstract three: THREE.Object3D;
     protected constructor(components: Components);
     /** {@link Disposable.dispose} */
@@ -1326,17 +1596,185 @@ 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 * as THREE from "three";
+import { Hideable, Disposable, Event, World } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * Each of the planes created by the clipper.
+ */
+export declare class SimplePlane implements Disposable, Hideable {
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onDraggingStarted: Event<unknown>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onDraggingEnded: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * The normal vector of the clipping plane.
+     */
+    readonly normal: THREE.Vector3;
+    /**
+     * The origin point of the clipping plane.
+     */
+    readonly origin: THREE.Vector3;
+    /**
+     * The THREE.js Plane object representing the clipping plane.
+     */
+    readonly three: THREE.Plane;
+    /** The components instance to which this plane belongs. */
+    components: Components;
+    /** The world instance to which this plane belongs. */
+    world: World;
+    protected readonly _helper: THREE.Object3D;
+    protected _visible: boolean;
+    protected _enabled: boolean;
+    private _controlsActive;
+    private readonly _arrowBoundBox;
+    private readonly _planeMesh;
+    private readonly _controls;
+    private readonly _hiddenMaterial;
+    /**
+     * Getter for the enabled state of the clipping plane.
+     * @returns {boolean} The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Setter for the enabled state of the clipping plane.
+     * Updates the clipping plane state in the renderer and throws an error if no renderer is found.
+     * @param {boolean} state - The new enabled state.
+     */
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The meshes used for raycasting */
+    get meshes(): THREE.Mesh[];
+    /** The material of the clipping plane representation. */
+    get planeMaterial(): THREE.Material | THREE.Material[];
+    /** The material of the clipping plane representation. */
+    set planeMaterial(material: THREE.Material | THREE.Material[]);
+    /** The size of the clipping plane representation. */
+    get size(): number;
+    /** Sets the size of the clipping plane representation. */
+    set size(size: number);
+    /**
+   * Getter for the helper object of the clipping plane.
+   * The helper object is a THREE.Object3D that contains the clipping plane mesh and other related objects.
+   * It is used for positioning, rotating, and scaling the clipping plane in the 3D scene.
+   *
+   * @returns {THREE.Object3D} The helper object of the clipping plane.
+   */
+    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
+    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
+    /**
+   * Sets the clipping plane's normal and origin from the given normal and point.
+   * This method resets the clipping plane's state, updates the normal and origin,
+   * and positions the helper object accordingly.
+   *
+   * @param normal - The new normal vector for the clipping plane.
+   * @param point - The new origin point for the clipping plane.
+   *
+   * @returns {void}
+   */
+    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
+    /** {@link Updateable.update} */
+    update: () => void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private reset;
+    protected toggleControls(state: boolean): void;
+    private newTransformControls;
+    private initializeControls;
+    private createArrowBoundingBox;
+    private changeDrag;
+    private notifyDraggingChanged;
+    private preventCameraMovement;
+    private newHelper;
+    private static newPlaneMesh;
+}
+import * as THREE from "three";
+import { Hideable, Event, World, Disposable } from "../../Types";
+import { Components } from "../../Components";
+export interface GridConfig {
+    color: THREE.Color;
+    size1: number;
+    size2: number;
+    distance: number;
+}
+/**
+ * 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 {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** The world instance to which this Raycaster belongs. */
+    world: World;
+    /** The components instance to which this grid belongs. */
+    components: Components;
+    /** {@link Hideable.visible} */
+    get visible(): boolean;
+    /** {@link Hideable.visible} */
+    set visible(visible: boolean);
+    /** The material of the grid. */
+    get material(): THREE.ShaderMaterial;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    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, config: GridConfig);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private setupEvents;
+    private updateZoom;
+}
+import * as THREE from "three";
 import { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
+/**
+ * Configuration interface for the {@link SimpleScene}. Defines properties for directional and ambient lights.
+ */
 export interface SimpleSceneConfig {
     directionalLight: {
         color: THREE.Color;
@@ -1349,143 +1787,129 @@ export interface SimpleSceneConfig {
     };
 }
 /**
- * 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.
- * @noInheritDoc
+ * 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<{}> {
     /** {@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.onSetup} */
     readonly onSetup: Event<SimpleScene>;
+    /**
+   * Configuration interface for the {@link SimpleScene}.
+   * Defines properties for directional and ambient lights.
+   */
     config: Required<SimpleSceneConfig>;
     constructor(components: Components);
-    /** Creates a simple and nice default set up for the scene (e.g. lighting). */
+    /** {@link Configurable.setup} */
     setup(config?: Partial<SimpleSceneConfig>): void;
 }
 import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer } from "../../Types";
-import { Components } from "../../Components";
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World {
+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).
+     * 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.
+     */
     uuid: string;
+    /**
+     * An optional name for the world.
+     */
     name?: string;
-    readonly onDisposed: Event<unknown>;
     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);
-    get renderer(): S | null;
-    set renderer(renderer: S | null);
-    constructor(components: Components);
-    update(delta?: number): void;
-    dispose(disposeResources?: boolean): 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 {
-    enabled: boolean;
-    /** The HTML container of the THREE.js canvas where the scene is rendered. */
-    container: HTMLElement;
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
-    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;
-    setupEvents(active: boolean): void;
-    private resizeEvent;
-    private setupRenderer;
-    private onContextLost;
-    private onContextBack;
-}
-import * as THREE from "three";
-import { Hideable, Event, World, Disposable } from "../../Types";
-import { Components } from "../../Components";
-export interface GridConfig {
-    color: THREE.Color;
-    size1: number;
-    size2: number;
-    distance: number;
-}
-/**
- * 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 {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    world: World;
-    components: Components;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * 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 fade(): boolean;
+    get renderer(): S | null;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * 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 fade(active: boolean);
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World, config: GridConfig);
+    set renderer(renderer: S | null);
+    /** {@link Updateable.update} */
+    update(delta?: number): void;
     /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
+    dispose(disposeResources?: boolean): void;
 }
 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
- * easily control the camera in 2D and 3D. Check out it's API to find out
- * what features it offers.
+ * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to easily 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>;
+    /**
+     * 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.
+     */
     readonly onAspectUpdated: Event<unknown>;
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<string>;
+    /**
+     * A three.js PerspectiveCamera or OrthographicCamera instance.
+     * This camera is used for rendering the scene.
+     */
     three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
     private _allControls;
     /**
@@ -1495,9 +1919,20 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
      * object to move, rotate, look at objects, etc.
      */
     get controls(): CameraControls;
-    /** {@link Component.enabled} */
+    /**
+     * 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.
+     */
     get enabled(): boolean;
-    /** {@link Component.enabled} */
+    /**
+     * 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.
+     */
     set enabled(enabled: boolean);
     constructor(components: Components);
     /** {@link Disposable.dispose} */
@@ -1514,124 +1949,59 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
     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 { 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;
-}
 import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
+import { BaseRenderer, Event } from "../../Types";
+import { Components } from "../../Components";
 /**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
  */
-export declare class ProjectionManager {
+export declare class SimpleRenderer extends BaseRenderer {
     /**
-     * Event that fires when the {@link CameraProjection} changes.
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
      */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
-    current: CameraProjection;
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _component;
-    private _previousDistance;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    constructor(camera: OrthoPerspectiveCamera);
+    enabled: boolean;
     /**
-     * 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.
+     * The HTML container of the THREE.js canvas where the scene is rendered.
      */
-    set(projection: CameraProjection): Promise<void>;
+    container: HTMLElement;
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * The THREE.js WebGLRenderer instance.
      */
-    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;
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
     /**
-     * Enable or disable this navigation mode.
-     * When a new navigation mode is enabled, the previous navigation mode
-     * must be disabled.
+     * Constructor for the SimpleRenderer class.
      *
-     * @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;
+     * @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;
+    /**
+     * 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.
+     */
+    setupEvents(active: boolean): void;
+    private resizeEvent;
+    private setupRenderer;
+    private onContextLost;
+    private onContextBack;
 }
 import * as THREE from "three";
 import { Disposable, Event } from "../../Types";
@@ -1671,12 +2041,21 @@ import { Mouse } from "./mouse";
 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>;
     /** 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.
+     */
     readonly three: THREE.Raycaster;
+    /**
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
+     */
     world: World;
     constructor(components: Components, world: World);
     /** {@link Disposable.dispose} */
@@ -1691,6 +2070,15 @@ export declare class SimpleRaycaster implements Disposable {
      * {@link Components.meshes}.
      */
     castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
+    /**
+   * 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.
+   */
     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;
@@ -1698,14 +2086,33 @@ export declare class SimpleRaycaster implements Disposable {
 import * as THREE from "three";
 import { Components } from "../../Components";
 import { AsyncEvent, Event, World } from "../../Types";
+/**
+ * Interface for settings to configure the CullerRenderer.
+ */
 export interface CullerRendererSettings {
+    /**
+     * Interval in milliseconds at which the visibility check should be performed.
+     * Default value is 1000.
+     */
     updateInterval?: number;
+    /**
+     * Width of the render target used for visibility checks.
+     * Default value is 512.
+     */
     width?: number;
+    /**
+     * Height of the render target used for visibility checks.
+     * Default value is 512.
+     */
     height?: number;
+    /**
+     * Whether the visibility check should be performed automatically.
+     * Default value is true.
+     */
     autoUpdate?: boolean;
 }
 /**
- * A base renderer to determine visibility on screen
+ * A base renderer to determine visibility on screen.
  */
 export declare class CullerRenderer {
     /** {@link Disposable.onDisposed} */
@@ -1716,7 +2123,9 @@ export declare class CullerRenderer {
      * just before but not anymore.
      */
     readonly onViewUpdated: Event<any> | AsyncEvent<any>;
-    /** {@link Component.enabled} */
+    /**
+     * Whether this renderer is active or not. If not, it won't render anything.
+     */
     enabled: boolean;
     /**
      * Needs to check whether there are objects that need to be hidden or shown.
@@ -1728,8 +2137,11 @@ export declare class CullerRenderer {
      * for debugging purposes.
      */
     renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
     components: Components;
+    /** 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 autoUpdate: boolean;
     protected updateInterval: number;
@@ -1762,21 +2174,36 @@ export declare class CullerRenderer {
     protected decreaseColor(): void;
     private applySettings;
 }
-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, CullerRendererSettings } from "./culler-renderer";
 import { Components } from "../../Components";
-import { Event, World } from "../../Types";
+import { Event, World, Disposable } from "../../Types";
 /**
- * A renderer to determine a mesh visibility on screen
+ * A renderer to determine a mesh visibility on screen.
  */
-export declare class MeshCullerRenderer extends CullerRenderer {
-    threshold: number;
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
+    /**
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
+     */
     readonly onViewUpdated: Event<{
         seen: Set<THREE.Mesh>;
         unseen: Set<THREE.Mesh>;
     }>;
+    /**
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
+     */
+    threshold: number;
+    /**
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
+     */
     colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    /**
+     * Flag to indicate if the renderer is currently processing.
+     * Used to prevent concurrent processing.
+     */
     isProcessing: boolean;
     private _colorCodeMeshMap;
     private _meshIDColorCodeMap;
@@ -1785,72 +2212,162 @@ export declare class MeshCullerRenderer extends CullerRenderer {
     private _intervalID;
     private readonly _transparentMat;
     constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    /** {@link Disposable.dispose} */
     dispose(): void;
+    /**
+     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
+     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
+     */
     add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    /**
+   * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
+   * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
+   * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+   * @returns {void}
+   */
     remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     private handleWorkerMessage;
     private getAvailableMaterial;
 }
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
+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;
+}
+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 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 * as THREE from "three";
-import { Hideable, Disposable, Event, World } from "../../Types";
-import { Components } from "../../Components";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
 /**
- * Each of the planes created by {@link SimpleClipper}.
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
  */
-export declare class SimplePlane implements Disposable, Hideable {
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onDraggingStarted: Event<unknown>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onDraggingEnded: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    readonly normal: THREE.Vector3;
-    readonly origin: THREE.Vector3;
-    readonly three: THREE.Plane;
-    protected readonly _helper: THREE.Object3D;
-    protected _visible: boolean;
-    protected _enabled: boolean;
-    components: Components;
-    world: World;
-    private _controlsActive;
-    private readonly _arrowBoundBox;
-    private readonly _planeMesh;
-    private readonly _controls;
-    private readonly _hiddenMaterial;
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The meshes used for raycasting */
-    get meshes(): THREE.Mesh[];
-    /** The material of the clipping plane representation. */
-    get planeMaterial(): THREE.Material | THREE.Material[];
-    /** The material of the clipping plane representation. */
-    set planeMaterial(material: THREE.Material | THREE.Material[]);
-    /** The size of the clipping plane representation. */
-    get size(): number;
-    /** Sets the size of the clipping plane representation. */
-    set size(size: number);
-    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
-    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
-    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
-    /** {@link Updateable.update} */
-    update: () => void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private reset;
-    protected toggleControls(state: boolean): void;
-    private newTransformControls;
-    private initializeControls;
-    private createArrowBoundingBox;
-    private changeDrag;
-    private notifyDraggingChanged;
-    private preventCameraMovement;
-    private newHelper;
-    private static newPlaneMesh;
+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 * 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";
 /** Configuration of the IFC-fragment conversion. */
@@ -1879,21 +2396,6 @@ export declare class IfcFragmentSettings {
     autoSetWasm: boolean;
     customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
 }
-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>;
@@ -1925,16 +2427,6 @@ export interface StreamedAsset {
     }[];
 }
 import * as WEBIFC from "web-ifc";
-import * as THREE from "three";
-export declare class Units {
-    factor: number;
-    complement: number;
-    apply(matrix: THREE.Matrix4): void;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    private getLengthUnits;
-    private getScaleMatrix;
-}
-import * as WEBIFC from "web-ifc";
 import { AsyncEvent, Component, Disposable, Event } from "../../../core";
 import { PropertiesStreamingSettings } from "./streaming-settings";
 export declare class FragmentPropsStreamConverter extends Component implements Disposable {
@@ -1985,6 +2477,16 @@ export type InverseAttributes = [
     "ContainsElements"
 ];
 export type InverseAttribute = InverseAttributes[number];
+import * as WEBIFC from "web-ifc";
+import * as THREE from "three";
+export declare class Units {
+    factor: number;
+    complement: number;
+    apply(matrix: THREE.Matrix4): void;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    private getLengthUnits;
+    private getScaleMatrix;
+}
 import { BufferGeometry } from "three";
 import * as THREE from "three";
 export declare class TransformHelper {