@thatopen/components 2.3.0-alpha.7 → 2.3.0-alpha.8

package/dist/namespace.d.ts

@@ -44,6 +44,100 @@ export declare class Disposer extends Component {
     private disposeChildren;
     private static disposeMaterial;
 }
+import { SimpleScene, SimpleSceneConfig, SimpleSceneConfigManager } from "../Worlds";
+import { DistanceRenderer } from "./src";
+import { Configurable, 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. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/ShadowedScene). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/ShadowedScene).
+ */
+export declare class ShadowedScene extends SimpleScene implements Disposable, Configurable<SimpleSceneConfigManager, ShadowedSceneConfig> {
+    private _distanceRenderer?;
+    /**
+     * Whether the bias property should be set automatically depending on the shadow distance.
+     */
+    autoBias: boolean;
+    protected _defaultShadowConfig: {
+        cascade: number;
+        resolution: number;
+    };
+    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 { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
+import { Components } from "../Components";
+import { BCFViewpoint, Viewpoint } from "./src";
+import { ViewpointsConfigManager, ViewpointsConfig } from "./src/viewpoints-config";
+export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfigManager, ViewpointsConfig> {
+    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
+    enabled: boolean;
+    /**
+     * A DataMap that stores Viewpoint instances, indexed by their unique identifiers (guid).
+     * This map is used to manage and retrieve Viewpoint instances within the Viewpoints component.
+     */
+    readonly list: DataMap<string, Viewpoint>;
+    /**
+     * Creates a new Viewpoint instance and adds it to the list.
+     *
+     * @param world - The world in which the Viewpoint will be created.
+     * @param data - Optional partial data for the Viewpoint. If not provided, default data will be used.
+     *
+     * @returns The newly created Viewpoint instance.
+     */
+    create(world: World, data?: Partial<BCFViewpoint>): Viewpoint;
+    constructor(components: Components);
+    isSetup: boolean;
+    setup(): void;
+    onSetup: Event<unknown>;
+    config: ViewpointsConfigManager;
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Disposes of the Viewpoints component and its associated resources.
+     *
+     * This method is responsible for cleaning up any resources held by the Viewpoints component,
+     * such as disposing of the DataMap of Viewpoint instances and triggering and resetting the
+     * onDisposed event.
+     */
+    dispose(): void;
+}
 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.
@@ -120,64 +214,6 @@ export declare class Components implements Disposable {
     private update;
     private static setupBVH;
 }
-import { SimpleScene, SimpleSceneConfig, SimpleSceneConfigManager } from "../Worlds";
-import { DistanceRenderer } from "./src";
-import { Configurable, 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. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/ShadowedScene). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/ShadowedScene).
- */
-export declare class ShadowedScene extends SimpleScene implements Disposable, Configurable<SimpleSceneConfigManager, ShadowedSceneConfig> {
-    private _distanceRenderer?;
-    /**
-     * Whether the bias property should be set automatically depending on the shadow distance.
-     */
-    autoBias: boolean;
-    protected _defaultShadowConfig: {
-        cascade: number;
-        resolution: number;
-    };
-    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 { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
@@ -287,195 +323,59 @@ export declare class Worlds extends Component implements Updateable, Disposable
     /** {@link Updateable.update} */
     update(delta?: number): void | Promise<void>;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleGrid } from "./src";
+import * as THREE from "three";
+import { Component, Configurable, Createable, Disposable, Event, Hideable, World } from "../Types";
+import { SimplePlane } from "./src";
 import { Components } from "../Components";
+import { ClipperConfig, ClipperConfigManager } from "./src/clipper-config";
 /**
- * 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).
+ * 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 Grids extends Component implements Disposable {
+export declare class Clipper extends Component implements Createable, Disposable, Hideable, Configurable<ClipperConfigManager, ClipperConfig> {
     /**
      * 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";
+    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** 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>;
     /**
-     * A map of world UUIDs to their corresponding grid instances.
+     * Event that fires when the user starts creating a clipping plane.
      */
-    list: Map<string, SimpleGrid>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    readonly onBeforeCreate: Event<unknown>;
     /**
-     * Creates a new grid for the given world.
-     * Throws an error if a grid already exists for the world.
-     *
-     * @param world - The world to create the grid for.
-     * @returns The newly created grid.
-     *
-     * @throws Will throw an error if a grid already exists for the given world.
+     * Event that fires when the user cancels the creation of a clipping plane.
      */
-    create(world: World): SimpleGrid;
+    readonly onBeforeCancel: Event<unknown>;
     /**
-     * Deletes the grid associated with the given world.
-     * If a grid does not exist for the given world, this method does nothing.
-     *
-     * @param world - The world for which to delete the grid.
-     *
-     * @remarks
-     * This method will dispose of the grid and remove it from the internal list.
-     * If the world is disposed before calling this method, the grid will be automatically deleted.
+     * Event that fires after the user cancels the creation of a clipping plane.
      */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}
-import { World, Component, Disposable, Event, DataMap, Configurable } from "../Types";
-import { Components } from "../Components";
-import { BCFViewpoint, Viewpoint } from "./src";
-import { ViewpointsConfigManager, ViewpointsConfig } from "./src/viewpoints-config";
-export declare class Viewpoints extends Component implements Disposable, Configurable<ViewpointsConfigManager, ViewpointsConfig> {
-    static readonly uuid: "ee867824-a796-408d-8aa0-4e5962a83c66";
-    enabled: boolean;
+    readonly onAfterCancel: Event<unknown>;
     /**
-     * A DataMap that stores Viewpoint instances, indexed by their unique identifiers (guid).
-     * This map is used to manage and retrieve Viewpoint instances within the Viewpoints component.
+     * Event that fires when the user starts deleting a clipping plane.
      */
-    readonly list: DataMap<string, Viewpoint>;
+    readonly onBeforeDelete: Event<unknown>;
     /**
-     * Creates a new Viewpoint instance and adds it to the list.
-     *
-     * @param world - The world in which the Viewpoint will be created.
-     * @param data - Optional partial data for the Viewpoint. If not provided, default data will be used.
-     *
-     * @returns The newly created Viewpoint instance.
+     * Event that fires after a clipping plane has been created.
+     * @param plane - The newly created clipping plane.
      */
-    create(world: World, data?: Partial<BCFViewpoint>): Viewpoint;
-    constructor(components: Components);
-    isSetup: boolean;
-    setup(): void;
-    onSetup: Event<unknown>;
-    config: ViewpointsConfigManager;
-    readonly onDisposed: Event<unknown>;
+    readonly onAfterCreate: Event<SimplePlane>;
     /**
-     * Disposes of the Viewpoints component and its associated resources.
-     *
-     * This method is responsible for cleaning up any resources held by the Viewpoints component,
-     * such as disposing of the DataMap of Viewpoint instances and triggering and resetting the
-     * onDisposed event.
+     * Event that fires after a clipping plane has been deleted.
+     * @param plane - The deleted clipping plane.
      */
-    dispose(): void;
-}
-import * as THREE from "three";
-import { Components } from "../Components";
-import { MeshCullerRenderer } 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.
-     *
-     * @returns The newly created or existing MeshCullerRenderer for the given world.
-     */
-    create(world: World): 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.
-     *
-     */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-}
-import * as THREE from "three";
-import { Component, Configurable, Createable, Disposable, Event, Hideable, World } from "../Types";
-import { SimplePlane } from "./src";
-import { Components } from "../Components";
-import { ClipperConfig, ClipperConfigManager } from "./src/clipper-config";
-/**
- * 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 Clipper extends Component implements Createable, Disposable, Hideable, Configurable<ClipperConfigManager, ClipperConfig> {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onBeforeDrag: Event<void>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onAfterDrag: Event<void>;
-    /**
-     * Event that fires when the user starts creating a clipping plane.
-     */
-    readonly onBeforeCreate: Event<unknown>;
-    /**
-     * Event that fires when the user cancels the creation of a clipping plane.
-     */
-    readonly onBeforeCancel: Event<unknown>;
-    /**
-     * Event that fires after the user cancels the creation of a clipping plane.
-     */
-    readonly onAfterCancel: Event<unknown>;
-    /**
-     * Event that fires when the user starts deleting a clipping plane.
-     */
-    readonly onBeforeDelete: Event<unknown>;
-    /**
-     * Event that fires after a clipping plane has been created.
-     * @param plane - The newly created clipping plane.
-     */
-    readonly onAfterCreate: Event<SimplePlane>;
-    /**
-     * Event that fires after a clipping plane has been deleted.
-     * @param plane - The deleted clipping plane.
-     */
-    readonly onAfterDelete: Event<SimplePlane>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
+    readonly onAfterDelete: Event<SimplePlane>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
     /**
      * Whether to force the clipping plane to be orthogonal in the Y direction
      * (up). This is desirable when clipping a building horizontally and a
@@ -564,18 +464,6 @@ export declare class Clipper extends Component implements Createable, Disposable
     private _onStartDragging;
     private _onEndDragging;
 }
-import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
 import { MiniMap } from "./src";
 import { Component, Updateable, World, Event, Disposable } from "../Types";
 import { Components } from "../Components";
@@ -623,12 +511,6 @@ export declare class MiniMaps extends Component implements Updateable, Disposabl
     /** {@link Updateable.update} */
     update(): void;
 }
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
 import * as THREE from "three";
 import { Components } from "../Components";
 import { SimpleCamera } from "..";
@@ -693,27 +575,59 @@ export declare class OrthoPerspectiveCamera extends SimpleCamera {
     private newOrthoCamera;
     private setOrthoPerspCameraAspect;
 }
-import { Component, DataSet } from "../Types";
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleGrid } from "./src";
 import { Components } from "../Components";
-import { Configurator } from "./src";
 /**
- * A tool to manage all the configuration from the app centrally.
+ * 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 ConfigManager extends Component {
+export declare class Grids extends Component implements Disposable {
     /**
-     * The list of all configurations of this app.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    list: DataSet<Configurator<any, any>>;
+    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    /**
+     * A map of world UUIDs to their corresponding grid instances.
+     */
+    list: Map<string, SimpleGrid>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /** {@link Component.enabled} */
     enabled: boolean;
+    constructor(components: Components);
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Creates a new grid for the given world.
+     * Throws an error if a grid already exists for the world.
+     *
+     * @param world - The world to create the grid for.
+     * @returns The newly created grid.
+     *
+     * @throws Will throw an error if a grid already exists for the given world.
      */
-    static readonly uuid: "b8c764e0-6b24-4e77-9a32-35fa728ee5b4";
-    constructor(components: Components);
+    create(world: World): SimpleGrid;
+    /**
+     * Deletes the grid associated with the given world.
+     * If a grid does not exist for the given world, this method does nothing.
+     *
+     * @param world - The world for which to delete the grid.
+     *
+     * @remarks
+     * This method will dispose of the grid and remove it from the internal list.
+     * If the world is disposed before calling this method, the grid will be automatically deleted.
+     */
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
 }
 import * as THREE from "three";
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
+};
+import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Component, Components, Disposable, Event } from "../../core";
@@ -921,90 +835,120 @@ export declare class BoundingBoxer extends Component implements Disposable {
     addFragmentIdMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
     private static getFragmentBounds;
 }
-import { Component, Disposable, Event, Components } from "../../core";
+import { Component, DataSet } from "../Types";
+import { Components } from "../Components";
+import { Configurator } from "./src";
 /**
- * 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).
+ * A tool to manage all the configuration from the app centrally.
  */
-export declare class Exploder extends Component implements Disposable {
+export declare class ConfigManager extends Component {
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * The list of all configurations of this app.
      */
-    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    list: DataSet<Configurator<any, any>>;
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
-     * The height of the explosion animation.
-     * This property determines the vertical distance by which fragments are moved during the explosion.
-     * Default value is 10.
-     */
-    height: number;
-    /**
-     * The group name used for the explosion animation.
-     * This property specifies the group of fragments that will be affected by the explosion.
-     * Default value is "storeys".
-     */
-    groupName: string;
-    /**
-     * A set of strings representing the exploded items.
-     * This set is used to keep track of which items have been exploded.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    list: Set<string>;
+    static readonly uuid: "b8c764e0-6b24-4e77-9a32-35fa728ee5b4";
     constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets the explosion state of the fragments.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the explosion.
-     *
-     * @remarks
-     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
-     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
-     * If 'active' is false, the fragments are moved back to their original position.
-     *
-     * The method also keeps track of the exploded items using the 'list' set.
-     *
-     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
-     */
-    set(active: boolean): void;
 }
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
 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.
- */
-export interface Classification {
-    /**
-     * A system within the classification.
-     * The key is the system name, and the value is an object representing the classes within the system.
-     */
-    [system: string]: {
-        /**
-         * A class within the system.
-         * The key is the class name, and the value is an object containing a map of fragment IDs with extra information.
-         */
-        [className: string]: {
-            map: FRAGS.FragmentIdMap;
-            name: string;
-            id: number | null;
-        };
-    };
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
 }
+import * as THREE from "three";
+import { Components } from "../Components";
+import { MeshCullerRenderer } from "./src";
+import { Component, Event, Disposable, World } from "../Types";
 /**
- * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ * 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 Classifier extends Component implements Disposable {
+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: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    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.
+     *
+     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     */
+    create(world: World): 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.
+     *
+     */
+    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+}
+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.
+ */
+export interface Classification {
+    /**
+     * A system within the classification.
+     * The key is the system name, and the value is an object representing the classes within the system.
+     */
+    [system: string]: {
+        /**
+         * A class within the system.
+         * The key is the class name, and the value is an object containing a map of fragment IDs with extra information.
+         */
+        [className: string]: {
+            map: FRAGS.FragmentIdMap;
+            name: string;
+            id: number | null;
+        };
+    };
+}
+/**
+ * The Classifier component is responsible for classifying and categorizing fragments based on various criteria. It provides methods to add, remove, find, and filter fragments based on their classification. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Classifier). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Classifier).
+ */
+export declare class Classifier 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: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
      * A map representing the classification systems.
      * The key is the system name, and the value is an object representing the classes within the system.
@@ -1145,172 +1089,237 @@ 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 { Components, Disposable, Event, Component } from "../../core";
-import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
+import { Component, Disposable, Event, Components } from "../../core";
 /**
- * A component that handles the tiling of IFC geometries for efficient streaming. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcGeometryTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcGeometryTiler).
+ * 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 IfcGeometryTiler 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: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
-    /**
-     * Event triggered when geometry is streamed.
-     * Contains the streamed geometry data and its buffer.
-     */
-    readonly onGeometryStreamed: Event<{
-        buffer: Uint8Array;
-        data: StreamedGeometries;
-    }>;
-    /**
-     * Event triggered when assets are streamed.
-     * Contains the streamed assets.
-     */
-    readonly onAssetStreamed: Event<StreamedAsset[]>;
-    /**
-     * Event triggered to indicate the progress of the streaming process.
-     * Contains the progress percentage.
-     */
-    readonly onProgress: Event<number>;
-    /**
-     * Event triggered when the IFC file is loaded.
-     * Contains the loaded IFC file data.
-     */
-    readonly onIfcLoaded: Event<Uint8Array>;
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
-    /**
-     * Settings for the IfcGeometryTiler.
-     */
-    settings: IfcStreamingSettings;
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
-     * The WebIFC API instance used for IFC file processing.
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
      */
-    webIfc: WEBIFC.IfcAPI;
-    private _nextAvailableID;
-    private _splittedGeometries;
-    private _spatialTree;
-    private _metaData;
-    private _visitedGeometries;
-    private _streamSerializer;
-    private _geometries;
-    private _geometryCount;
-    private _civil;
-    private _groupSerializer;
-    private _assets;
-    private _meshesWithHoles;
+    height: number;
+    /**
+     * The group name used for the explosion animation.
+     * This property specifies the group of fragments that will be affected by the explosion.
+     * Default value is "storeys".
+     */
+    groupName: string;
+    /**
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
+     */
+    list: Set<string>;
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * This method streams the IFC file from a given buffer.
+     * Sets the explosion state of the fragments.
      *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
      *
      * @remarks
-     * This method cleans up any resources after the streaming process is complete.
-     *
-     * @example
-     * '''typescript
-     * const ifcData = await fetch('path/to/ifc/file.ifc');
-     * const rawBuffer = await response.arrayBuffer();
-     * const ifcBuffer = new Uint8Array(rawBuffer);
-     * await ifcGeometryTiler.streamFromBuffer(ifcBuffer);
-     * '''
-     */
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    /**
-     * This method streams the IFC file from a given callback.
-     *
-     * @param loadCallback - The callback function that will be used to load the IFC file.
-     * @returns A Promise that resolves when the streaming process is complete.
+     * 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.
      *
-     * @remarks
-     * This method cleans up any resources after the streaming process is complete.
+     * 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.
      */
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllGeometries;
-    private cleanUp;
-    private getMesh;
-    private getGeometry;
-    private streamAssets;
-    private streamGeometries;
-    private registerGeometryData;
+    set(active: boolean): 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 * as THREE from "three";
+import { Component, Components, Disposable, Event, World } 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).
+ * Configuration interface for the VertexPicker component.
  */
-export declare class IfcLoader extends Component implements Disposable {
+export interface VertexPickerConfig {
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * If true, only vertices will be picked, not the closest point on the face.
      */
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    showOnlyVertex: boolean;
     /**
-     * An event triggered when the IFC file starts loading.
+     * The maximum distance for snapping to a vertex.
      */
-    readonly onIfcStartedLoading: Event<void>;
+    snapDistance: number;
     /**
-     * An event triggered when the setup process is completed.
+     * The HTML element to use for previewing the picked vertex.
      */
-    readonly onSetup: Event<void>;
+    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>;
     /**
-     * The settings for the IfcLoader.
-     * It includes options for excluding categories, setting WASM paths, and more.
+     * An event that is triggered when a vertex is found.
+     * The event passes a THREE.Vector3 representing the position of the found vertex.
      */
-    settings: IfcFragmentSettings;
+    readonly onVertexFound: Event<THREE.Vector3>;
     /**
-     * The instance of the Web-IFC library used for handling IFC data.
+     * An event that is triggered when a vertex is lost.
+     * The event passes a THREE.Vector3 representing the position of the lost vertex.
      */
-    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;
+    readonly onVertexLost: Event<THREE.Vector3>;
     /**
-     * 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.
-     *
-     * @returns A Promise that resolves when the setup process is completed.
-     *
-     * @remarks
-     * If the 'autoSetWasm' option is enabled in the configuration,
-     * the method will automatically set the WASM paths for the Web-IFC library.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = new IfcLoader(components);
-     * await ifcLoader.setup({ autoSetWasm: true });
-     * '''
+     * An event that is triggered when the picker is enabled or disabled
      */
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    readonly onEnabled: Event<boolean>;
     /**
-     * Loads an IFC file and processes it for 3D visualization.
+     * 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;
+    /**
+     * Sets the enabled state of the VertexPicker.
+     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
+     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
+     *
+     * @param value - The new enabled state.
+     */
+    set enabled(value: boolean);
+    /**
+     * Gets the current enabled state of the VertexPicker.
+     *
+     * @returns The current enabled state.
+     */
+    get enabled(): boolean;
+    /**
+     * Sets the configuration for the VertexPicker component.
+     *
+     * @param value - A Partial object containing the configuration properties to update.
+     * The properties not provided in the value object will retain their current values.
+     *
+     * @example
+     * '''typescript
+     * vertexPicker.config = {
+     *   snapDistance: 0.5,
+     *   showOnlyVertex: true,
+     * };
+     * '''
+     */
+    set config(value: Partial<VertexPickerConfig>);
+    /**
+     * Gets the current configuration for the VertexPicker component.
+     *
+     * @returns A copy of the current VertexPickerConfig object.
+     *
+     * @example
+     * '''typescript
+     * const currentConfig = vertexPicker.config;
+     * console.log(currentConfig.snapDistance); // Output: 0.25
+     * '''
+     */
+    get config(): Partial<VertexPickerConfig>;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Performs the vertex picking operation based on the current state of the VertexPicker.
+     *
+     * @param world - The World instance to use for raycasting.
+     *
+     * @returns The current picked point, or null if no point is picked.
+     *
+     * @remarks
+     * This method checks if the VertexPicker is enabled. If not, it returns the current picked point.
+     * If enabled, it performs raycasting to find the closest intersecting object.
+     * It then determines the closest vertex or point on the face, based on the configuration settings.
+     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
+     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
+     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
+     */
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+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.
+     *
+     * @returns A Promise that resolves when the setup process is completed.
+     *
+     * @remarks
+     * If the 'autoSetWasm' option is enabled in the configuration,
+     * the method will automatically set the WASM paths for the Web-IFC library.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = new IfcLoader(components);
+     * await ifcLoader.setup({ autoSetWasm: true });
+     * '''
+     */
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    /**
+     * Loads an IFC file and processes it for 3D visualization.
      *
      * @param data - The Uint8Array containing the IFC file data.
      * @param coordinate - Optional boolean indicating whether to coordinate the loaded IFC data. Default is true.
@@ -1361,43 +1370,70 @@ export declare class IfcLoader extends Component implements Disposable {
     private getGeometry;
     private autoSetWasm;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
+import * as WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "./src";
 /**
- * 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).
+ * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
  */
-export declare class Hider extends Component {
+export declare class IfcPropertiesTiler 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: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    /**
+     * An event that is triggered when properties are streamed from the IFC file.
+     * The event provides the type of the IFC entity and the corresponding data.
+     */
+    readonly onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
+    }>;
+    /**
+     * An event that is triggered to indicate the progress of the streaming process.
+     * The event provides a number between 0 and 1 representing the progress percentage.
+     */
+    readonly onProgress: AsyncEvent<number>;
+    /**
+     * An event that is triggered when indices are streamed from the IFC file.
+     * The event provides a map of indices, where the key is the entity type and the value is another map of indices.
+     */
+    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /** {@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}
+     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
      */
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    settings: PropertiesStreamingSettings;
     /**
-     * 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.
+     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
+     */
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Disposable.dispose} */
+    dispose(): Promise<void>;
+    /**
+     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
      *
-     * @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 data - The Uint8Array containing the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
+     */
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    /**
+     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
      *
-     * @returns {void}
+     * @param loadCallback - A callback function that loads the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
      */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private cleanUp;
 }
 import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
@@ -1544,295 +1580,254 @@ export declare class FragmentsManager extends Component implements Disposable {
     clone(model: FRAGS.FragmentsGroup, items?: FRAGS.FragmentIdMap): FragmentsGroup;
 }
 import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../core";
-import { PropertiesStreamingSettings } from "./src";
+import { Components, Disposable, Event, Component } from "../../core";
+import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
 /**
- * A component that converts the properties of an IFC file to tiles. It uses the Web-IFC library to read and process the IFC data. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcPropertiesTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcPropertiesTiler).
+ * A component that handles the tiling of IFC geometries for efficient streaming. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcGeometryTiler). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcGeometryTiler).
  */
-export declare class IfcPropertiesTiler extends Component implements Disposable {
+export declare class IfcGeometryTiler 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: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    static readonly uuid: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
     /**
-     * An event that is triggered when properties are streamed from the IFC file.
-     * The event provides the type of the IFC entity and the corresponding data.
+     * Event triggered when geometry is streamed.
+     * Contains the streamed geometry data and its buffer.
      */
-    readonly onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
+    readonly onGeometryStreamed: Event<{
+        buffer: Uint8Array;
+        data: StreamedGeometries;
     }>;
     /**
-     * An event that is triggered to indicate the progress of the streaming process.
-     * The event provides a number between 0 and 1 representing the progress percentage.
+     * Event triggered when assets are streamed.
+     * Contains the streamed assets.
      */
-    readonly onProgress: AsyncEvent<number>;
+    readonly onAssetStreamed: Event<StreamedAsset[]>;
     /**
-     * An event that is triggered when indices are streamed from the IFC file.
-     * The event provides a map of indices, where the key is the entity type and the value is another map of indices.
+     * Event triggered to indicate the progress of the streaming process.
+     * Contains the progress percentage.
      */
-    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    readonly onProgress: Event<number>;
     /**
-     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
+     * Event triggered when the IFC file is loaded.
+     * Contains the loaded IFC file data.
      */
-    settings: PropertiesStreamingSettings;
+    readonly onIfcLoaded: Event<Uint8Array>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
+     * Settings for the IfcGeometryTiler.
+     */
+    settings: IfcStreamingSettings;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * The WebIFC API instance used for IFC file processing.
      */
     webIfc: WEBIFC.IfcAPI;
+    private _nextAvailableID;
+    private _splittedGeometries;
+    private _spatialTree;
+    private _metaData;
+    private _visitedGeometries;
+    private _streamSerializer;
+    private _geometries;
+    private _geometryCount;
+    private _civil;
+    private _groupSerializer;
+    private _assets;
+    private _meshesWithHoles;
+    constructor(components: Components);
     /** {@link Disposable.dispose} */
-    dispose(): Promise<void>;
+    dispose(): void;
     /**
-     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
+     * This method streams the IFC file from a given buffer.
      *
      * @param data - The Uint8Array containing the IFC file data.
      * @returns A Promise that resolves when the streaming process is complete.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
+     * @example
+     * '''typescript
+     * const ifcData = await fetch('path/to/ifc/file.ifc');
+     * const rawBuffer = await response.arrayBuffer();
+     * const ifcBuffer = new Uint8Array(rawBuffer);
+     * await ifcGeometryTiler.streamFromBuffer(ifcBuffer);
+     * '''
      */
     streamFromBuffer(data: Uint8Array): Promise<void>;
     /**
-     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
+     * This method streams the IFC file from a given callback.
      *
-     * @param loadCallback - A callback function that loads the IFC file data.
+     * @param loadCallback - The callback function that will be used to load the IFC file.
      * @returns A Promise that resolves when the streaming process is complete.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
      */
     streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
     private readIfcFile;
     private streamIfcFile;
-    private streamAllProperties;
+    private streamAllGeometries;
     private cleanUp;
+    private getMesh;
+    private getGeometry;
+    private streamAssets;
+    private streamGeometries;
+    private registerGeometryData;
 }
-import * as THREE from "three";
-import { Component, Components, Disposable, Event, World } from "../core";
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
 /**
- * Configuration interface for the VertexPicker component.
+ * 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 interface VertexPickerConfig {
+export declare class Hider extends Component {
     /**
-     * If true, only vertices will be picked, not the closest point on the face.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    showOnlyVertex: boolean;
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
     /**
-     * The maximum distance for snapping to a vertex.
+     * 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}
      */
-    snapDistance: number;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
     /**
-     * The HTML element to use for previewing the picked vertex.
+     * 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}
      */
-    previewElement: HTMLElement;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
+}
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
 }
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components } from "../../core";
 /**
- * A class that provides functionality for picking vertices in a 3D scene.
+ * Represents an edge measurement result.
  */
-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>;
+export interface MeasureEdge {
     /**
-     * An event that is triggered when a vertex is lost.
-     * The event passes a THREE.Vector3 representing the position of the lost vertex.
+     * The distance between the two points of the edge.
      */
-    readonly onVertexLost: Event<THREE.Vector3>;
+    distance: number;
     /**
-     * An event that is triggered when the picker is enabled or disabled
+     * The two points that define the edge.
      */
-    readonly onEnabled: Event<boolean>;
+    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 reference to the Components instance associated with this VertexPicker.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    components: Components;
+    static uuid: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(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.
+     * 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.
      */
-    workingPlane: THREE.Plane | null;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
     /**
-     * Sets the enabled state of the VertexPicker.
-     * When enabled, the VertexPicker will actively search for vertices in the 3D scene.
-     * When disabled, the VertexPicker will stop searching for vertices and reset the picked point.
+     * 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 value - The new enabled state.
+     * @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.
      */
-    set enabled(value: boolean);
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
     /**
-     * Gets the current enabled state of the VertexPicker.
+     * Method to get the vertices and normal of a mesh face at a given index.
+     * It also applies instance transformation if provided.
      *
-     * @returns The current enabled state.
+     * @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.
      */
-    get enabled(): boolean;
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
     /**
-     * Sets the configuration for the VertexPicker component.
-     *
-     * @param value - A Partial object containing the configuration properties to update.
-     * The properties not provided in the value object will retain their current values.
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
      *
-     * @example
-     * '''typescript
-     * vertexPicker.config = {
-     *   snapDistance: 0.5,
-     *   showOnlyVertex: true,
-     * };
-     * '''
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
      */
-    set config(value: Partial<VertexPickerConfig>);
+    round(vector: THREE.Vector3): void;
     /**
-     * Gets the current configuration for the VertexPicker component.
+     * Calculates the volume of a set of fragments.
      *
-     * @returns A copy of the current VertexPickerConfig object.
+     * @param frags - A map of fragment IDs to their corresponding item IDs.
+     * @returns The total volume of the fragments and the bounding sphere.
      *
-     * @example
-     * '''typescript
-     * const currentConfig = vertexPicker.config;
-     * console.log(currentConfig.snapDistance); // Output: 0.25
-     * '''
+     * @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.
      */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
     /**
-     * Performs the vertex picking operation based on the current state of the VertexPicker.
-     *
-     * @param world - The World instance to use for raycasting.
+     * Calculates the total volume of a set of meshes.
      *
-     * @returns The current picked point, or null if no point is picked.
+     * @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 checks if the VertexPicker is enabled. If not, it returns the current picked point.
-     * If enabled, it performs raycasting to find the closest intersecting object.
-     * It then determines the closest vertex or point on the face, based on the configuration settings.
-     * If the picked point is on the working plane (if defined), it triggers the 'onVertexFound' event and updates the 'pickedPoint'.
-     * If the picked point is not on the working plane, it resets the 'pickedPoint'.
-     * If no intersecting object is found, it triggers the 'onVertexLost' event and resets the 'pickedPoint'.
+     * This method calculates the volume of each mesh in the provided array and returns the total volume
+     * and its bounding sphere.
+     *
      */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
-}
-import { XMLParser } from "fast-xml-parser";
-import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core";
-import { BCFTopic, Topic, BCFTopicsConfigManager, BCFTopicsConfig } from "./src";
-import { Viewpoint } from "../../core/Viewpoints";
-export declare class BCFTopics extends Component implements Disposable, Configurable<BCFTopicsConfigManager, BCFTopicsConfig> {
-    static uuid: "de977976-e4f6-4e4f-a01a-204727839802";
-    enabled: boolean;
-    static xmlParser: XMLParser;
-    protected _defaultConfig: Required<BCFTopicsConfig>;
-    config: BCFTopicsConfigManager;
-    readonly list: DataMap<string, Topic>;
-    readonly onSetup: Event<unknown>;
-    isSetup: boolean;
-    setup(config?: Partial<BCFTopicsConfig>): void;
-    readonly onBCFImported: Event<Topic[]>;
-    /**
-     * Creates a new BCFTopic instance and adds it to the list.
-     *
-     * @param data - Optional partial BCFTopic object to initialize the new topic with.
-     * If not provided, default values will be used.
-     * @returns The newly created BCFTopic instance.
-     */
-    create(data?: Partial<BCFTopic>): Topic;
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Disposes of the BCFTopics component and triggers the onDisposed event.
-     *
-     * @remarks
-     * This method clears the list of topics and triggers the onDisposed event.
-     * It also resets the onDisposed event listener.
-     */
-    dispose(): void;
-    /**
-     * Retrieves the unique set of topic types used across all topics.
-     *
-     * @returns A Set containing the unique topic types.
-     */
-    get usedTypes(): Set<string>;
-    /**
-     * Retrieves the unique set of topic statuses used across all topics.
-     *
-     * @returns A Set containing the unique topic statuses.
-     */
-    get usedStatuses(): Set<string>;
-    /**
-     * Retrieves the unique set of topic priorities used across all topics.
-     *
-     * @returns A Set containing the unique topic priorities.
-     * Note: This method filters out any null or undefined priorities.
-     */
-    get usedPriorities(): Set<string | undefined>;
-    /**
-     * Retrieves the unique set of topic stages used across all topics.
-     *
-     * @returns A Set containing the unique topic stages.
-     * Note: This method filters out any null or undefined stages.
-     */
-    get usedStages(): Set<string | undefined>;
-    /**
-     * Retrieves the unique set of users associated with topics.
-     *
-     * @returns A Set containing the unique users.
-     * Note: This method collects users from the creation author, assigned to, modified author, and comment authors.
-     */
-    get usedUsers(): Set<string>;
-    /**
-     * Retrieves the unique set of labels used across all topics.
-     *
-     * @returns A Set containing the unique labels.
-     */
-    get usedLabels(): Set<string>;
-    /**
-     * Updates the set of extensions (types, statuses, priorities, labels, stages, users) based on the current topics.
-     * This method iterates through each topic in the list and adds its properties to the corresponding sets in the config.
-     */
-    updateExtensions(): void;
-    /**
-     * Updates the references to viewpoints in the topics.
-     * This function iterates through each topic and checks if the viewpoints exist in the viewpoints list.
-     * If a viewpoint does not exist, it is removed from the topic's viewpoints.
-     */
-    updateViewpointReferences(): void;
-    /**
-     * Exports the given topics to a BCF (Building Collaboration Format) zip file.
-     *
-     * @param topics - The topics to export. Defaults to all topics in the list.
-     * @returns A promise that resolves to a Blob containing the exported BCF zip file.
-     */
-    export(topics?: Iterable<Topic>): Promise<Blob>;
-    private serializeExtensions;
-    private processMarkupComment;
-    private getMarkupComments;
-    private getMarkupLabels;
-    private getMarkupViewpoints;
-    private getMarkupRelatedTopics;
-    /**
-     * Loads BCF (Building Collaboration Format) data into the engine.
-     *
-     * @param world - The default world where the viewpoints are going to be created.
-     * @param data - The BCF data to load.
-     *
-     * @returns A promise that resolves to an object containing the created viewpoints and topics.
-     *
-     * @throws An error if the BCF version is not supported.
-     */
-    load(data: Uint8Array, world: World): Promise<{
-        viewpoints: Viewpoint[];
-        topics: Topic[];
-    }>;
+    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
+    private getFaceData;
+    private getVolumeOfMesh;
+    private getSignedVolumeOfTriangle;
 }
 import * as WEBIFC from "web-ifc";
 import * as FRAG from "@thatopen/fragments";
@@ -2034,134 +2029,116 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      */
     getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
 }
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Represents an edge measurement result.
- */
-export interface MeasureEdge {
+import { XMLParser } from "fast-xml-parser";
+import { Component, Configurable, Disposable, Event, World, DataMap } from "../../core";
+import { BCFTopic, Topic, BCFTopicsConfigManager, BCFTopicsConfig } from "./src";
+import { Viewpoint } from "../../core/Viewpoints";
+export declare class BCFTopics extends Component implements Disposable, Configurable<BCFTopicsConfigManager, BCFTopicsConfig> {
+    static uuid: "de977976-e4f6-4e4f-a01a-204727839802";
+    enabled: boolean;
+    static xmlParser: XMLParser;
+    protected _defaultConfig: Required<BCFTopicsConfig>;
+    config: BCFTopicsConfigManager;
+    readonly list: DataMap<string, Topic>;
+    readonly onSetup: Event<unknown>;
+    isSetup: boolean;
+    setup(config?: Partial<BCFTopicsConfig>): void;
+    readonly onBCFImported: Event<Topic[]>;
     /**
-     * The distance between the two points of the edge.
+     * Creates a new BCFTopic instance and adds it to the list.
+     *
+     * @param data - Optional partial BCFTopic object to initialize the new topic with.
+     * If not provided, default values will be used.
+     * @returns The newly created BCFTopic instance.
      */
-    distance: number;
+    create(data?: Partial<BCFTopic>): Topic;
+    readonly onDisposed: Event<unknown>;
     /**
-     * The two points that define the edge.
+     * Disposes of the BCFTopics component and triggers the onDisposed event.
+     *
+     * @remarks
+     * This method clears the list of topics and triggers the onDisposed event.
+     * It also resets the onDisposed event listener.
      */
-    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 {
+    dispose(): void;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Retrieves the unique set of topic types used across all topics.
+     *
+     * @returns A Set containing the unique topic types.
      */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    get usedTypes(): Set<string>;
     /**
-     * Utility method to calculate the distance from a point to a line segment.
+     * Retrieves the unique set of topic statuses used across all topics.
      *
-     * @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.
+     * @returns A Set containing the unique topic statuses.
      */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    get usedStatuses(): Set<string>;
     /**
-     * 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.
+     * Retrieves the unique set of topic priorities used across all topics.
      *
-     * @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.
+     * @returns A Set containing the unique topic priorities.
+     * Note: This method filters out any null or undefined priorities.
      */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
+    get usedPriorities(): Set<string | undefined>;
     /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
+     * Retrieves the unique set of topic stages used across all topics.
      *
-     * @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.
+     * @returns A Set containing the unique topic stages.
+     * Note: This method filters out any null or undefined stages.
      */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
+    get usedStages(): Set<string | undefined>;
     /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
+     * Retrieves the unique set of users associated with topics.
      *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
+     * @returns A Set containing the unique users.
+     * Note: This method collects users from the creation author, assigned to, modified author, and comment authors.
      */
-    round(vector: THREE.Vector3): void;
+    get usedUsers(): Set<string>;
     /**
-     * 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.
+     * Retrieves the unique set of labels used across all topics.
      *
-     * @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.
+     * @returns A Set containing the unique labels.
+     */
+    get usedLabels(): Set<string>;
+    /**
+     * Updates the set of extensions (types, statuses, priorities, labels, stages, users) based on the current topics.
+     * This method iterates through each topic in the list and adds its properties to the corresponding sets in the config.
+     */
+    updateExtensions(): void;
+    /**
+     * Updates the references to viewpoints in the topics.
+     * This function iterates through each topic and checks if the viewpoints exist in the viewpoints list.
+     * If a viewpoint does not exist, it is removed from the topic's viewpoints.
+     */
+    updateViewpointReferences(): void;
+    /**
+     * Exports the given topics to a BCF (Building Collaboration Format) zip file.
      *
-     * @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.
+     * @param topics - The topics to export. Defaults to all topics in the list.
+     * @returns A promise that resolves to a Blob containing the exported BCF zip file.
      */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    export(topics?: Iterable<Topic>): Promise<Blob>;
+    private serializeExtensions;
+    private processMarkupComment;
+    private getMarkupComments;
+    private getMarkupLabels;
+    private getMarkupViewpoints;
+    private getMarkupRelatedTopics;
     /**
-     * Calculates the total volume of a set of meshes.
+     * Loads BCF (Building Collaboration Format) data into the engine.
      *
-     * @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.
+     * @param world - The default world where the viewpoints are going to be created.
+     * @param data - The BCF data to load.
      *
-     * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
+     * @returns A promise that resolves to an object containing the created viewpoints and topics.
      *
+     * @throws An error if the BCF version is not supported.
      */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
+    load(data: Uint8Array, world: World): Promise<{
+        viewpoints: Viewpoint[];
+        topics: Topic[];
+    }>;
 }
-import { BooleanSettingsControl } from "../../Types";
-import { Viewpoints } from "../index";
-import { Configurator } from "../../ConfigManager";
-/**
- * Configuration interface for the Viewpoints general behavior.
- */
-export interface ViewpointsConfig {
-    /**
-     * Indicates whether to overwrite the fragments colors when applying viewpoints.
-     * @remarks BCF Viewpoints comes with information to indicate the colors to be applied to components, if any.
-     * @default false
-     */
-    overwriteColors: boolean;
-}
-type ViewpointsConfigType = {
-    overwriteColors: BooleanSettingsControl;
-};
-export declare class ViewpointsConfigManager extends Configurator<Viewpoints, ViewpointsConfigType> {
-    protected _config: ViewpointsConfigType;
-    get overwriteColors(): boolean;
-    set overwriteColors(value: boolean);
-}
-export {};
 import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Component, Disposable, Event, Components } from "../../core";
@@ -2518,10 +2495,36 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     resize(size?: THREE.Vector2): void;
     private updatePlanes;
 }
-import * as FRAGS from "@thatopen/fragments";
+import { BooleanSettingsControl } from "../../Types";
+import { Viewpoints } from "../index";
+import { Configurator } from "../../ConfigManager";
+/**
+ * Configuration interface for the Viewpoints general behavior.
+ */
+export interface ViewpointsConfig {
+    /**
+     * Indicates whether to overwrite the fragments colors when applying viewpoints.
+     * @remarks BCF Viewpoints comes with information to indicate the colors to be applied to components, if any.
+     * @default false
+     */
+    overwriteColors: boolean;
+}
+type ViewpointsConfigType = {
+    overwriteColors: BooleanSettingsControl;
+};
+export declare class ViewpointsConfigManager extends Configurator<Viewpoints, ViewpointsConfigType> {
+    protected _config: ViewpointsConfigType;
+    get overwriteColors(): boolean;
+    set overwriteColors(value: boolean);
+}
+export {};
 import * as WEBIFC from "web-ifc";
-export declare class SpatialIdsFinder {
-    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+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. */
@@ -2566,6 +2569,11 @@ export declare class IfcFragmentSettings {
      */
     customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
 }
+import * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+}
 import * as WEBIFC from "web-ifc";
 export interface IfcItemsCategories {
     [itemID: number]: number;
@@ -2573,12 +2581,6 @@ export interface IfcItemsCategories {
 export declare class IfcCategories {
     getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
 }
-/**
- * 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;
-};
 /**
  * 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.
  *
@@ -2590,6 +2592,12 @@ export declare const IfcCategoryMap: {
 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 FRAGS from "@thatopen/fragments";
 export declare class IfcPropertiesUtils {
     static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
@@ -2615,18 +2623,6 @@ export declare class IfcPropertiesUtils {
     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>>>;
 }
-import * as WEBIFC from "web-ifc";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
-}
-/**
- * A Set of unique numbers representing different types of IFC geometries.
- */
-export declare const GeometryTypes: Set<number>;
 import * as THREE from "three";
 import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
 import { Configurator } from "../../ConfigManager";
@@ -2661,66 +2657,122 @@ export declare class ClipperConfigManager extends Configurator<Clipper, ClipperC
 }
 export {};
 /**
- * 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 Set of unique numbers representing different types of IFC geometries.
  */
-export declare class Event<T> {
+export declare const GeometryTypes: Set<number>;
+import { ControlsSchema, ControlEntry } from "../../Types";
+import { Components } from "../../Components";
+export declare abstract class Configurator<T, U extends ControlsSchema> {
+    protected abstract _config: U;
+    protected _component: T;
+    name: string;
+    get controls(): U;
+    constructor(component: T, components: Components, name: string);
+    copyEntry(controlEntry: ControlEntry): ControlEntry;
+}
+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);
     /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
+     * The real position of the mouse of the Three.js canvas.
      */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
+    get position(): THREE.Vector2;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private getPositionY;
+    private getPositionX;
+    private updateMouseInfo;
+    private setupEvents;
+}
+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;
     /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
+     * A reference to the Three.js Raycaster instance.
+     * This is used for raycasting operations.
      */
-    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;
+    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;
 }
 /**
  * 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 | 2857406711 | 2565941209 | 2495723537 | 3268803585, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
 import * as THREE from "three";
 import CameraControls from "camera-controls";
 import { Event } from "./event";
@@ -2828,53 +2880,34 @@ export interface CameraControllable {
      */
     controls: CameraControls;
 }
-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, any>;
-}
-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.
+ * 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 abstract class BaseCamera extends BaseWorldItem {
-    /**
-     * Whether the camera is enabled or not.
-     */
-    abstract enabled: boolean;
-    /**
-     * The Three.js camera instance.
-     */
-    abstract three: THREE.Camera;
+export declare class AsyncEvent<T> {
     /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
      */
-    abstract controls?: CameraControls;
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
     /**
-     * Checks whether the instance is {@link CameraControllable}.
-     *
-     * @returns True if the instance is controllable, false otherwise.
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
      */
-    hasCameraControls: () => this is CameraControllable;
-}
+    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 { Base } from "./base";
 /**
  * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
@@ -2888,6 +2921,76 @@ export declare abstract class Component extends Base {
      */
     abstract enabled: boolean;
 }
+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 { 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, any>;
+}
+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 { Vector2 } from "three";
 import { Event } from "./event";
@@ -2953,54 +3056,11 @@ 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";
-import { Components } from "../../Components";
-import { BaseWorldItem } from "./base-world-item";
-/**
- * Abstract class representing a base scene in the application. All scenes should use this class as a base.
- */
-export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
-     */
-    abstract three: THREE.Object3D;
-    /** 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;
-    deleteAllLights(): void;
-}
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<160246688 | 2655215786 | 919958153 | 1307041759 | 4186316022 | 781010003 | 307848117 | 3242617779 | 279856033 | 1204542856 | 2857406711 | 2565941209 | 2495723537 | 3268803585, {
+    forRelating: InverseAttribute;
+    forRelated: InverseAttribute;
+}>;
 import * as THREE from "three";
 import { BaseScene } from "./base-scene";
 import { BaseCamera } from "./base-camera";
@@ -3035,77 +3095,30 @@ export interface World extends Disposable, Updateable {
      */
     isDisposing: boolean;
 }
+import * as THREE from "three";
+import { Disposable } from "./interfaces";
 import { Event } from "./event";
+import { Components } from "../../Components";
+import { BaseWorldItem } from "./base-world-item";
 /**
- * A class that extends the built-in Set class and provides additional functionality.
- * It triggers events when items are added, deleted, or the set is cleared.
- *
- * @template T - The type of elements in the set.
+ * Abstract class representing a base scene in the application. All scenes should use this class as a base.
  */
-export declare class DataSet<T> extends Set<T> {
-    /**
-     * An event that is triggered when a new item is added to the set.
-     */
-    readonly onItemAdded: Event<T>;
-    /**
-     * An event that is triggered when an item is deleted from the set.
-     */
-    readonly onItemDeleted: Event<unknown>;
-    /**
-     * An event that is triggered when the set is cleared.
-     */
-    readonly onCleared: Event<unknown>;
-    /**
-     * Constructs a new instance of the DataSet class.
-     *
-     * @param iterable - An optional iterable object to initialize the set with.
-     */
-    constructor(iterable?: Iterable<T> | null);
-    /**
-     * Clears the set and triggers the onCleared event.
-     */
-    clear(): void;
-    /**
-     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
-     *
-     * @param value - The value to add to the set.
-     * @returns - The set instance.
-     */
-    add(...value: T[]): this;
-    /**
-     * A function that acts as a guard for adding items to the set.
-     * It determines whether a given value should be allowed to be added to the set.
-     *
-     * @param value - The value to be checked against the guard.
-     * @returns A boolean indicating whether the value should be allowed to be added to the set.
-     *          By default, this function always returns true, allowing all values to be added.
-     *          You can override this behavior by providing a custom implementation.
-     */
-    guard: (value: T) => boolean;
-    /**
-     * Deletes a value from the set and triggers the onItemDeleted event.
-     *
-     * @param value - The value to delete from the set.
-     * @returns - True if the value was successfully deleted, false otherwise.
-     */
-    delete(value: T): boolean;
+export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
+     * Abstract property representing the three.js object associated with this scene.
+     * 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 { Component } from "./component";
-export type ComponentUIElement = {
-    name: string;
-    componentID: string;
-    attributes: {
-        [name: string]: string;
-    };
-    get: () => HTMLElement;
-};
-export declare abstract class ComponentWithUI extends Component {
-    abstract name: string;
-    abstract getUI(): ComponentUIElement[];
+    deleteAllLights(): void;
 }
 import { Event } from "./event";
 /**
@@ -3178,119 +3191,77 @@ export declare class DataMap<K, V> extends Map<K, V> {
      */
     dispose(): void;
 }
-import * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+import { Event } from "./event";
 /**
- * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
+ * A class that extends the built-in Set class and provides additional functionality.
+ * It triggers events when items are added, deleted, or the set is cleared.
  *
- * @template T - The type of the scene. Default is BaseScene.
- * @template U - The type of the camera. Default is BaseCamera.
- * @template S - The type of the renderer. Default is BaseRenderer.
+ * @template T - The type of elements in the set.
  */
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
+export declare class DataSet<T> extends Set<T> {
     /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
+     * An event that is triggered when a new item is added to the set.
      */
-    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    readonly onItemAdded: Event<T>;
     /**
-     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
+     * An event that is triggered when an item is deleted from the set.
      */
-    isDisposing: boolean;
+    readonly onItemDeleted: Event<unknown>;
     /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
+     * An event that is triggered when the set is cleared.
      */
-    enabled: boolean;
+    readonly onCleared: Event<unknown>;
     /**
-     * A unique identifier for the world.
+     * Constructs a new instance of the DataSet class.
+     *
+     * @param iterable - An optional iterable object to initialize the set with.
      */
-    uuid: string;
+    constructor(iterable?: Iterable<T> | null);
     /**
-     * An optional name for the world.
+     * Clears the set and triggers the onCleared event.
      */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
-    /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
-     */
-    get scene(): T;
-    /**
-     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
-     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
-     * @param scene - The new scene to be set.
-     */
-    set scene(scene: T);
+    clear(): void;
     /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
+     * Adds one or multiple values to the set and triggers the onItemAdded event per each.
+     *
+     * @param value - The value to add to the set.
+     * @returns - The set instance.
      */
-    get camera(): U;
+    add(...value: T[]): this;
     /**
-     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
-     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
-     * @param camera - The new camera to be set.
+     * A function that acts as a guard for adding items to the set.
+     * It determines whether a given value should be allowed to be added to the set.
+     *
+     * @param value - The value to be checked against the guard.
+     * @returns A boolean indicating whether the value should be allowed to be added to the set.
+     *          By default, this function always returns true, allowing all values to be added.
+     *          You can override this behavior by providing a custom implementation.
      */
-    set camera(camera: U);
+    guard: (value: T) => boolean;
     /**
-     * Getter for the renderer.
-     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
+     * Deletes a value from the set and triggers the onItemDeleted event.
+     *
+     * @param value - The value to delete from the set.
+     * @returns - True if the value was successfully deleted, false otherwise.
      */
-    get renderer(): S | null;
+    delete(value: T): boolean;
     /**
-     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
-     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
-     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
-     * @param renderer - The new renderer to be set or null to remove the current renderer.
+     * Clears the set and resets the onItemAdded, onItemDeleted, and onCleared events.
      */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
+    dispose(): void;
 }
-import { ControlsSchema, ControlEntry } from "../../Types";
-import { Components } from "../../Components";
-export declare abstract class Configurator<T, U extends ControlsSchema> {
-    protected abstract _config: U;
-    protected _component: T;
+import { Component } from "./component";
+export type ComponentUIElement = {
     name: string;
-    get controls(): U;
-    constructor(component: T, components: Components, name: string);
-    copyEntry(controlEntry: ControlEntry): ControlEntry;
-}
-import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
-import { Components } from "../../Components";
-import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
-/**
- * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
- */
-export declare class SimpleScene extends BaseScene implements Configurable<SimpleSceneConfigManager, SimpleSceneConfig> {
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /**
-     * The underlying Three.js scene object.
-     * It is used to define the 3D space containing objects, lights, and cameras.
-     */
-    three: THREE.Scene;
-    /** {@link Configurable.config} */
-    config: SimpleSceneConfigManager;
-    protected _defaultConfig: SimpleSceneConfig;
-    constructor(components: Components);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleSceneConfig>): void;
-    dispose(): void;
+    componentID: string;
+    attributes: {
+        [name: string]: string;
+    };
+    get: () => HTMLElement;
+};
+export declare abstract class ComponentWithUI extends Component {
+    abstract name: string;
+    abstract getUI(): ComponentUIElement[];
 }
 import * as THREE from "three";
 export interface BooleanSettingsControl {
@@ -3334,110 +3305,654 @@ export type ControlEntry = BooleanSettingsControl | ColorSettingsControl | TextS
 export interface ControlsSchema {
     [name: string]: ControlEntry | ControlsSchema;
 }
+import { SimplePlane } from "../../Clipper";
+import { DataSet } from "../../Types";
+export interface ViewpointCamera {
+    direction: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    aspectRatio: number;
+}
+export interface ViewpointPerspectiveCamera extends ViewpointCamera {
+    fov: number;
+}
+export interface ViewpointOrthographicCamera extends ViewpointCamera {
+    viewToWorldScale: number;
+}
+export interface BCFViewpoint {
+    title?: string;
+    guid: string;
+    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
+    selectionComponents: Iterable<string>;
+    exceptionComponents: Iterable<string>;
+    clippingPlanes: DataSet<SimplePlane>;
+    spacesVisible: boolean;
+    spaceBoundariesVisible: boolean;
+    openingsVisible: boolean;
+    defaultVisibility: boolean;
+}
 import * as THREE from "three";
-import { BaseRenderer, Event } from "../../Types";
+import * as FRAGS from "@thatopen/fragments";
+import { BCFViewpoint, ViewpointOrthographicCamera, ViewpointPerspectiveCamera } from "./types";
+import { CameraProjection } from "../../OrthoPerspectiveCamera";
 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 {
+import { DataMap, DataSet, World } from "../../Types";
+import { SimplePlane } from "../../Clipper";
+export declare class Viewpoint implements BCFViewpoint {
+    title?: string;
+    guid: string;
     /**
-     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
-     * Default is 'true'.
+     * ClippingPlanes can be used to define a subsection of a building model that is related to the topic.
+     * Each clipping plane is defined by Location and Direction.
+     * The Direction vector points in the invisible direction meaning the half-space that is clipped.
      */
-    enabled: boolean;
+    clippingPlanes: DataSet<SimplePlane>;
+    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
     /**
-     * The HTML container of the THREE.js canvas where the scene is rendered.
+     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
      */
-    container: HTMLElement;
+    readonly exceptionComponents: DataSet<string>;
     /**
-     * The THREE.js WebGLRenderer instance.
+     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
      */
-    three: THREE.WebGLRenderer;
-    protected _canvas: HTMLCanvasElement;
-    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
-    protected _resizeObserver: ResizeObserver | null;
-    protected onContainerUpdated: Event<unknown>;
-    private _resizing;
+    readonly selectionComponents: DataSet<string>;
     /**
-     * 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.
+     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
+     * For this to work, call viewpoint.colorize()
      */
-    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;
+    readonly componentColors: DataMap<string, string[]>;
     /**
-     * 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.
+     * Boolean flags to allow fine control over the visibility of spaces.
+     * A typical use of these flags is when DefaultVisibility=true but spaces should remain hidden.
+     * @default false
      */
-    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>;
+    spacesVisible: boolean;
     /**
-     * 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.
+     * Boolean flags to allow fine control over the visibility of space boundaries.
+     * A typical use of these flags is when DefaultVisibility=true but space boundaries should remain hidden.
+     * @default false
      */
-    readonly onAspectUpdated: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
+    spaceBoundariesVisible: boolean;
     /**
-     * A three.js PerspectiveCamera or OrthographicCamera instance.
-     * This camera is used for rendering the scene.
+     * Boolean flags to allow fine control over the visibility of openings.
+     * A typical use of these flags is when DefaultVisibility=true but openings should remain hidden.
+     * @default false
      */
-    three: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _allControls;
+    openingsVisible: boolean;
     /**
-     * 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.
+     * When true, all components should be visible unless listed in the exceptions
+     * When false all components should be invisible unless listed in the exceptions
      */
-    get controls(): CameraControls;
+    defaultVisibility: boolean;
+    private get _selectionModelIdMap();
+    private get _exceptionModelIdMap();
     /**
-     * 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.
+     * A list of components that should be selected (highlighted) when displaying a viewpoint.
+     * @returns The fragmentIdMap for components marked as selections.
      */
-    get enabled(): boolean;
+    get selection(): FRAGS.FragmentIdMap;
     /**
-     * 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.
+     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
+     * @returns The fragmentIdMap for components marked as exceptions.
      */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    get exception(): FRAGS.FragmentIdMap;
+    /**
+     * Retrieves the projection type of the viewpoint's camera.
+     *
+     * @returns A string representing the projection type of the viewpoint's camera.
+     *          It can be either 'Perspective' or 'Orthographic'.
+     */
+    get projection(): CameraProjection;
+    /**
+     * Retrieves the position vector of the viewpoint's camera.
+     *
+     * @remarks
+     * The position vector represents the camera's position in the world coordinate system.
+     * The function applies the base coordinate system transformation to the position vector.
+     *
+     * @returns A THREE.Vector3 representing the position of the viewpoint's camera.
+     */
+    get position(): THREE.Vector3;
+    /**
+     * Retrieves the direction vector of the viewpoint's camera.
+     *
+     * @remarks
+     * The direction vector represents the direction in which the camera is pointing.
+     * It is calculated by extracting the x, y, and z components from the camera's direction property.
+     *
+     * @returns A THREE.Vector3 representing the direction of the viewpoint's camera.
+     */
+    get direction(): THREE.Vector3;
+    private _components;
+    /**
+     * Represents the world in which the viewpoints are created and managed.
+     */
+    readonly world: World;
+    private get _managerVersion();
+    /**
+     * Retrieves the list of BCF topics associated with the current viewpoint.
+     *
+     * @remarks
+     * This function retrieves the BCFTopics manager from the components,
+     * then filters the list of topics to find those associated with the current viewpoint.
+     *
+     * @returns An array of BCF topics associated with the current viewpoint.
+     */
+    get topics(): import("../../../openbim/BCFTopics").Topic[];
+    constructor(components: Components, world: World, _config?: {
+        data?: Partial<BCFViewpoint>;
+        setCamera?: boolean;
+    });
+    /**
+     * Adds components to the viewpoint based on the provided fragment ID map.
+     *
+     * @param fragmentIdMap - A map containing fragment IDs as keys and arrays of express IDs as values.
+     *
+     * @returns A Promise that resolves when the components have been added to the viewpoint.
+     */
+    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): Promise<void>;
+    /**
+     * Sets the properties of the viewpoint with the provided data.
+     *
+     * @remarks The guid will be ommited as it shouldn't change after it has been initially set.
+     *
+     * @param data - An object containing the properties to be set.
+     *               The properties not included in the object will remain unchanged.
+     *
+     * @returns The viewpoint instance with the updated properties.
+     */
+    set(data: Partial<BCFViewpoint>): this;
+    /**
+     * Sets the viewpoint of the camera in the world.
+     *
+     * @remarks
+     * This function calculates the target position based on the viewpoint information.
+     * It sets the visibility of the viewpoint components and then applies the viewpoint using the camera's controls.
+     *
+     * @param transition - Indicates whether the camera movement should have a transition effect.
+     *                      Default value is 'true'.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     *
+     * @returns A Promise that resolves when the camera has been set.
+     */
+    go(transition?: boolean): Promise<void>;
+    /**
+     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
+     *
+     * @remarks
+     * This function retrieves the camera's position, direction, and aspect ratio from the world's camera and renderer.
+     * It then calculates the camera's perspective or orthographic settings based on the camera type.
+     * Finally, it updates the viewpoint's camera settings and updates the viewpoint to the Viewpoints manager.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     * @throws An error if the world's renderer is not available.
+     */
+    updateCamera(): void;
+    /**
+     * Applies color to the components in the viewpoint based on their GUIDs.
+     *
+     * This function iterates through the 'componentColors' map, retrieves the fragment IDs
+     * corresponding to each color, and then uses the 'Classifier' to apply the color to those fragments.
+     *
+     * @remarks
+     * The color is applied using the 'Classifier.setColor' method, which sets the color of the specified fragments.
+     * The color is provided as a hexadecimal string, prefixed with a '#'.
+     */
+    colorize(): void;
+    /**
+     * Resets the colors of all components in the viewpoint to their original color.
+     * This method iterates through the 'componentColors' map, retrieves the fragment IDs
+     * corresponding to each color, and then uses the 'Classifier' to reset the color of those fragments.
+     */
+    resetColors(): void;
+    private createComponentTags;
+    /**
+     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
+     *
+     * @param version - The version of the BCF Manager to use for serialization.
+     *                   If not provided, the current version of the manager will be used.
+     *
+     * @returns A Promise that resolves to an XML string representing the viewpoint.
+     *          The XML string follows the BCF VisualizationInfo schema.
+     *
+     * @throws An error if the world's camera does not have camera controls.
+     * @throws An error if the world's renderer is not available.
+     */
+    serialize(version?: string): Promise<string>;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
+ */
+export declare class FirstPersonMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "FirstPerson";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: OrthoPerspectiveCamera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
+ */
+export declare class PlanMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Plan";
+    private mouseAction1?;
+    private mouseAction2?;
+    private mouseInitialized;
+    private readonly defaultAzimuthSpeed;
+    private readonly defaultPolarSpeed;
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+}
+import * as THREE from "three";
+import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
+import { Components } from "../../Components";
+import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
+/**
+ * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ */
+export declare class SimpleGrid implements Hideable, Disposable, Configurable<SimpleGridConfigManager, SimpleGridConfig> {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    /** The world instance to which this Raycaster belongs. */
+    world: World;
+    /** The components instance to which this grid belongs. */
+    components: Components;
+    /** {@link Configurable.config} */
+    config: SimpleGridConfigManager;
+    protected _defaultConfig: SimpleGridConfig;
+    /** {@link Hideable.visible} */
+    get visible(): boolean;
+    /** {@link Hideable.visible} */
+    set visible(visible: boolean);
+    /** The material of the grid. */
+    get material(): THREE.ShaderMaterial;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    get fade(): boolean;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    set fade(active: boolean);
+    /** The Three.js mesh that contains the infinite grid. */
+    readonly three: THREE.Mesh;
+    private _fade;
+    constructor(components: Components, world: World);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleGridConfig>): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private setupEvents;
+    private updateZoom;
+}
+/**
+ * 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 { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+import { SimpleGrid } from "./simple-grid";
+type SimpleGridConfigType = {
+    visible: BooleanSettingsControl;
+    color: ColorSettingsControl;
+    primarySize: NumberSettingControl;
+    secondarySize: NumberSettingControl;
+    distance: NumberSettingControl;
+};
+/**
+ * Configuration interface for the {@link SimpleGrid}.
+ */
+export interface SimpleGridConfig {
+    /**
+     * The color of the grid lines.
+     */
+    color: THREE.Color;
+    /**
+     * The size of the primary grid lines.
+     */
+    primarySize: number;
+    /**
+     * The size of the secondary grid lines.
+     */
+    secondarySize: number;
+    /**
+     * The distance at which the grid lines start to fade away.
+     */
+    distance: number;
+}
+export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
+    protected _config: SimpleGridConfigType;
+    get visible(): boolean;
+    set visible(value: boolean);
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    get primarySize(): number;
+    set primarySize(value: number);
+    get secondarySize(): number;
+    set secondarySize(value: number);
+    get distance(): number;
+    set distance(value: number);
+}
+export {};
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
+     */
+    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    /**
+     * Current projection mode of the camera.
+     * Default is "Perspective".
+     */
+    current: CameraProjection;
+    /**
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     */
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    private _component;
+    private _previousDistance;
+    constructor(camera: OrthoPerspectiveCamera);
+    /**
+     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     *
+     * @param projection - the new projection to set. If it is the current projection,
+     * it will have no effect.
+     */
+    set(projection: CameraProjection): Promise<void>;
+    /**
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
+     */
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getPerspectiveDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
+}
+import * as THREE from "three";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+/**
+ * A class representing a simple world in a 3D environment. It extends the Base class and implements the World interface.
+ *
+ * @template T - The type of the scene. Default is BaseScene.
+ * @template U - The type of the camera. Default is BaseCamera.
+ * @template S - The type of the renderer. Default is BaseRenderer.
+ */
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
+    /**
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
+     */
+    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /**
+     * Indicates whether the world is currently being disposed. This is useful to prevent trying to access world's elements when it's being disposed, which could cause errors when you dispose a world.
+     */
+    isDisposing: boolean;
+    /**
+     * Indicates whether the world is currently enabled.
+     * When disabled, the world will not be updated.
+     */
+    enabled: boolean;
+    /**
+     * A unique identifier for the world.
+     */
+    uuid: string;
+    /**
+     * An optional name for the world.
+     */
+    name?: string;
+    private _scene?;
+    private _camera?;
+    private _renderer;
+    /**
+     * Getter for the scene. If no scene is initialized, it throws an error.
+     * @returns The current scene.
+     */
+    get scene(): T;
+    /**
+     * Setter for the scene. It sets the current scene, adds the world to the scene's worlds set,
+     * sets the current world in the scene, and triggers the scene's onWorldChanged event with the added action.
+     * @param scene - The new scene to be set.
+     */
+    set scene(scene: T);
+    /**
+     * Getter for the camera. If no camera is initialized, it throws an error.
+     * @returns The current camera.
+     */
+    get camera(): U;
+    /**
+     * Setter for the camera. It sets the current camera, adds the world to the camera's worlds set,
+     * sets the current world in the camera, and triggers the camera's onWorldChanged event with the added action.
+     * @param camera - The new camera to be set.
+     */
+    set camera(camera: U);
+    /**
+     * Getter for the renderer.
+     * @returns The current renderer or null if no renderer is set. Some worlds don't need a renderer to work (when your mail goal is not to display a 3D viewport to the user).
+     */
+    get renderer(): S | null;
+    /**
+     * Setter for the renderer. It sets the current renderer, adds the world to the renderer's worlds set,
+     * sets the current world in the renderer, and triggers the renderer's onWorldChanged event with the added action.
+     * If a new renderer is set, it also triggers the onWorldChanged event with the removed action for the old renderer.
+     * @param renderer - The new renderer to be set or null to remove the current renderer.
+     */
+    set renderer(renderer: S | null);
+    /** {@link Updateable.update} */
+    update(delta?: number): void;
+    /** {@link Disposable.dispose} */
+    dispose(disposeResources?: boolean): void;
+}
+import * as THREE from "three";
+import { BaseScene, Configurable, Event } from "../../Types";
+import { Components } from "../../Components";
+import { SimpleSceneConfig, SimpleSceneConfigManager } from "./simple-scene-config";
+/**
+ * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add objects hierarchically, and easily dispose them when you are finished with it.
+ */
+export declare class SimpleScene extends BaseScene implements Configurable<SimpleSceneConfigManager, SimpleSceneConfig> {
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    /**
+     * The underlying Three.js scene object.
+     * It is used to define the 3D space containing objects, lights, and cameras.
+     */
+    three: THREE.Scene;
+    /** {@link Configurable.config} */
+    config: SimpleSceneConfigManager;
+    protected _defaultConfig: SimpleSceneConfig;
+    constructor(components: Components);
+    /** {@link Configurable.setup} */
+    setup(config?: Partial<SimpleSceneConfig>): void;
+    dispose(): void;
+}
+import * as THREE from "three";
+import { BaseRenderer, Event } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * A basic renderer capable of rendering [Objec3Ds](https://threejs.org/docs/#api/en/core/Object3D).
+ */
+export declare class SimpleRenderer extends BaseRenderer {
+    /**
+     * Indicates whether the renderer is enabled. If it's not, it won't be updated.
+     * Default is 'true'.
+     */
+    enabled: boolean;
+    /**
+     * The HTML container of the THREE.js canvas where the scene is rendered.
+     */
+    container: HTMLElement;
+    /**
+     * The THREE.js WebGLRenderer instance.
+     */
+    three: THREE.WebGLRenderer;
+    protected _canvas: HTMLCanvasElement;
+    protected _parameters?: Partial<THREE.WebGLRendererParameters>;
+    protected _resizeObserver: ResizeObserver | null;
+    protected onContainerUpdated: Event<unknown>;
+    private _resizing;
+    /**
+     * Constructor for the SimpleRenderer class.
+     *
+     * @param components - The components instance.
+     * @param container - The HTML container where the THREE.js canvas will be rendered.
+     * @param parameters - Optional parameters for the THREE.js WebGLRenderer.
+     */
+    constructor(components: Components, container: HTMLElement, parameters?: Partial<THREE.WebGLRendererParameters>);
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Resizeable.getSize}. */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize: (size?: THREE.Vector2) => void;
+    /**
+     * 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;
     /**
@@ -3570,169 +4085,11 @@ export declare class DistanceRenderer {
     /**
      * 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 { Components } from "../../Components";
-import { AsyncEvent, Configurable, Event, World } from "../../Types";
-import { CullerRendererConfig, CullerRendererConfigManager } from "./culler-renderer-config";
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class CullerRenderer implements Configurable<CullerRendererConfigManager, CullerRendererConfig> {
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@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;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /** The render target used to render the visibility scene. */
-    renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
-    /**
-     * The size of the buffer where the result of the visibility check is stored.
-     */
-    bufferSize: number;
-    /**
-     * The buffer when the result of the visibility check is stored.
-     */
-    buffer: Uint8Array;
-    /**
-     * Flag to indicate if the renderer shouldn't update the visibility.
-     */
-    preventUpdate: boolean;
-    /** {@link Configurable.config} */
-    config: CullerRendererConfigManager;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /** 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 _defaultConfig: CullerRendererConfig;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _availableColor;
-    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.
-     */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    setup(config?: Partial<CullerRendererConfig>): void;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-}
-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 { CullerRenderer } 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>;
-    }>;
-    /**
-     * 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[]>>;
-    /**
-     * @deprecated use config.threshold instead.
-     */
-    get threshold(): number;
-    /**
-     * @deprecated use config.threshold instead.
-     */
-    set threshold(value: number);
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World);
-    /** {@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.
-     */
-    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.
-     */
-    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}
+     * @param force if true, it will refresh the scene even if needsUpdate is
+     * not true.
      */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+    compute: () => Promise<void>;
     private handleWorkerMessage;
-    private getAvailableMaterial;
 }
 import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
@@ -3777,579 +4134,217 @@ export declare class SimplePlane implements Disposable, Hideable {
      * Getter for the enabled state of the clipping plane.
      * @returns {boolean} The current enabled state.
      */
-    get enabled(): boolean;
-    /**
-     * Setter for the enabled state of the clipping plane.
-     * Updates the clipping plane state in the renderer and throws an error if no renderer is found.
-     * @param {boolean} state - The new enabled state.
-     */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The meshes used for raycasting */
-    get meshes(): THREE.Mesh[];
-    /** The material of the clipping plane representation. */
-    get planeMaterial(): THREE.Material | THREE.Material[];
-    /** The material of the clipping plane representation. */
-    set planeMaterial(material: THREE.Material | THREE.Material[]);
-    /** The size of the clipping plane representation. */
-    get size(): number;
-    /** Sets the size of the clipping plane representation. */
-    set size(size: number);
-    /**
-     * Getter for the helper object of the clipping plane.
-     * The helper object is a THREE.Object3D that contains the clipping plane mesh and other related objects.
-     * It is used for positioning, rotating, and scaling the clipping plane in the 3D scene.
-     *
-     * @returns {THREE.Object3D} The helper object of the clipping plane.
-     */
-    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
-    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
-    /**
-     * Sets the clipping plane's normal and origin from the given normal and point.
-     * This method resets the clipping plane's state, updates the normal and origin,
-     * and positions the helper object accordingly.
-     *
-     * @param normal - The new normal vector for the clipping plane.
-     * @param point - The new origin point for the clipping plane.
-     *
-     * @returns {void}
-     */
-    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): void;
-    /** {@link Updateable.update} */
-    update: () => void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private reset;
-    protected toggleControls(state: boolean): void;
-    private newTransformControls;
-    private initializeControls;
-    private createArrowBoundingBox;
-    private changeDrag;
-    private notifyDraggingChanged;
-    private preventCameraMovement;
-    private newHelper;
-    private static newPlaneMesh;
-}
-import * as THREE from "three";
-import { 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;
-}
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
-import { SimplePlane } from "../../Clipper";
-import { DataSet } from "../../Types";
-export interface ViewpointCamera {
-    direction: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    aspectRatio: number;
-}
-export interface ViewpointPerspectiveCamera extends ViewpointCamera {
-    fov: number;
-}
-export interface ViewpointOrthographicCamera extends ViewpointCamera {
-    viewToWorldScale: number;
-}
-export interface BCFViewpoint {
-    title?: string;
-    guid: string;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    selectionComponents: Iterable<string>;
-    exceptionComponents: Iterable<string>;
-    clippingPlanes: DataSet<SimplePlane>;
-    spacesVisible: boolean;
-    spaceBoundariesVisible: boolean;
-    openingsVisible: boolean;
-    defaultVisibility: boolean;
-}
-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 * as FRAGS from "@thatopen/fragments";
-import { BCFViewpoint, ViewpointOrthographicCamera, ViewpointPerspectiveCamera } from "./types";
-import { CameraProjection } from "../../OrthoPerspectiveCamera";
-import { Components } from "../../Components";
-import { DataMap, DataSet, World } from "../../Types";
-import { SimplePlane } from "../../Clipper";
-export declare class Viewpoint implements BCFViewpoint {
-    title?: string;
-    guid: string;
-    /**
-     * ClippingPlanes can be used to define a subsection of a building model that is related to the topic.
-     * Each clipping plane is defined by Location and Direction.
-     * The Direction vector points in the invisible direction meaning the half-space that is clipped.
-     */
-    clippingPlanes: DataSet<SimplePlane>;
-    camera: ViewpointPerspectiveCamera | ViewpointOrthographicCamera;
-    /**
-     * A list of components GUIDs to hide when defaultVisibility = true or to show when defaultVisibility = false
-     */
-    readonly exceptionComponents: DataSet<string>;
-    /**
-     * A list of components GUIDs that should be selected (highlighted) when displaying a viewpoint.
-     */
-    readonly selectionComponents: DataSet<string>;
-    /**
-     * A map of colors and components GUIDs that should be colorized when displaying a viewpoint.
-     * For this to work, call viewpoint.colorize()
-     */
-    readonly componentColors: DataMap<string, string[]>;
-    /**
-     * Boolean flags to allow fine control over the visibility of spaces.
-     * A typical use of these flags is when DefaultVisibility=true but spaces should remain hidden.
-     * @default false
-     */
-    spacesVisible: boolean;
-    /**
-     * Boolean flags to allow fine control over the visibility of space boundaries.
-     * A typical use of these flags is when DefaultVisibility=true but space boundaries should remain hidden.
-     * @default false
-     */
-    spaceBoundariesVisible: boolean;
-    /**
-     * Boolean flags to allow fine control over the visibility of openings.
-     * A typical use of these flags is when DefaultVisibility=true but openings should remain hidden.
-     * @default false
-     */
-    openingsVisible: boolean;
-    /**
-     * When true, all components should be visible unless listed in the exceptions
-     * When false all components should be invisible unless listed in the exceptions
-     */
-    defaultVisibility: boolean;
-    private get _selectionModelIdMap();
-    private get _exceptionModelIdMap();
-    /**
-     * A list of components that should be selected (highlighted) when displaying a viewpoint.
-     * @returns The fragmentIdMap for components marked as selections.
-     */
-    get selection(): FRAGS.FragmentIdMap;
-    /**
-     * A list of components to hide when defaultVisibility = true or to show when defaultVisibility = false
-     * @returns The fragmentIdMap for components marked as exceptions.
-     */
-    get exception(): FRAGS.FragmentIdMap;
-    /**
-     * Retrieves the projection type of the viewpoint's camera.
-     *
-     * @returns A string representing the projection type of the viewpoint's camera.
-     *          It can be either 'Perspective' or 'Orthographic'.
-     */
-    get projection(): CameraProjection;
-    /**
-     * Retrieves the position vector of the viewpoint's camera.
-     *
-     * @remarks
-     * The position vector represents the camera's position in the world coordinate system.
-     * The function applies the base coordinate system transformation to the position vector.
-     *
-     * @returns A THREE.Vector3 representing the position of the viewpoint's camera.
-     */
-    get position(): THREE.Vector3;
-    /**
-     * Retrieves the direction vector of the viewpoint's camera.
-     *
-     * @remarks
-     * The direction vector represents the direction in which the camera is pointing.
-     * It is calculated by extracting the x, y, and z components from the camera's direction property.
-     *
-     * @returns A THREE.Vector3 representing the direction of the viewpoint's camera.
-     */
-    get direction(): THREE.Vector3;
-    private _components;
+    get enabled(): boolean;
     /**
-     * Represents the world in which the viewpoints are created and managed.
+     * Setter for the enabled state of the clipping plane.
+     * Updates the clipping plane state in the renderer and throws an error if no renderer is found.
+     * @param {boolean} state - The new enabled state.
      */
-    readonly world: World;
-    private get _managerVersion();
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The meshes used for raycasting */
+    get meshes(): THREE.Mesh[];
+    /** The material of the clipping plane representation. */
+    get planeMaterial(): THREE.Material | THREE.Material[];
+    /** The material of the clipping plane representation. */
+    set planeMaterial(material: THREE.Material | THREE.Material[]);
+    /** The size of the clipping plane representation. */
+    get size(): number;
+    /** Sets the size of the clipping plane representation. */
+    set size(size: number);
     /**
-     * Retrieves the list of BCF topics associated with the current viewpoint.
-     *
-     * @remarks
-     * This function retrieves the BCFTopics manager from the components,
-     * then filters the list of topics to find those associated with the current viewpoint.
+     * 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 An array of BCF topics associated with the current viewpoint.
+     * @returns {THREE.Object3D} The helper object of the clipping plane.
      */
-    get topics(): import("../../../openbim/BCFTopics").Topic[];
-    constructor(components: Components, world: World, _config?: {
-        data?: Partial<BCFViewpoint>;
-        setCamera?: boolean;
-    });
+    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
+    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
     /**
-     * Adds components to the viewpoint based on the provided fragment ID map.
+     * 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 fragmentIdMap - A map containing fragment IDs as keys and arrays of express IDs as values.
+     * @param normal - The new normal vector for the clipping plane.
+     * @param point - The new origin point for the clipping plane.
      *
-     * @returns A Promise that resolves when the components have been added to the viewpoint.
+     * @returns {void}
      */
-    addComponentsFromMap(fragmentIdMap: FRAGS.FragmentIdMap): Promise<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 { Components } from "../../Components";
+import { AsyncEvent, Configurable, Event, World } from "../../Types";
+import { CullerRendererConfig, CullerRendererConfigManager } from "./culler-renderer-config";
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class CullerRenderer implements Configurable<CullerRendererConfigManager, CullerRendererConfig> {
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Sets the properties of the viewpoint with the provided data.
-     *
-     * @remarks The guid will be ommited as it shouldn't change after it has been initially set.
-     *
-     * @param data - An object containing the properties to be set.
-     *               The properties not included in the object will remain unchanged.
-     *
-     * @returns The viewpoint instance with the updated properties.
+     * 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.
      */
-    set(data: Partial<BCFViewpoint>): this;
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
     /**
-     * Sets the viewpoint of the camera in the world.
-     *
-     * @remarks
-     * This function calculates the target position based on the viewpoint information.
-     * It sets the visibility of the viewpoint components and then applies the viewpoint using the camera's controls.
-     *
-     * @param transition - Indicates whether the camera movement should have a transition effect.
-     *                      Default value is 'true'.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     *
-     * @returns A Promise that resolves when the camera has been set.
+     * Whether this renderer is active or not. If not, it won't render anything.
      */
-    go(transition?: boolean): Promise<void>;
+    enabled: boolean;
     /**
-     * Updates the camera settings of the viewpoint based on the current world's camera and renderer.
-     *
-     * @remarks
-     * This function retrieves the camera's position, direction, and aspect ratio from the world's camera and renderer.
-     * It then calculates the camera's perspective or orthographic settings based on the camera type.
-     * Finally, it updates the viewpoint's camera settings and updates the viewpoint to the Viewpoints manager.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
+     * 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.
      */
-    updateCamera(): void;
+    needsUpdate: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** The render target used to render the visibility scene. */
+    renderTarget: THREE.WebGLRenderTarget<THREE.Texture>;
     /**
-     * Applies color to the components in the viewpoint based on their GUIDs.
-     *
-     * This function iterates through the 'componentColors' map, retrieves the fragment IDs
-     * corresponding to each color, and then uses the 'Classifier' to apply the color to those fragments.
-     *
-     * @remarks
-     * The color is applied using the 'Classifier.setColor' method, which sets the color of the specified fragments.
-     * The color is provided as a hexadecimal string, prefixed with a '#'.
+     * The size of the buffer where the result of the visibility check is stored.
      */
-    colorize(): void;
+    bufferSize: number;
     /**
-     * Resets the colors of all components in the viewpoint to their original color.
-     * This method iterates through the 'componentColors' map, retrieves the fragment IDs
-     * corresponding to each color, and then uses the 'Classifier' to reset the color of those fragments.
+     * The buffer when the result of the visibility check is stored.
      */
-    resetColors(): void;
-    private createComponentTags;
+    buffer: Uint8Array;
     /**
-     * Serializes the viewpoint into a buildingSMART compliant XML string for export.
-     *
-     * @param version - The version of the BCF Manager to use for serialization.
-     *                   If not provided, the current version of the manager will be used.
-     *
-     * @returns A Promise that resolves to an XML string representing the viewpoint.
-     *          The XML string follows the BCF VisualizationInfo schema.
-     *
-     * @throws An error if the world's camera does not have camera controls.
-     * @throws An error if the world's renderer is not available.
+     * Flag to indicate if the renderer shouldn't update the visibility.
      */
-    serialize(version?: string): Promise<string>;
-}
-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;
-}
-/**
- * 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;
+    preventUpdate: boolean;
+    /** {@link Configurable.config} */
+    config: CullerRendererConfigManager;
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    /** 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 _defaultConfig: CullerRendererConfig;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _availableColor;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): 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;
-}
-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 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>;
+    setup(config?: Partial<CullerRendererConfig>): void;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
 }
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 import * as THREE from "three";
-import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-import { SimpleGrid } from "./simple-grid";
-type SimpleGridConfigType = {
-    visible: BooleanSettingsControl;
-    color: ColorSettingsControl;
-    primarySize: NumberSettingControl;
-    secondarySize: NumberSettingControl;
-    distance: NumberSettingControl;
-};
+import { CullerRenderer } from "./culler-renderer";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
 /**
- * Configuration interface for the {@link SimpleGrid}.
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
  */
-export interface SimpleGridConfig {
-    /**
-     * The color of the grid lines.
-     */
-    color: THREE.Color;
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * The size of the primary grid lines.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    primarySize: number;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * The size of the secondary grid lines.
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
      */
-    secondarySize: number;
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /**
-     * The distance at which the grid lines start to fade away.
+     * @deprecated use config.threshold instead.
      */
-    distance: number;
-}
-export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
-    protected _config: SimpleGridConfigType;
-    get visible(): boolean;
-    set visible(value: boolean);
-    get color(): THREE.Color;
-    set color(value: THREE.Color);
-    get primarySize(): number;
-    set primarySize(value: number);
-    get secondarySize(): number;
-    set secondarySize(value: number);
-    get distance(): number;
-    set distance(value: number);
-}
-export {};
-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 {
+    get threshold(): number;
     /**
-     * Event that fires when the {@link CameraProjection} changes.
+     * @deprecated use config.threshold instead.
      */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
+    set threshold(value: number);
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
+     * 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.
      */
-    current: CameraProjection;
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
+     * 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.
      */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
     /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     * 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 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.
+     * @param meshes - The meshes to update.
+     *
+     * @returns {void}
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
+    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
 }
-import * as THREE from "three";
-import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
-import { Components } from "../../Components";
-import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
+import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
- * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-export declare class SimpleGrid implements Hideable, Disposable, Configurable<SimpleGridConfigManager, SimpleGridConfig> {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /** The world instance to which this Raycaster belongs. */
-    world: World;
-    /** The components instance to which this grid belongs. */
-    components: Components;
-    /** {@link Configurable.config} */
-    config: SimpleGridConfigManager;
-    protected _defaultConfig: SimpleGridConfig;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Minimum number of geometries to be streamed.
+     * Defaults to 10 geometries.
      */
-    get fade(): boolean;
+    minGeometrySize: number;
     /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
+     * Minimum amount of assets to be streamed.
+     * Defaults to 1000 assets.
      */
-    set fade(active: boolean);
-    /** The Three.js mesh that contains the infinite grid. */
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleGridConfig>): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
-}
-import * as WEBIFC from "web-ifc";
-import * as THREE from "three";
-export declare class Units {
-    factor: number;
-    complement: number;
-    apply(matrix: THREE.Matrix4): void;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    private getLengthUnits;
-    private getScaleMatrix;
-}
-import * as THREE from "three";
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-export declare class CivilReader {
-    defLineMat: THREE.LineBasicMaterial;
-    read(webIfc: WEBIFC.IfcAPI): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    get(civilItems: any): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    private getCurves;
+    minAssetsSize: number;
+    /**
+     * Maximum amount of triangles per fragment. Useful for controlling the maximum size of fragment files.
+     */
+    maxTriangles: number | null;
 }
 /**
  * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
@@ -4380,100 +4375,46 @@ export interface StreamedAsset {
         color: number[];
     }[];
 }
+import * as THREE from "three";
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+export declare class CivilReader {
+    defLineMat: THREE.LineBasicMaterial;
+    read(webIfc: WEBIFC.IfcAPI): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    get(civilItems: any): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    private getCurves;
+}
 import * as WEBIFC from "web-ifc";
 export declare class IfcMetadataReader {
     getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
     getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
 }
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/**
- * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
- */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
-    /**
-     * Minimum number of geometries to be streamed.
-     * Defaults to 10 geometries.
-     */
-    minGeometrySize: number;
-    /**
-     * Minimum amount of assets to be streamed.
-     * Defaults to 1000 assets.
-     */
-    minAssetsSize: number;
-    /**
-     * Maximum amount of triangles per fragment. Useful for controlling the maximum size of fragment files.
-     */
-    maxTriangles: number | null;
+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 { 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;
-}
-export type BCFVersion = "2.1" | "3";
-export interface BCFTopic {
-    guid: string;
-    serverAssignedId?: string;
-    type: string;
-    status: string;
-    title: string;
-    priority?: string;
-    index?: number;
-    labels: Set<string>;
-    creationDate: Date;
-    creationAuthor: string;
-    modifiedDate?: Date;
-    modifiedAuthor?: string;
-    dueDate?: Date;
-    assignedTo?: string;
-    description?: string;
-    stage?: string;
-}
-import { Topic } from "..";
-import { Viewpoint } from "../../../core/Viewpoints";
-import { Components } from "../../../core/Components";
-/**
- * Represents a comment in a BCF Topic.
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-export declare class Comment {
-    date: Date;
-    author: string;
-    guid: string;
-    viewpoint?: Viewpoint;
-    modifiedAuthor?: string;
-    modifiedDate?: Date;
-    topic?: Topic;
-    private _components;
-    private _comment;
-    /**
-     * Sets the comment text and updates the modified date and author.
-     * The author will be the one defined in BCFTopics.config.author
-     * @param value - The new comment text.
-     */
-    set comment(value: string);
-    /**
-     * Gets the comment text.
-     * @returns The comment text.
-     */
-    get comment(): string;
-    /**
-     * Constructs a new BCF Topic Comment instance.
-     * @param components - The Components instance.
-     * @param text - The initial comment text.
-     */
-    constructor(components: Components, text: string);
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
     /**
-     * Serializes the Comment instance into a BCF compliant XML string.
-     *
-     * @returns A string representing the Comment in BCFv2 XML format.
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
      */
-    serialize(): string;
+    propertiesSize: number;
 }
 import { Components } from "../../../core/Components";
 import { Viewpoint } from "../../../core/Viewpoints";
@@ -4598,86 +4539,24 @@ export declare class Topic implements BCFTopic {
      */
     serialize(): string;
 }
-import { BooleanSettingsControl, NumberSettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-import { CullerRenderer } from "../index";
-type CullerRendererConfigType = {
-    enabled: BooleanSettingsControl;
-    width: NumberSettingControl;
-    height: NumberSettingControl;
-    updateInterval: NumberSettingControl;
-    autoUpdate: BooleanSettingsControl;
-    renderDebugFrame: BooleanSettingsControl;
-    threshold: NumberSettingControl;
-};
-/**
- * Configuration interface for the {@link CullerRenderer}.
- */
-export interface CullerRendererConfig {
-    /**
-     * Whether the culler renderer should make renders or not.
-     */
-    enabled: boolean;
-    /**
-     * Width of the render target used for visibility checks.
-     */
-    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;
-    /**
-     * Interval in milliseconds at which the visibility check should be performed.
-     */
-    updateInterval: number;
-    /**
-     * Whether to render the frame use to debug the culler behavior.
-     */
-    renderDebugFrame: boolean;
-    /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
-     */
-    threshold: number;
-}
-/**
- * Settings to configure the CullerRenderer.
- */
-export declare class CullerRendererConfigManager extends Configurator<CullerRenderer, CullerRendererConfigType> {
-    protected _config: CullerRendererConfigType;
-    private _interval;
-    get enabled(): boolean;
-    set enabled(value: boolean);
-    get width(): number;
-    set width(value: number);
-    get height(): number;
-    set height(value: number);
-    get autoUpdate(): boolean;
-    set autoUpdate(value: boolean);
-    get updateInterval(): number;
-    set updateInterval(value: number);
-    get renderDebugFrame(): boolean;
-    set renderDebugFrame(value: boolean);
-    get threshold(): number;
-    set threshold(value: number);
-    setWidthHeight(width: number, height: number): void;
-    setAutoAndInterval(auto: boolean, interval: number): void;
-    private resetRenderTarget;
-    private resetInterval;
-}
-export {};
-import { BCFTopics } from "../..";
-export declare const extensionsImporter: (manager: BCFTopics, extensionsXML: string) => void;
-import { BufferGeometry } from "three";
-import * as THREE from "three";
-export declare class TransformHelper {
-    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
+export type BCFVersion = "2.1" | "3";
+export interface BCFTopic {
+    guid: string;
+    serverAssignedId?: string;
+    type: string;
+    status: string;
+    title: string;
+    priority?: string;
+    index?: number;
+    labels: Set<string>;
+    creationDate: Date;
+    creationAuthor: string;
+    modifiedDate?: Date;
+    modifiedAuthor?: string;
+    dueDate?: Date;
+    assignedTo?: string;
+    description?: string;
+    stage?: string;
 }
 import { BCFTopics, BCFVersion } from "../index";
 import { BooleanSettingsControl, Configurator, SelectSettingControl, TextSetSettingControl, TextSettingsControl } from "../../../core";
@@ -4801,6 +4680,127 @@ export declare class BCFTopicsConfigManager extends Configurator<BCFTopics, BCFT
     set ignoreIncompleteTopicsOnImport(value: boolean);
 }
 export {};
+import { BooleanSettingsControl, NumberSettingControl } from "../../Types";
+import { Configurator } from "../../ConfigManager";
+import { CullerRenderer } from "../index";
+type CullerRendererConfigType = {
+    enabled: BooleanSettingsControl;
+    width: NumberSettingControl;
+    height: NumberSettingControl;
+    updateInterval: NumberSettingControl;
+    autoUpdate: BooleanSettingsControl;
+    renderDebugFrame: BooleanSettingsControl;
+    threshold: NumberSettingControl;
+};
+/**
+ * Configuration interface for the {@link CullerRenderer}.
+ */
+export interface CullerRendererConfig {
+    /**
+     * Whether the culler renderer should make renders or not.
+     */
+    enabled: boolean;
+    /**
+     * Width of the render target used for visibility checks.
+     */
+    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;
+    /**
+     * Interval in milliseconds at which the visibility check should be performed.
+     */
+    updateInterval: number;
+    /**
+     * Whether to render the frame use to debug the culler behavior.
+     */
+    renderDebugFrame: boolean;
+    /**
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
+     */
+    threshold: number;
+}
+/**
+ * Settings to configure the CullerRenderer.
+ */
+export declare class CullerRendererConfigManager extends Configurator<CullerRenderer, CullerRendererConfigType> {
+    protected _config: CullerRendererConfigType;
+    private _interval;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get autoUpdate(): boolean;
+    set autoUpdate(value: boolean);
+    get updateInterval(): number;
+    set updateInterval(value: number);
+    get renderDebugFrame(): boolean;
+    set renderDebugFrame(value: boolean);
+    get threshold(): number;
+    set threshold(value: number);
+    setWidthHeight(width: number, height: number): void;
+    setAutoAndInterval(auto: boolean, interval: number): void;
+    private resetRenderTarget;
+    private resetInterval;
+}
+export {};
+import { Topic } from "..";
+import { Viewpoint } from "../../../core/Viewpoints";
+import { Components } from "../../../core/Components";
+/**
+ * Represents a comment in a BCF Topic.
+ */
+export declare class Comment {
+    date: Date;
+    author: string;
+    guid: string;
+    viewpoint?: Viewpoint;
+    modifiedAuthor?: string;
+    modifiedDate?: Date;
+    topic?: Topic;
+    private _components;
+    private _comment;
+    /**
+     * Sets the comment text and updates the modified date and author.
+     * The author will be the one defined in BCFTopics.config.author
+     * @param value - The new comment text.
+     */
+    set comment(value: string);
+    /**
+     * Gets the comment text.
+     * @returns The comment text.
+     */
+    get comment(): string;
+    /**
+     * Constructs a new BCF Topic Comment instance.
+     * @param components - The Components instance.
+     * @param text - The initial comment text.
+     */
+    constructor(components: Components, text: string);
+    /**
+     * Serializes the Comment instance into a BCF compliant XML string.
+     *
+     * @returns A string representing the Comment in BCFv2 XML format.
+     */
+    serialize(): string;
+}
+import { BCFTopics } from "../..";
+export declare const extensionsImporter: (manager: BCFTopics, extensionsXML: string) => void;
+import { BufferGeometry } from "three";
+import * as THREE from "three";
+export declare class TransformHelper {
+    getHelper(geometries: BufferGeometry[]): THREE.Object3D<THREE.Object3DEventMap>;
+}
 import * as WEBIFC from "web-ifc";
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {