@thatopen/components 2.1.19 → 2.1.21

package/dist/namespace.d.ts

@@ -1,4 +1,139 @@
 declare namespace OBC {
+import { Component, Disposable, Event } from "../Types";
+/**
+ * The entry point of the Components library. It can create, delete 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 {
+    /**
+     * The version of the @thatopen/components library.
+     */
+    static readonly release = "2.1.21";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<void>;
+    /**
+     * 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.
+     * 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 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 Components instance.
+     * This method starts the animation loop, sets the enabled flag to true,
+     * and calls the update method.
+     *
+     * @returns {void}
+     */
+    init(): void;
+    /**
+     * Disposes the memory of all the components and tools of this instance of
+     * the library. A memory leak will be created if:
+     *
+     * - An instance of the library ends up out of scope and this function isn't
+     * called. This is especially relevant in Single Page Applications (React,
+     * Angular, Vue, etc).
+     *
+     * - 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
+     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+     *
+     */
+    dispose(): void;
+    private update;
+    private static setupBVH;
+}
+import { SimpleScene, SimpleSceneConfig } from "../Worlds";
+import { DistanceRenderer } from "./src";
+import { Disposable } from "../Types";
+/**
+ * Configuration interface for the {@link ShadowedScene}. Defines properties for directional and ambient lights,
+ * as well as shadows.
+ */
+export interface ShadowedSceneConfig extends SimpleSceneConfig {
+    shadows: {
+        cascade: number;
+        resolution: number;
+    };
+}
+/**
+ * A scene that supports efficient cast shadows.
+ */
+export declare class ShadowedScene extends SimpleScene implements Disposable {
+    private _distanceRenderer?;
+    /**
+     * Whether the bias property should be set automatically depending on the shadow distance.
+     */
+    autoBias: boolean;
+    /**
+     * Configuration interface for the {@link ShadowedScene}.
+     * Defines properties for directional and ambient lights, as well as shadows.
+     */
+    config: Required<ShadowedSceneConfig>;
+    private _lightsWithShadow;
+    private _isComputingShadows;
+    private _shadowsEnabled;
+    private _bias;
+    /**
+     * The getter for the bias to prevent artifacts (stripes). It usually ranges between 0 and -0.005.
+     */
+    get bias(): number;
+    /**
+     * The setter for the bias to prevent artifacts (stripes). It usually ranges between 0 and -0.005.
+     */
+    set bias(value: number);
+    /**
+     * Getter to see whether the shadows are enabled or not in this scene instance.
+     */
+    get shadowsEnabled(): boolean;
+    /**
+     * Setter to control whether the shadows are enabled or not in this scene instance.
+     */
+    set shadowsEnabled(value: boolean);
+    /**
+     * Getter to get the renderer used to determine the farthest distance from the camera.
+     */
+    get distanceRenderer(): DistanceRenderer;
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<ShadowedSceneConfig>): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** Update all the shadows of the scene. */
+    updateShadows(): Promise<void>;
+    private recomputeShadows;
+}
 import * as THREE from "three";
 import { Components } from "../Components";
 import { Component } from "../Types";
@@ -44,6 +179,63 @@ export declare class Disposer extends Component {
     private disposeChildren;
     private static disposeMaterial;
 }
+import * as THREE from "three";
+import { Components } from "../Components";
+import { MeshCullerRenderer, CullerRendererSettings } from "./src";
+import { Component, Event, Disposable, World } from "../Types";
+/**
+ * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
+ */
+export declare class Cullers 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: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
+    /**
+     * An event that is triggered when the Cullers component is disposed.
+     */
+    readonly onDisposed: Event<unknown>;
+    private _enabled;
+    /**
+     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
+     */
+    list: Map<string, MeshCullerRenderer>;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@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.
+     */
+    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;
+    /**
+     * Updates the given instanced meshes inside the all the cullers. You should use this if you change the count property, e.g. when changing the visibility of fragments.
+     *
+     * @param meshes - The meshes to update.
+     *
+     * @returns {void}
+     */
+    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+}
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
@@ -86,337 +278,219 @@ export declare class Raycasters extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Disposable, Event, Components } from "../../core";
-/**
- * Types for boolean properties in IFC schema.
- */
-export type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
-/**
- * Types for string properties in IFC schema.
- */
-export type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
-/**
- * Types for numeric properties in IFC schema.
- */
-export type NumericPropTypes = "IfcInteger" | "IfcReal";
-/**
- * Interface representing a map of changed entities in a model. The keys are model UUIDs, and the values are sets of express IDs of changed entities.
- */
-export interface ChangeMap {
-    [modelID: string]: Set<number>;
-}
-/**
- * Interface representing a map of attribute listeners. The keys are model UUIDs, and the values are objects with express IDs as keys, and objects with attribute names as keys, and Event objects as values.
- */
-export interface AttributeListener {
-    [modelID: string]: {
-        [expressID: number]: {
-            [attributeName: string]: Event<String | Boolean | Number>;
-        };
-    };
-}
+import * as THREE from "three";
+import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
+import { SimplePlane } from "./src";
+import { Components } from "../Components";
 /**
- * Component to manage and edit properties and Psets in IFC files.
+ * A lightweight component to easily create, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
+ *
+ * @param components - the instance of {@link Components} used.
+ * E.g. {@link SimplePlane}.
  */
-export declare class IfcPropertiesManager extends Component implements Disposable {
+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: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
+    /** 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 triggered when a file is requested for export.
+     * Event that fires when the user starts creating a clipping plane.
      */
-    readonly onRequestFile: Event<unknown>;
+    readonly onBeforeCreate: Event<unknown>;
     /**
-     * ArrayBuffer containing the IFC data to be exported.
+     * Event that fires when the user cancels the creation of a clipping plane.
      */
-    ifcToExport: ArrayBuffer | null;
+    readonly onBeforeCancel: Event<unknown>;
     /**
-     * Event triggered when an element is added to a Pset.
+     * Event that fires after the user cancels the creation of a clipping plane.
      */
-    readonly onElementToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        elementID: number;
-    }>;
+    readonly onAfterCancel: Event<unknown>;
     /**
-     * Event triggered when a property is added to a Pset.
+     * Event that fires when the user starts deleting a clipping plane.
      */
-    readonly onPropToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        propID: number;
-    }>;
+    readonly onBeforeDelete: Event<unknown>;
     /**
-     * Event triggered when a Pset is removed.
+     * Event that fires after a clipping plane has been created.
+     * @param plane - The newly created clipping plane.
      */
-    readonly onPsetRemoved: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-    }>;
+    readonly onAfterCreate: Event<SimplePlane>;
     /**
-     * Event triggered when data in the model changes.
+     * Event that fires after a clipping plane has been deleted.
+     * @param plane - The deleted clipping plane.
      */
-    readonly onDataChanged: Event<{
-        model: FragmentsGroup;
-        expressID: number;
-    }>;
+    readonly onAfterDelete: Event<SimplePlane>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Configuration for the WebAssembly module.
+     * Whether to force the clipping plane to be orthogonal in the Y direction
+     * (up). This is desirable when clipping a building horizontally and a
+     * clipping plane is created in its roof, which might have a slight
+     * slope for draining purposes.
      */
-    wasm: {
-        path: string;
-        absolute: boolean;
-    };
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    orthogonalY: boolean;
     /**
-     * Map of attribute listeners.
+     * The tolerance that determines whether an almost-horizontal clipping plane
+     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
+     * has to be 'true' for this to apply.
      */
-    attributeListeners: AttributeListener;
+    toleranceOrthogonalY: number;
     /**
-     * The currently selected model.
+     * The type of clipping plane to be created.
+     * Default is {@link SimplePlane}.
      */
-    selectedModel?: FragmentsGroup;
+    Type: new (...args: any) => SimplePlane;
     /**
-     * Map of changed entities in the model.
+     * A list of all the clipping planes created by this component.
      */
-    changeMap: ChangeMap;
+    list: SimplePlane[];
+    /** The material used in all the clipping planes. */
+    private _material;
+    private _size;
+    private _enabled;
+    private _visible;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The material of the clipping plane representation. */
+    get material(): THREE.MeshBasicMaterial;
+    /** The material of the clipping plane representation. */
+    set material(material: THREE.MeshBasicMaterial);
+    /** The size of the geometric representation of the clippings planes. */
+    get size(): number;
+    /** The size of the geometric representation of the clippings planes. */
+    set size(size: number);
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /** {@link Createable.create} */
+    create(world: World): SimplePlane | null;
     /**
-     * Static method to retrieve the IFC schema from a given model.
-     *
-     * @param model - The FragmentsGroup model from which to retrieve the IFC schema.
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @returns The IFC schema associated with the given model.
-     */
-    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
-    /**
-     * Method to set properties data in the model.
-     *
-     * @param model - The FragmentsGroup model in which to set the properties.
-     * @param dataToSave - An array of objects representing the properties to be saved.
-     * Each object must have an 'expressID' property, which is the express ID of the entity in the model.
-     * The rest of the properties will be set as the properties of the entity.
-     *
-     * @returns A promise that resolves when all the properties have been set.
+     * Creates a plane in a certain place and with a certain orientation,
+     * without the need of the mouse.
      *
-     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'dataToSave' array.
+     * @param world - the world where this plane should be created.
+     * @param normal - the orientation of the clipping plane.
+     * @param point - the position of the clipping plane.
+     * navigation.
      */
-    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
+    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): SimplePlane;
     /**
-     * Creates a new Property Set (Pset) in the given model.
-     *
-     * @param model - The FragmentsGroup model in which to create the Pset.
-     * @param name - The name of the Pset.
-     * @param description - (Optional) The description of the Pset.
-     *
-     * @returns A promise that resolves with an object containing the newly created Pset and its relation.
+     * {@link Createable.delete}
      *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * @param world - the world where the plane to delete is.
+     * @param plane - the plane to delete. If undefined, the first plane
+     * found under the cursor will be deleted.
      */
-    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;
-    }>;
+    delete(world: World, plane?: SimplePlane): void;
     /**
-     * Removes a Property Set (Pset) from the given model.
-     *
-     * @param model - The FragmentsGroup model from which to remove the Pset.
-     * @param psetID - The express IDs of the Psets to be removed.
-     *
-     * @returns A promise that resolves when all the Psets have been removed.
+     * Deletes all the existing clipping planes.
      *
-     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'psetID' array.
-     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
-     * @throws Will throw an error if no relation is found between the Pset and the model.
+     * @param types - the types of planes to be deleted. If not provided, all planes will be deleted.
      */
-    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
+    deleteAll(types?: Set<string>): void;
+    private deletePlane;
+    private pickPlane;
+    private getAllPlaneMeshes;
+    private createPlaneFromIntersection;
+    private getWorldNormal;
+    private normalizePlaneDirectionY;
+    private newPlane;
+    private updateMaterialsAndPlanes;
+    private _onStartDragging;
+    private _onEndDragging;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { SimpleCamera } from "..";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+/**
+ * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
+ */
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
     /**
-     * Creates a new single-value property of type string in the given model.
-     *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a string property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a string.
-     *
-     * @returns The newly created single-value property.
-     *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * A ProjectionManager instance that manages the projection modes of the camera.
      */
-    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    readonly projection: ProjectionManager;
     /**
-     * Creates a new single-value property of type numeric in the given model.
-     *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a numeric property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a number.
-     *
-     * @returns The newly created single-value property.
-     *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * A THREE.OrthographicCamera instance that represents the orthographic camera.
+     * This camera is used when the projection mode is set to orthographic.
      */
-    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    readonly threeOrtho: THREE.OrthographicCamera;
     /**
-     * Creates a new single-value property of type boolean in the given model.
-     *
-     * @param model - The FragmentsGroup model in which to create the property.
-     * @param type - The type of the property value. Must be a boolean property type.
-     * @param name - The name of the property.
-     * @param value - The value of the property. Must be a boolean.
-     *
-     * @returns The newly created single-value property.
-     *
-     * @throws Will throw an error if the IFC schema is not found in the model.
-     * @throws Will throw an error if no OwnerHistory is found in the model.
+     * A THREE.PerspectiveCamera instance that represents the perspective camera.
+     * This camera is used when the projection mode is set to perspective.
      */
-    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    readonly threePersp: THREE.PerspectiveCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    protected _mode: NavigationMode | null;
+    private previousSize;
     /**
-     * Removes a property from a Property Set (Pset) in the given model.
-     *
-     * @param model - The FragmentsGroup model from which to remove the property.
-     * @param psetID - The express ID of the Pset from which to remove the property.
-     * @param propID - The express ID of the property to be removed.
+     * Getter for the current navigation mode.
+     * Throws an error if the mode is not found or the camera is not initialized.
      *
-     * @returns A promise that resolves when the property has been removed.
+     * @returns {NavigationMode} The current navigation mode.
      *
-     * @throws Will throw an error if the Pset or the property to be removed are not found in the model.
-     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
+     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
      */
-    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
-    addElementToPset(model: FragmentsGroup, psetID: number, ...expressIDs: number[]): Promise<void>;
+    get mode(): NavigationMode;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Adds elements to a Property Set (Pset) in the given model.
-     *
-     * @param model - The FragmentsGroup model in which to add the elements.
-     * @param psetID - The express ID of the Pset to which to add the elements.
-     * @param elementID - The express IDs of the elements to be added.
-     *
-     * @returns A promise that resolves when all the elements have been added.
+     * Sets a new {@link NavigationMode} and disables the previous one.
      *
-     * @throws Will throw an error if the Pset or the elements to be added are not found in the model.
-     * @throws Will throw an error if the Pset to be added to is not of type 'IFCPROPERTYSET'.
-     * @throws Will throw an error if no relation is found between the Pset and the model.
+     * @param mode - The {@link NavigationMode} to set.
      */
-    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
+    set(mode: NavModeID): void;
     /**
-     * Saves the changes made to the model to a new IFC file.
-     *
-     * @param model - The FragmentsGroup model from which to save the changes.
-     * @param ifcToSaveOn - The Uint8Array representing the original IFC file.
-     *
-     * @returns A promise that resolves with the modified IFC data as a Uint8Array.
+     * Make the camera view fit all the specified meshes.
      *
-     * @throws Will throw an error if any issues occur during the saving process.
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
      */
-    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
     /**
-     * Sets an attribute listener for a specific attribute of an entity in the model.
-     * The listener will trigger an event whenever the attribute's value changes.
-     *
-     * @param model - The FragmentsGroup model in which to set the attribute listener.
-     * @param expressID - The express ID of the entity for which to set the listener.
-     * @param attributeName - The name of the attribute for which to set the listener.
-     *
-     * @returns The event that will be triggered when the attribute's value changes.
+     * Allows or prevents all user input.
      *
-     * @throws Will throw an error if the entity with the given expressID doesn't exist.
-     * @throws Will throw an error if the attribute is an array or null, and it can't have a listener.
-     * @throws Will throw an error if the attribute has a badly defined handle.
+     * @param active - whether to enable or disable user inputs.
      */
-    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
-    private increaseMaxID;
-    private newGUID;
-    private getOwnerHistory;
-    private registerChange;
-    private newSingleProperty;
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoPerspCameraAspect;
 }
-import * as THREE from "three";
+import { Component, Disposable, World, Event } from "../Types";
+import { GridConfig, SimpleGrid } from "./src";
 import { Components } from "../Components";
-import { MeshCullerRenderer, CullerRendererSettings } from "./src";
-import { Component, Event, Disposable, World } from "../Types";
 /**
- * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
+ * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
  */
-export declare class Cullers extends Component implements Disposable {
+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: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
+    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
     /**
-     * An event that is triggered when the Cullers component is disposed.
+     * A map of world UUIDs to their corresponding grid instances.
      */
-    readonly onDisposed: Event<unknown>;
-    private _enabled;
+    list: Map<string, SimpleGrid>;
     /**
-     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
-     */
-    list: Map<string, MeshCullerRenderer>;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@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.
-     */
-    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;
-    /**
-     * Updates the given instanced meshes inside the all the cullers. You should use this if you change the count property, e.g. when changing the visibility of fragments.
-     *
-     * @param meshes - The meshes to update.
-     *
-     * @returns {void}
-     */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-}
-import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
-import { Components } from "../Components";
-/**
- * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
- */
-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.
+     * The default configuration for grid creation.
      */
     config: Required<GridConfig>;
     /** {@link Disposable.onDisposed} */
@@ -448,81 +522,52 @@ export declare class Grids extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
-import { Component, Disposable, Event } from "../Types";
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
+import { Components } from "../Components";
 /**
- * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
+ * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
  */
-export declare class Components implements Disposable {
+export declare class MiniMaps extends Component implements Updateable, Disposable {
     /**
-     * The version of the @thatopen/components library.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    static readonly release = "2.1.19";
+    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<void>;
-    /**
-     * 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.
-     * Default value is false.
-     */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
     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
+     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
      */
-    add(uuid: string, instance: Component): void;
+    list: Map<string, MiniMap>;
+    constructor(components: Components);
     /**
-     * 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.
+     * 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.
      *
-     * @internal
+     * @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.
      */
-    get<U extends Component>(Component: new (components: Components) => U): U;
-    constructor();
+    create(world: World): MiniMap;
     /**
-     * Initializes the Components instance.
-     * This method starts the animation loop, sets the enabled flag to true,
-     * and calls the update method.
+     * 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}
      */
-    init(): void;
-    /**
-     * Disposes the memory of all the components and tools of this instance of
-     * the library. A memory leak will be created if:
-     *
-     * - An instance of the library ends up out of scope and this function isn't
-     * called. This is especially relevant in Single Page Applications (React,
-     * Angular, Vue, etc).
-     *
-     * - 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
-     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     *
-     */
+    delete(id: string): void;
+    /** {@link Disposable.dispose} */
     dispose(): void;
-    private update;
-    private static setupBVH;
+    /** {@link Updateable.update} */
+    update(): void;
 }
 import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
 import { Components } from "../Components";
@@ -591,308 +636,76 @@ export declare class Worlds extends Component implements Updateable, Disposable
     /** {@link Updateable.update} */
     update(delta?: number): void | Promise<void>;
 }
-import { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
-import { Components } from "../Components";
+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";
+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";
+import { Component, Components, Disposable, Event, World } from "../core";
 /**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
+ * Configuration interface for the VertexPicker component.
  */
-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;
+export interface VertexPickerConfig {
     /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
+     * If true, only vertices will be picked, not the closest point on the face.
      */
-    list: Map<string, MiniMap>;
-    constructor(components: Components);
+    showOnlyVertex: boolean;
     /**
-     * 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.
+     * The maximum distance for snapping to a vertex.
      */
-    create(world: World): MiniMap;
+    snapDistance: number;
     /**
-     * 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}
+     * The HTML element to use for previewing the picked vertex.
      */
-    delete(id: string): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
+    previewElement: HTMLElement;
 }
-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, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
- *
- * @param components - the instance of {@link Components} used.
- * E.g. {@link SimplePlane}.
+ * A class that provides functionality for picking vertices in a 3D scene.
  */
-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";
-    /** 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>;
+export declare class VertexPicker extends Component implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * Event that fires when the user starts creating a clipping plane.
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
      */
-    readonly onBeforeCreate: Event<unknown>;
+    readonly onVertexFound: Event<THREE.Vector3>;
     /**
-     * Event that fires when the user cancels the creation of a clipping plane.
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
      */
-    readonly onBeforeCancel: Event<unknown>;
+    readonly onVertexLost: Event<THREE.Vector3>;
     /**
-     * Event that fires after the user cancels the creation of a clipping plane.
+     * An event that is triggered when the picker is enabled or disabled
      */
-    readonly onAfterCancel: Event<unknown>;
+    readonly onEnabled: Event<boolean>;
     /**
-     * Event that fires when the user starts deleting a clipping plane.
+     * A reference to the Components instance associated with this VertexPicker.
      */
-    readonly onBeforeDelete: Event<unknown>;
+    components: Components;
     /**
-     * Event that fires after a clipping plane has been created.
-     * @param plane - The newly created clipping plane.
+     * A reference to the working plane used for vertex picking.
+     * This plane is used to determine which vertices are considered valid for picking.
+     * If this value is null, all vertices are considered valid.
      */
-    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>;
-    /**
-     * Whether to force the clipping plane to be orthogonal in the Y direction
-     * (up). This is desirable when clipping a building horizontally and a
-     * clipping plane is created in its roof, which might have a slight
-     * slope for draining purposes.
-     */
-    orthogonalY: boolean;
-    /**
-     * The tolerance that determines whether an almost-horizontal clipping plane
-     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
-     * 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;
-    private _size;
-    private _enabled;
-    private _visible;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The material of the clipping plane representation. */
-    get material(): THREE.MeshBasicMaterial;
-    /** The material of the clipping plane representation. */
-    set material(material: THREE.MeshBasicMaterial);
-    /** The size of the geometric representation of the clippings planes. */
-    get size(): number;
-    /** The size of the geometric representation of the clippings planes. */
-    set size(size: number);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Createable.create} */
-    create(world: World): SimplePlane | null;
-    /**
-     * Creates a plane in a certain place and with a certain orientation,
-     * without the need of the mouse.
-     *
-     * @param world - the world where this plane should be created.
-     * @param normal - the orientation of the clipping plane.
-     * @param point - the position of the clipping plane.
-     * navigation.
-     */
-    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): SimplePlane;
-    /**
-     * {@link Createable.delete}
-     *
-     * @param world - the world where the plane to delete is.
-     * @param plane - the plane to delete. If undefined, the first plane
-     * found under the cursor will be deleted.
-     */
-    delete(world: World, plane?: SimplePlane): void;
-    /**
-     * Deletes all the existing clipping planes.
-     *
-     * @param types - the types of planes to be deleted. If not provided, all planes will be deleted.
-     */
-    deleteAll(types?: Set<string>): void;
-    private deletePlane;
-    private pickPlane;
-    private getAllPlaneMeshes;
-    private createPlaneFromIntersection;
-    private getWorldNormal;
-    private normalizePlaneDirectionY;
-    private newPlane;
-    private updateMaterialsAndPlanes;
-    private _onStartDragging;
-    private _onEndDragging;
-}
-import * as THREE from "three";
-import { Components } from "../Components";
-import { SimpleCamera } from "..";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
-/**
- * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
- */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
-    /**
-     * A ProjectionManager instance that manages the projection modes of the camera.
-     */
-    readonly projection: ProjectionManager;
-    /**
-     * A THREE.OrthographicCamera instance that represents the orthographic camera.
-     * This camera is used when the projection mode is set to orthographic.
-     */
-    readonly threeOrtho: THREE.OrthographicCamera;
-    /**
-     * A THREE.PerspectiveCamera instance that represents the perspective camera.
-     * This camera is used when the projection mode is set to perspective.
-     */
-    readonly threePersp: THREE.PerspectiveCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    protected _mode: NavigationMode | null;
-    private previousSize;
-    /**
-     * Getter for the current navigation mode.
-     * Throws an error if the mode is not found or the camera is not initialized.
-     *
-     * @returns {NavigationMode} The current navigation mode.
-     *
-     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
-     */
-    get mode(): NavigationMode;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
-     *
-     * @param mode - The {@link NavigationMode} to set.
-     */
-    set(mode: NavModeID): void;
-    /**
-     * Make the camera view fit all the specified meshes.
-     *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
-     */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
-    /**
-     * Allows or prevents all user input.
-     *
-     * @param active - whether to enable or disable user inputs.
-     */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
-}
-import * as THREE from "three";
-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";
-import { Component, Components, Disposable, Event, World } from "../core";
-/**
- * Configuration interface for the VertexPicker component.
- */
-export interface VertexPickerConfig {
-    /**
-     * If true, only vertices will be picked, not the closest point on the face.
-     */
-    showOnlyVertex: boolean;
-    /**
-     * The maximum distance for snapping to a vertex.
-     */
-    snapDistance: number;
-    /**
-     * The HTML element to use for previewing the picked vertex.
-     */
-    previewElement: HTMLElement;
-}
-/**
- * A class that provides functionality for picking vertices in a 3D scene.
- */
-export declare class VertexPicker extends Component implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a vertex is found.
-     * The event passes a THREE.Vector3 representing the position of the found vertex.
-     */
-    readonly onVertexFound: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
-     */
-    readonly onVertexLost: Event<THREE.Vector3>;
-    /**
-     * An event that is triggered when the picker is enabled or disabled
-     */
-    readonly onEnabled: Event<boolean>;
-    /**
-     * A reference to the Components instance associated with this VertexPicker.
-     */
-    components: Components;
-    /**
-     * A reference to the working plane used for vertex picking.
-     * This plane is used to determine which vertices are considered valid for picking.
-     * If this value is null, all vertices are considered valid.
-     */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
+    workingPlane: THREE.Plane | null;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
     /**
      * Sets the enabled state of the VertexPicker.
      * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
@@ -957,15 +770,30 @@ export declare class VertexPicker extends Component implements Disposable {
     private getVertices;
     private getVertex;
 }
-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 WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
+ */
+export declare class IfcJsonExporter extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    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](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";
@@ -1131,222 +959,260 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
 }
 import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Disposable, Event, Components } from "../../core";
 /**
- * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
+ * Types for boolean properties in IFC schema.
  */
-export declare class IfcJsonExporter extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    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](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>;
+export type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
+/**
+ * Types for string properties in IFC schema.
+ */
+export type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
+/**
+ * Types for numeric properties in IFC schema.
+ */
+export type NumericPropTypes = "IfcInteger" | "IfcReal";
+/**
+ * Interface representing a map of changed entities in a model. The keys are model UUIDs, and the values are sets of express IDs of changed entities.
+ */
+export interface ChangeMap {
+    [modelID: string]: Set<number>;
 }
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
 /**
- * Represents an edge measurement result.
+ * Interface representing a map of attribute listeners. The keys are model UUIDs, and the values are objects with express IDs as keys, and objects with attribute names as keys, and Event objects as values.
  */
-export interface MeasureEdge {
-    /**
-     * The distance between the two points of the edge.
-     */
-    distance: number;
-    /**
-     * The two points that define the edge.
-     */
-    points: THREE.Vector3[];
+export interface AttributeListener {
+    [modelID: string]: {
+        [expressID: number]: {
+            [attributeName: string]: Event<String | Boolean | Number>;
+        };
+    };
 }
 /**
- * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ * Component to manage and edit properties and Psets in IFC files.
  */
-export declare class MeasurementUtils extends Component {
+export declare class IfcPropertiesManager extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
+     * Event triggered when a file is requested for export.
      */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    readonly onRequestFile: Event<unknown>;
     /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
+     * ArrayBuffer containing the IFC data to be exported.
      */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
+    ifcToExport: ArrayBuffer | null;
     /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
+     * Event triggered when an element is added to a Pset.
      */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
+    readonly onElementToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        elementID: number;
+    }>;
     /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
+     * Event triggered when a property is added to a Pset.
      */
-    round(vector: THREE.Vector3): void;
+    readonly onPropToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        propID: number;
+    }>;
     /**
-     * Calculates the volume of a set of fragments.
-     *
-     * @param frags - A map of fragment IDs to their corresponding item IDs.
-     * @returns The total volume of the fragments and the bounding sphere.
-     *
-     * @remarks
-     * This method creates a set of instanced meshes from the given fragments and item IDs.
-     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
-     *
-     * @throws Will throw an error if the geometry of the meshes is not indexed.
-     * @throws Will throw an error if the fragment manager is not available.
+     * Event triggered when a Pset is removed.
      */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    readonly onPsetRemoved: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+    }>;
     /**
-     * Calculates the total volume of a set of meshes.
-     *
-     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
-     * @returns The total volume of the meshes and the bounding sphere.
-     *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
-     *
+     * Event triggered when data in the model changes.
      */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
-}
-import { Component, Disposable, Event, Components } from "../../core";
-/**
- * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
- */
-export declare class Exploder extends Component implements Disposable {
+    readonly onDataChanged: Event<{
+        model: FragmentsGroup;
+        expressID: number;
+    }>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Configuration for the WebAssembly module.
      */
-    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    wasm: {
+        path: string;
+        absolute: boolean;
+    };
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
-     * The height of the explosion animation.
-     * This property determines the vertical distance by which fragments are moved during the explosion.
-     * Default value is 10.
+     * Map of attribute listeners.
      */
-    height: number;
+    attributeListeners: AttributeListener;
     /**
-     * The group name used for the explosion animation.
-     * This property specifies the group of fragments that will be affected by the explosion.
-     * Default value is "storeys".
+     * The currently selected model.
      */
-    groupName: string;
+    selectedModel?: FragmentsGroup;
     /**
-     * A set of strings representing the exploded items.
-     * This set is used to keep track of which items have been exploded.
+     * Map of changed entities in the model.
      */
-    list: Set<string>;
+    changeMap: ChangeMap;
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * Sets the explosion state of the fragments.
+     * Static method to retrieve the IFC schema from a given model.
      *
-     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     * @param model - The FragmentsGroup model from which to retrieve the IFC schema.
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @returns The IFC schema associated with the given model.
+     */
+    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    /**
+     * Method to set properties data in the model.
      *
-     * @remarks
-     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
-     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
-     * If 'active' is false, the fragments are moved back to their original position.
+     * @param model - The FragmentsGroup model in which to set the properties.
+     * @param dataToSave - An array of objects representing the properties to be saved.
+     * Each object must have an 'expressID' property, which is the express ID of the entity in the model.
+     * The rest of the properties will be set as the properties of the entity.
      *
-     * The method also keeps track of the exploded items using the 'list' set.
+     * @returns A promise that resolves when all the properties have been set.
      *
-     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
-     */
-    set(active: boolean): void;
-}
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
-/**
- * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
- */
-export declare class Hider extends Component {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'dataToSave' array.
      */
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
     /**
-     * Sets the visibility of fragments within the 3D scene.
-     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
-     * If 'items' is provided, only the specified fragments will be affected.
+     * Creates a new Property Set (Pset) in the given model.
      *
-     * @param visible - The visibility state to set for the fragments.
-     * @param items - An optional map of fragment IDs and their corresponding sub-fragment IDs to be affected.
-     * If not provided, all fragments will be affected.
+     * @param model - The FragmentsGroup model in which to create the Pset.
+     * @param name - The name of the Pset.
+     * @param description - (Optional) The description of the Pset.
      *
-     * @returns {void}
+     * @returns A promise that resolves with an object containing the newly created Pset and its relation.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
      */
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): 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;
+    }>;
     /**
-     * Isolates fragments within the 3D scene by hiding all other fragments and showing only the specified ones.
-     * It calls the 'set' method twice: first to hide all fragments, and then to show only the specified ones.
+     * Removes a Property Set (Pset) from the given model.
      *
-     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
-     * If not provided, all fragments will be isolated.
+     * @param model - The FragmentsGroup model from which to remove the Pset.
+     * @param psetID - The express IDs of the Psets to be removed.
      *
-     * @returns {void}
+     * @returns A promise that resolves when all the Psets have been removed.
+     *
+     * @throws Will throw an error if any of the 'expressID' properties are missing in the 'psetID' array.
+     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
+     * @throws Will throw an error if no relation is found between the Pset and the model.
      */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
+    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
+    /**
+     * Creates a new single-value property of type string in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a string property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a string.
+     *
+     * @returns The newly created single-value property.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
+     */
+    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    /**
+     * Creates a new single-value property of type numeric in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a numeric property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a number.
+     *
+     * @returns The newly created single-value property.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
+     */
+    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    /**
+     * Creates a new single-value property of type boolean in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to create the property.
+     * @param type - The type of the property value. Must be a boolean property type.
+     * @param name - The name of the property.
+     * @param value - The value of the property. Must be a boolean.
+     *
+     * @returns The newly created single-value property.
+     *
+     * @throws Will throw an error if the IFC schema is not found in the model.
+     * @throws Will throw an error if no OwnerHistory is found in the model.
+     */
+    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    /**
+     * Removes a property from a Property Set (Pset) in the given model.
+     *
+     * @param model - The FragmentsGroup model from which to remove the property.
+     * @param psetID - The express ID of the Pset from which to remove the property.
+     * @param propID - The express ID of the property to be removed.
+     *
+     * @returns A promise that resolves when the property has been removed.
+     *
+     * @throws Will throw an error if the Pset or the property to be removed are not found in the model.
+     * @throws Will throw an error if the Pset to be removed is not of type 'IFCPROPERTYSET'.
+     */
+    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
+    addElementToPset(model: FragmentsGroup, psetID: number, ...expressIDs: number[]): Promise<void>;
+    /**
+     * Adds elements to a Property Set (Pset) in the given model.
+     *
+     * @param model - The FragmentsGroup model in which to add the elements.
+     * @param psetID - The express ID of the Pset to which to add the elements.
+     * @param elementID - The express IDs of the elements to be added.
+     *
+     * @returns A promise that resolves when all the elements have been added.
+     *
+     * @throws Will throw an error if the Pset or the elements to be added are not found in the model.
+     * @throws Will throw an error if the Pset to be added to is not of type 'IFCPROPERTYSET'.
+     * @throws Will throw an error if no relation is found between the Pset and the model.
+     */
+    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
+    /**
+     * Saves the changes made to the model to a new IFC file.
+     *
+     * @param model - The FragmentsGroup model from which to save the changes.
+     * @param ifcToSaveOn - The Uint8Array representing the original IFC file.
+     *
+     * @returns A promise that resolves with the modified IFC data as a Uint8Array.
+     *
+     * @throws Will throw an error if any issues occur during the saving process.
+     */
+    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Sets an attribute listener for a specific attribute of an entity in the model.
+     * The listener will trigger an event whenever the attribute's value changes.
+     *
+     * @param model - The FragmentsGroup model in which to set the attribute listener.
+     * @param expressID - The express ID of the entity for which to set the listener.
+     * @param attributeName - The name of the attribute for which to set the listener.
+     *
+     * @returns The event that will be triggered when the attribute's value changes.
+     *
+     * @throws Will throw an error if the entity with the given expressID doesn't exist.
+     * @throws Will throw an error if the attribute is an array or null, and it can't have a listener.
+     * @throws Will throw an error if the attribute has a badly defined handle.
+     */
+    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+    private increaseMaxID;
+    private newGUID;
+    private getOwnerHistory;
+    private registerChange;
+    private newSingleProperty;
 }
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
@@ -1558,6 +1424,111 @@ export declare class BoundingBoxer extends Component implements Disposable {
 }
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Represents an edge measurement result.
+ */
+export interface MeasureEdge {
+    /**
+     * The distance between the two points of the edge.
+     */
+    distance: number;
+    /**
+     * The two points that define the edge.
+     */
+    points: THREE.Vector3[];
+}
+/**
+ * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ */
+export declare class MeasurementUtils extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static uuid: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Utility method to calculate the distance from a point to a line segment.
+     *
+     * @param point - The point from which to calculate the distance.
+     * @param lineStart - The start point of the line segment.
+     * @param lineEnd - The end point of the line segment.
+     * @param clamp - If true, the distance will be clamped to the line segment's length.
+     * @returns The distance from the point to the line segment.
+     */
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    /**
+     * Method to get the face of a mesh that contains a given triangle index.
+     * It also returns the edges of the found face and their indices.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param triangleIndex - The index of the triangle within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
+     */
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    /**
+     * Method to get the vertices and normal of a mesh face at a given index.
+     * It also applies instance transformation if provided.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param faceIndex - The index of the face within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the vertices and normal of the face.
+     * @throws Will throw an error if the geometry is not indexed.
+     */
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    /**
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
+     *
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
+     */
+    round(vector: THREE.Vector3): void;
+    /**
+     * Calculates the volume of a set of fragments.
+     *
+     * @param frags - A map of fragment IDs to their corresponding item IDs.
+     * @returns The total volume of the fragments and the bounding sphere.
+     *
+     * @remarks
+     * This method creates a set of instanced meshes from the given fragments and item IDs.
+     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
+     *
+     * @throws Will throw an error if the geometry of the meshes is not indexed.
+     * @throws Will throw an error if the fragment manager is not available.
+     */
+    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    /**
+     * Calculates the total volume of a set of meshes.
+     *
+     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
+     * @returns The total volume of the meshes and the bounding sphere.
+     *
+     * @remarks
+     * This method calculates the volume of each mesh in the provided array and returns the total volume
+     * and its bounding sphere.
+     *
+     */
+    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
+    private getFaceData;
+    private getVolumeOfMesh;
+    private getSignedVolumeOfTriangle;
+}
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
 import { Disposable, Component, Event, Components } from "../../core";
 /**
  * Interface representing a classification system. The classification is organized by system and class name, and each class contains a map of fragment IDs with extra information.
@@ -1730,52 +1701,140 @@ export declare class Classifier extends Component implements Disposable {
     resetColor(items: FRAGS.FragmentIdMap): void;
     protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
 }
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
+import { Component, Disposable, Event, Components } from "../../core";
 /**
- * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
+ * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
  */
-export declare class IfcLoader extends Component implements Disposable {
+export declare class Exploder extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * An event triggered when the IFC file starts loading.
-     */
-    readonly onIfcStartedLoading: Event<void>;
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * An event triggered when the setup process is completed.
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
      */
-    readonly onSetup: Event<void>;
+    height: number;
     /**
-     * The settings for the IfcLoader.
-     * It includes options for excluding categories, setting WASM paths, and more.
+     * The group name used for the explosion animation.
+     * This property specifies the group of fragments that will be affected by the explosion.
+     * Default value is "storeys".
      */
-    settings: IfcFragmentSettings;
+    groupName: string;
     /**
-     * The instance of the Web-IFC library used for handling IFC data.
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
      */
-    webIfc: WEBIFC.IfcAPI;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _material;
-    private _spatialTree;
-    private _metaData;
-    private _fragmentInstances;
-    private _civil;
-    private _visitedFragments;
-    private _materialT;
+    list: Set<string>;
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * Sets up the IfcLoader component with the provided configuration.
+     * Sets the explosion state of the fragments.
+     *
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     *
+     * @remarks
+     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
+     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
+     * If 'active' is false, the fragments are moved back to their original position.
+     *
+     * The method also keeps track of the exploded items using the 'list' set.
+     *
+     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
+     */
+    set(active: boolean): void;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+/**
+ * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
+ */
+export declare class Hider extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Sets the visibility of fragments within the 3D scene.
+     * If no 'items' parameter is provided, all fragments will be set to the specified visibility.
+     * If 'items' is provided, only the specified fragments will be affected.
+     *
+     * @param visible - The visibility state to set for the fragments.
+     * @param items - An optional map of fragment IDs and their corresponding sub-fragment IDs to be affected.
+     * If not provided, all fragments will be affected.
+     *
+     * @returns {void}
+     */
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    /**
+     * Isolates fragments within the 3D scene by hiding all other fragments and showing only the specified ones.
+     * It calls the 'set' method twice: first to hide all fragments, and then to show only the specified ones.
+     *
+     * @param items - A map of fragment IDs and their corresponding sub-fragment IDs to be isolated.
+     * If not provided, all fragments will be isolated.
+     *
+     * @returns {void}
+     */
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
+}
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
+/**
+ * The IfcLoader component is responsible for loading and processing IFC files. It utilizes the Web-IFC library to handle the IFC data and the Three.js library for 3D rendering. The class provides methods for setting up, loading, and cleaning up IFC files. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcLoader). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcLoader).
+ */
+export declare class IfcLoader 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: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * An event triggered when the IFC file starts loading.
+     */
+    readonly onIfcStartedLoading: Event<void>;
+    /**
+     * An event triggered when the setup process is completed.
+     */
+    readonly onSetup: Event<void>;
+    /**
+     * The settings for the IfcLoader.
+     * It includes options for excluding categories, setting WASM paths, and more.
+     */
+    settings: IfcFragmentSettings;
+    /**
+     * The instance of the Web-IFC library used for handling IFC data.
+     */
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    private _material;
+    private _spatialTree;
+    private _metaData;
+    private _fragmentInstances;
+    private _civil;
+    private _visitedFragments;
+    private _materialT;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets up the IfcLoader component with the provided configuration.
      *
      * @param config - Optional configuration settings for the IfcLoader.
      * If not provided, the existing settings will be used.
@@ -1982,13 +2041,6 @@ export declare class FragmentsManager extends Component implements Disposable {
     clone(model: FRAGS.FragmentsGroup, items?: FRAGS.FragmentIdMap): FragmentsGroup;
 }
 import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
-import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
 import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
 /**
@@ -2086,48 +2138,6 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private streamAssets;
     private streamGeometries;
 }
-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>>>;
-}
-/**
- * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
- *
- * @remarks
- * This map is used to provide a mapping between IFC entity type numbers and their names.
- * It is useful for identifying and processing different types of IFC elements in a project.
- *
- */
-export declare const IfcElements: {
-    [key: number]: string;
-};
-/**
- * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
- */
-export declare const IfcCategoryMap: {
-    [key: number]: string;
-};
 import * as WEBIFC from "web-ifc";
 import { AsyncEvent, Component, Disposable, Event } from "../../core";
 import { PropertiesStreamingSettings } from "./src";
@@ -2193,10 +2203,59 @@ export declare class IfcPropertiesTiler extends Component implements Disposable
     private streamAllProperties;
     private cleanUp;
 }
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+}
 /**
  * A Set of unique numbers representing different types of IFC geometries.
  */
 export declare const GeometryTypes: Set<number>;
+/**
+ * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
+ *
+ * @remarks
+ * This map is used to provide a mapping between IFC entity type numbers and their names.
+ * It is useful for identifying and processing different types of IFC elements in a project.
+ *
+ */
+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>>>;
+}
+/**
+ * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
+ */
+export declare const IfcCategoryMap: {
+    [key: number]: string;
+};
 import * as THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 /**
@@ -2286,123 +2345,262 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     resize(size?: THREE.Vector2): void;
     private updatePlanes;
 }
-import * as FRAGS from "@thatopen/fragments";
-import * as WEBIFC from "web-ifc";
-export declare class SpatialIdsFinder {
-    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
-}
-import * as WEBIFC from "web-ifc";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
-}
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711, {
+    forRelating: InverseAttribute;
+    forRelated: InverseAttribute;
+}>;
+import * as THREE from "three";
+import { Event, World } from "../../Types";
+import { Components } from "../../Components";
 /**
- * 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.
+ * A base renderer to determine visibility on screen.
  */
-export declare class Event<T> {
+export declare class DistanceRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
      */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
+    readonly onDistanceComputed: Event<number>;
     /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
+     * Objects that won't be taken into account in the distance check.
      */
-    remove(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}
-import * as WEBIFC from "web-ifc";
-/** Configuration of the IFC-fragment conversion. */
-export declare class IfcFragmentSettings {
-    /** Whether to extract the IFC properties into a JSON. */
-    includeProperties: boolean;
+    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
     /**
-     * Generate the geometry for categories that are not included by default,
-     * like IFCSPACE.
+     * Whether this renderer is active or not. If not, it won't render anything.
      */
-    optionalCategories: number[];
-    /** Whether to use the coordination data coming from the IFC files. */
-    coordinate: boolean;
-    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    wasm: {
-        path: string;
-        absolute: boolean;
-        logLevel?: WEBIFC.LogLevel;
-    };
-    /** List of categories that won't be converted to fragments. */
-    excludedCategories: Set<number>;
-    /** Exclusive list of categories that will be converted to fragments. If this contains any category, any other categories will be ignored. */
-    includedCategories: Set<number>;
-    /** Whether to save the absolute location of all IFC items. */
-    saveLocations: boolean;
-    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    webIfc: WEBIFC.LoaderSettings;
+    enabled: boolean;
     /**
-     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * If set to true, the path will be set to the default path of the WASM file.
-     * If set to false, the path must be provided manually in the 'wasm.path' property.
-     * Default value is true.
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
      */
-    autoSetWasm: boolean;
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
     /**
-     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
-     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
-     * If set to null, the default file location handler will be used.
+     * The scene where the distance is computed.
+     */
+    scene: THREE.Scene;
+    /**
+     * The camera used to compute the distance.
+     */
+    camera: THREE.OrthographicCamera;
+    /**
+     * The material used to compute the distance.
+     */
+    depthMaterial: THREE.ShaderMaterial;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected readonly worker: Worker;
+    private _width;
+    private _height;
+    private readonly _postQuad;
+    private readonly tempRT;
+    private readonly resultRT;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    compute: () => Promise<void>;
+    private handleWorkerMessage;
+}
+import * as THREE from "three";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+/**
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
+ */
+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;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    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;
+    /**
+     * Updates the given instanced meshes inside the culler. You should use this if you change the count property, e.g. when changing the visibility of fragments.
      *
-     * @param url - The URL of the file to locate.
-     * @returns The absolute path of the file.
+     * @param meshes - The meshes to update.
+     *
+     * @returns {void}
      */
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
+}
+import * as THREE from "three";
+import { Components } from "../../Components";
+import { AsyncEvent, Event, World } from "../../Types";
+/**
+ * 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.
+ */
+export declare class CullerRenderer {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /**
+     * Fires after making the visibility check to the meshes. It lists the
+     * meshes that are currently visible, and the ones that were visible
+     * just before but not anymore.
+     */
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
+    /**
+     * 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.
+     * You can bind this to the camera movement, to a certain interval, etc.
+     */
+    needsUpdate: boolean;
+    /**
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
+     */
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** The 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;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _width;
+    private _height;
+    private _availableColor;
+    private readonly renderTarget;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * The function that the culler uses to reprocess the scene. Generally it's
+     * better to call needsUpdate, but you can also call this to force it.
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
+     */
+    updateVisibility: (force?: boolean) => Promise<void>;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    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>;
 /**
  * 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 { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
 import * as THREE from "three";
 import CameraControls from "camera-controls";
 import { Event } from "./event";
@@ -2524,52 +2722,131 @@ export declare abstract class Component extends Base {
      */
     abstract enabled: boolean;
 }
-import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
-import { Components } from "../../Components";
-/**
- * Base class of the library. Useful for finding out the interfaces something 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 * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
 }
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
-/**
- * Abstract class representing a camera in a 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;
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
+}
+import * as WEBIFC from "web-ifc";
+/** Configuration of the IFC-fragment conversion. */
+export declare class IfcFragmentSettings {
+    /** Whether to extract the IFC properties into a JSON. */
+    includeProperties: boolean;
     /**
-     * The Three.js camera instance.
+     * Generate the geometry for categories that are not included by default,
+     * like IFCSPACE.
      */
-    abstract three: THREE.Camera;
+    optionalCategories: number[];
+    /** Whether to use the coordination data coming from the IFC files. */
+    coordinate: boolean;
+    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    wasm: {
+        path: string;
+        absolute: boolean;
+        logLevel?: WEBIFC.LogLevel;
+    };
+    /** List of categories that won't be converted to fragments. */
+    excludedCategories: Set<number>;
+    /** Exclusive list of categories that will be converted to fragments. If this contains any category, any other categories will be ignored. */
+    includedCategories: Set<number>;
+    /** Whether to save the absolute location of all IFC items. */
+    saveLocations: boolean;
+    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    webIfc: WEBIFC.LoaderSettings;
     /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
+     * Whether to automatically set the path to the WASM file for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * If set to true, the path will be set to the default path of the WASM file.
+     * If set to false, the path must be provided manually in the 'wasm.path' property.
+     * Default value is true.
      */
-    abstract controls?: CameraControls;
+    autoSetWasm: boolean;
     /**
-     * Checks whether the instance is {@link CameraControllable}.
+     * Custom function to handle the file location for [web-ifc](https://github.com/ThatOpen/engine_web-ifc).
+     * This function will be called when [web-ifc](https://github.com/ThatOpen/engine_web-ifc) needs to locate a file.
+     * If set to null, the default file location handler will be used.
      *
-     * @returns True if the instance is controllable, false otherwise.
+     * @param url - The URL of the file to locate.
+     * @returns The absolute path of the file.
      */
-    hasCameraControls: () => this is CameraControllable;
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+/**
+ * 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> {
+    /**
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
+     */
+    add(handler: T extends void ? {
+        (): Promise<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 ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    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 something 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.
+ */
+export declare abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
+    /**
+     * Event that is triggered when a world is added or removed from the 'worlds' map.
+     * The event payload contains the world instance and the action ("added" or "removed").
+     */
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
+    /**
+     * The current world this item is associated with. It can be null if no world is currently active.
+     */
+    currentWorld: World | null;
+    protected constructor(components: Components);
 }
 import * as THREE from "three";
 import { Vector2 } from "three";
@@ -2636,29 +2913,6 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
      */
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
-import { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
-import { Components } from "../../Components";
-/**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
- */
-export declare abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
-    /**
-     * Event that is triggered when a world is added or removed from the 'worlds' map.
-     * The event payload contains the world instance and the action ("added" or "removed").
-     */
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
-    /**
-     * The current world this item is associated with. It can be null if no world is currently active.
-     */
-    currentWorld: World | null;
-    protected constructor(components: Components);
-}
 import * as THREE from "three";
 import { Disposable } from "./interfaces";
 import { Event } from "./event";
@@ -2675,10 +2929,92 @@ export declare abstract class BaseScene extends BaseWorldItem implements Disposa
      * It should be implemented by subclasses.
      */
     abstract three: THREE.Object3D;
+    /** The set of directional lights managed by this scene component. */
+    directionalLights: Map<string, THREE.DirectionalLight>;
+    /** The set of ambient lights managed by this scene component. */
+    ambientLights: Map<string, THREE.AmbientLight>;
     protected constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
+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 CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
+/**
+ * Abstract class representing a camera in a 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;
+    /**
+     * 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";
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
+/**
+ * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ */
+export interface World extends Disposable, Updateable {
+    /**
+     * A set of meshes present in the world. This is taken into account for operations like raycasting.
+     */
+    meshes: Set<THREE.Mesh>;
+    /**
+     * The base scene of the world.
+     */
+    scene: BaseScene;
+    /**
+     * The base camera of the world.
+     */
+    camera: BaseCamera;
+    /**
+     * The base renderer of the world. Can be null if this world doesn't use a renderer (e.g. in a backend environment).
+     */
+    renderer: BaseRenderer | null;
+    /**
+     * A unique identifier for the world.
+     */
+    uuid: string;
+    /**
+     * Indicates whether the world is currently disposing. This is useful for cancelling logic that access the elements of a world (which are also disposed).
+     */
+    isDisposing: boolean;
+}
 import { Event } from "./event";
 /**
  * A class that extends the built-in Map class and provides additional events for item set, update, delete, and clear operations.
@@ -2788,39 +3124,112 @@ export declare class DataSet<T> extends Set<T> {
      */
     dispose(): void;
 }
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
 /**
- * Represents a 3D world with meshes, scene, camera, renderer, and other properties.
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
  */
-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).
+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 { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
      */
-    isDisposing: boolean;
+    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 { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
@@ -2902,316 +3311,44 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
     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 {
-    /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is 'true'.
-     */
-    enabled: boolean;
-    /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
-     */
-    container: HTMLElement;
-    /**
-     * The THREE.js WebGLRenderer instance.
-     */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
-    /**
-     * Constructor for the SimpleRenderer class.
-     *
-     * @param components - The components instance.
-     * @param container - The HTML container where the THREE.js canvas will be rendered.
-     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
-     */
-    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Resizeable.getSize}. */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize: (size?: THREE.Vector2) => void;
-    /**
-     * 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 CameraControls from "camera-controls";
-import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
- */
-export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<SimpleCamera>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<SimpleCamera>;
-    /**
-     * 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;
-    /**
-     * The object that controls the camera. An instance of
-     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
-     * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
-     */
-    get controls(): CameraControls;
-    /**
-     * 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;
-    /**
-     * 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} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
-    /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
-     */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}
-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;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
-}
-/**
- * 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);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
-}
-import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-/**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
- */
-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;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    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;
-    /**
-     * Updates the given instanced meshes inside the culler. You should use this if you change the count property, e.g. when changing the visibility of fragments.
-     *
-     * @param meshes - The meshes to update.
-     *
-     * @returns {void}
-     */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
-}
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
-/**
- * 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.
- */
-export declare class CullerRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
-    /**
-     * 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.
-     * You can bind this to the camera movement, to a certain interval, etc.
-     */
-    needsUpdate: boolean;
+    directionalLight: {
+        color: THREE.Color;
+        intensity: number;
+        position: THREE.Vector3;
+    };
+    ambientLight: {
+        color: THREE.Color;
+        intensity: number;
+    };
+}
+/**
+ * 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;
     /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
      */
-    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;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _width;
-    private _height;
-    private _availableColor;
-    private readonly renderTarget;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    three: THREE.Scene;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<SimpleScene>;
     /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
+     * Configuration interface for the {@link SimpleScene}.
+     * Defines properties for directional and ambient lights.
      */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-    private applySettings;
+    config: Required<SimpleSceneConfig>;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
 }
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 import * as THREE from "three";
 import { Hideable, Event, World, Disposable } from "../../Types";
 import { Components } from "../../Components";
@@ -3272,113 +3409,6 @@ export declare class SimpleGrid implements Hideable, Disposable {
     private updateZoom;
 }
 import * as THREE from "three";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
-/**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
- */
-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} */
-    dispose(): void;
-    /**
-     * Throws a ray from the camera to the mouse or touch event point and returns
-     * the first item found. This also takes into account the clipping planes
-     * used by the renderer.
-     *
-     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
-     * to query. If not provided, it will query all the meshes stored in
-     * {@link Components.meshes}.
-     */
-    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;
-}
-import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
-/**
- * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
- */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
-    /**
-     * The real position of the mouse of the Three.js canvas.
-     */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private setupEvents;
-}
-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 { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
 /**
@@ -3443,141 +3473,230 @@ export declare class SimplePlane implements Disposable, Hideable {
     /** 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.
+     * 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 { Disposable, Event } from "../../Types";
+/**
+ * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
+ */
+export declare class Mouse implements Disposable {
+    dom: HTMLCanvasElement;
+    private _event?;
+    private _position;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    constructor(dom: HTMLCanvasElement);
+    /**
+     * The real position of the mouse of the Three.js canvas.
+     */
+    get position(): THREE.Vector2;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private getPositionY;
+    private getPositionX;
+    private updateMouseInfo;
+    private setupEvents;
+}
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * A basic camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. Check out it's API to find out what features it offers.
+ */
+export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<SimpleCamera>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<SimpleCamera>;
+    /**
+     * 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;
+    /**
+     * The object that controls the camera. An instance of
+     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
+     * Transforming the camera directly will have no effect: you need to use this
+     * object to move, rotate, look at objects, etc.
+     */
+    get controls(): CameraControls;
+    /**
+     * 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 {THREE.Object3D} The helper object of the clipping plane.
+     * @returns {boolean} The enabled state of the camera controls.
      */
-    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
-    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
+    get enabled(): 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.
+     * 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.
      *
-     * @returns {void}
+     * @param {boolean} enabled - The new enabled state of the camera controls.
      */
-    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
-    /** {@link Updateable.update} */
-    update: () => void;
+    set enabled(enabled: boolean);
+    constructor(components: Components);
     /** {@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;
-}
-/**
- * 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;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
     /**
-     * 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;
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
+     */
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
 import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+import { Mouse } from "./mouse";
 /**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
  */
-export declare class ProjectionManager {
-    /**
-     * Event that fires when the {@link CameraProjection} changes.
-     */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+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;
     /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
      */
-    current: CameraProjection;
+    readonly three: THREE.Raycaster;
     /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     * A reference to the world instance to which this Raycaster belongs.
+     * This is used to access the camera and meshes.
      */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     * Throws a ray from the camera to the mouse or touch event point and returns
+     * the first item found. This also takes into account the clipping planes
+     * used by the renderer.
      *
-     * @param projection - the new projection to set. If it is the current projection,
-     * it will have no effect.
+     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
+     * to query. If not provided, it will query all the meshes stored in
+     * {@link Components.meshes}.
      */
-    set(projection: CameraProjection): Promise<void>;
+    castRay(items?: THREE.Object3D[]): THREE.Intersection | null;
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * 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.
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
+    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    private intersect;
+    private filterClippingPlanes;
 }
-import { IfcFragmentSettings } from "../../IfcLoader/src";
+import * as THREE from "three";
+import { BaseRenderer, Event } from "../../Types";
+import { Components } from "../../Components";
 /**
- * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
  */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+export declare class SimpleRenderer extends BaseRenderer {
     /**
-     * Amount of properties to be streamed.
-     * Defaults to 100 properties.
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
      */
-    propertiesSize: number;
-}
-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;
+    /**
+     * The HTML container of the THREE.js canvas where the scene is rendered.
+     */
+    container: HTMLElement;
+    /**
+     * The THREE.js WebGLRenderer instance.
+     */
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
+    /**
+     * Constructor for the SimpleRenderer class.
+     *
+     * @param components - The components instance.
+     * @param container - The HTML container where the THREE.js canvas will be rendered.
+     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
+     */
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Resizeable.getSize}. */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize: (size?: THREE.Vector2) => void;
+    /**
+     * 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 { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
@@ -3595,10 +3714,16 @@ export declare class IfcStreamingSettings extends IfcFragmentSettings {
      */
     minAssetsSize: number;
 }
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+import { IfcFragmentSettings } from "../../IfcLoader/src";
+/**
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
+ */
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
+     */
+    propertiesSize: number;
 }
 import * as THREE from "three";
 import * as WEBIFC from "web-ifc";
@@ -3645,14 +3770,9 @@ 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;
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
 }
 import * as WEBIFC from "web-ifc";
 export type RelationsMap = Map<number, Map<number, number[]>>;
@@ -3680,7 +3800,8 @@ export type InverseAttributes = [
     "HasControlElements",
     "AssignedToFlowElement",
     "ConnectedTo",
-    "ConnectedFrom"
+    "ConnectedFrom",
+    "ReferencedBy"
 ];
 export type InverseAttribute = InverseAttributes[number];
 /**
@@ -3696,9 +3817,20 @@ export type IfcRelations = [
     typeof WEBIFC.IFCRELDEFINESBYTEMPLATE,
     typeof WEBIFC.IFCRELCONTAINEDINSPATIALSTRUCTURE,
     typeof WEBIFC.IFCRELFLOWCONTROLELEMENTS,
-    typeof WEBIFC.IFCRELCONNECTSELEMENTS
+    typeof WEBIFC.IFCRELCONNECTSELEMENTS,
+    typeof WEBIFC.IFCRELASSIGNSTOPRODUCT
 ];
 export type IfcRelation = IfcRelations[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 {