@thatopen/components 2.1.9 → 2.1.11

package/dist/namespace.d.ts

@@ -1,1015 +1,602 @@
 declare namespace OBC {
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Components, Disposable, Event } from "../../core";
-/**
- * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but it's fast, and should suffice for general use cases such as camera zooming or general boundary determination. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
- */
-export declare class BoundingBoxer extends Component implements Disposable {
-    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    private _absoluteMin;
-    private _absoluteMax;
-    private _meshes;
-    constructor(components: Components);
-    /**
-     * A static method to calculate the dimensions of a given bounding box.
-     *
-     * @param bbox - The bounding box to calculate the dimensions for.
-     * @returns An object containing the width, height, depth, and center of the bounding box.
-     */
-    static getDimensions(bbox: THREE.Box3): {
-        width: number;
-        height: number;
-        depth: number;
-        center: THREE.Vector3;
-    };
-    /**
-     * A static method to create a new bounding box boundary.
-     *
-     * @param positive - A boolean indicating whether to create a boundary for positive or negative values.
-     * @returns A new THREE.Vector3 representing the boundary.
-     *
-     * @remarks
-     * This method is used to create a new boundary for calculating bounding boxes.
-     * It sets the x, y, and z components of the returned vector to positive or negative infinity,
-     * depending on the value of the 'positive' parameter.
-     *
-     * @example
-     * '''typescript
-     * const positiveBound = BoundingBoxer.newBound(true);
-     * console.log(positiveBound); // Output: Vector3 { x: Infinity, y: Infinity, z: Infinity }
-     *
-     * const negativeBound = BoundingBoxer.newBound(false);
-     * console.log(negativeBound); // Output: Vector3 { x: -Infinity, y: -Infinity, z: -Infinity }
-     * '''
-     */
-    static newBound(positive: boolean): THREE.Vector3;
-    /**
-     * A static method to calculate the bounding box of a set of points.
-     *
-     * @param points - An array of THREE.Vector3 representing the points.
-     * @param min - An optional THREE.Vector3 representing the minimum bounds. If not provided, it will be calculated.
-     * @param max - An optional THREE.Vector3 representing the maximum bounds. If not provided, it will be calculated.
-     * @returns A THREE.Box3 representing the bounding box of the given points.
-     *
-     * @remarks
-     * This method calculates the bounding box of a set of points by iterating through each point and updating the minimum and maximum bounds accordingly.
-     * If the 'min' or 'max' parameters are provided, they will be used as the initial bounds. Otherwise, the initial bounds will be set to positive and negative infinity.
-     *
-     * @example
-     * '''typescript
-     * const points = [
-     *   new THREE.Vector3(1, 2, 3),
-     *   new THREE.Vector3(4, 5, 6),
-     *   new THREE.Vector3(7, 8, 9),
-     * ];
-     *
-     * const bbox = BoundingBoxer.getBounds(points);
-     * console.log(bbox); // Output: Box3 { min: Vector3 { x: 1, y: 2, z: 3 }, max: Vector3 { x: 7, y: 8, z: 9 } }
-     * '''
-     */
-    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Returns the bounding box of the calculated fragments.
-     *
-     * @returns A new THREE.Box3 instance representing the bounding box.
-     *
-     * @remarks
-     * This method clones the internal minimum and maximum vectors and returns a new THREE.Box3 instance.
-     * The returned box represents the bounding box of the calculated fragments.
-     *
-     * @example
-     * '''typescript
-     * const boundingBox = boundingBoxer.get();
-     * console.log(boundingBox); // Output: Box3 { min: Vector3 { x: -10, y: -10, z: -10 }, max: Vector3 { x: 10, y: 10, z: 10 } }
-     * '''
-     */
-    get(): THREE.Box3;
-    /**
-     * Calculates and returns a sphere that encompasses the entire bounding box.
-     *
-     * @returns A new THREE.Sphere instance representing the calculated sphere.
-     *
-     * @remarks
-     * This method calculates the center and radius of a sphere that encompasses the entire bounding box.
-     * The center is calculated as the midpoint between the minimum and maximum bounds of the bounding box.
-     * The radius is calculated as the distance from the center to the minimum bound.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * const boundingSphere = boundingBoxer.getSphere();
-     * console.log(boundingSphere); // Output: Sphere { center: Vector3 { x: 0, y: 0, z: 0 }, radius: 10 }
-     * '''
-     */
-    getSphere(): THREE.Sphere;
-    /**
-     * Returns a THREE.Mesh instance representing the bounding box.
-     *
-     * @returns A new THREE.Mesh instance representing the bounding box.
-     *
-     * @remarks
-     * This method calculates the dimensions of the bounding box using the 'getDimensions' method.
-     * It then creates a new THREE.BoxGeometry with the calculated dimensions.
-     * A new THREE.Mesh is created using the box geometry, and it is added to the '_meshes' array.
-     * The position of the mesh is set to the center of the bounding box.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * const boundingBoxMesh = boundingBoxer.getMesh();
-     * scene.add(boundingBoxMesh);
-     * '''
-     */
-    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
-    /**
-     * Resets the internal minimum and maximum vectors to positive and negative infinity, respectively.
-     * This method is used to prepare the BoundingBoxer for a new set of fragments.
-     *
-     * @remarks
-     * This method is called when a new set of fragments is added to the BoundingBoxer.
-     * It ensures that the bounding box calculations are accurate and up-to-date.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * // ...
-     * boundingBoxer.reset();
-     * '''
-     */
-    reset(): void;
-    /**
-     * Adds a FragmentsGroup to the BoundingBoxer.
-     *
-     * @param group - The FragmentsGroup to add.
-     *
-     * @remarks
-     * This method iterates through each fragment in the provided FragmentsGroup,
-     * and calls the 'addMesh' method for each fragment's mesh.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.add(fragmentsGroup);
-     * '''
-     */
-    add(group: FragmentsGroup): void;
-    /**
-     * Adds a mesh to the BoundingBoxer and calculates the bounding box.
-     *
-     * @param mesh - The mesh to add. It can be an instance of THREE.InstancedMesh, THREE.Mesh, or FRAGS.CurveMesh.
-     * @param itemIDs - An optional iterable of numbers representing the item IDs.
-     *
-     * @remarks
-     * This method calculates the bounding box of the provided mesh and updates the internal minimum and maximum vectors.
-     * If the mesh is an instance of THREE.InstancedMesh, it calculates the bounding box for each instance.
-     * If the mesh is an instance of FRAGS.FragmentMesh and itemIDs are provided, it calculates the bounding box for the specified item IDs.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * boundingBoxer.addMesh(mesh);
-     * '''
-     */
-    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
-    /**
-     * Uses a FragmentIdMap to add its meshes to the bb calculation.
-     *
-     * This method iterates through the provided 'fragmentIdMap', retrieves the corresponding fragment from the 'FragmentsManager',
-     * and then calls the 'addMesh' method for each fragment's mesh, passing the expression IDs as the second parameter.
-     *
-     * @param fragmentIdMap - A mapping of fragment IDs to their corresponding expression IDs.
-     *
-     * @remarks
-     * This method is used to add a mapping of fragment IDs to their corresponding expression IDs.
-     * It ensures that the bounding box calculations are accurate and up-to-date by updating the internal minimum and maximum vectors.
-     *
-     * @example
-     * '''typescript
-     * const boundingBoxer = components.get(BoundingBoxer);
-     * const fragmentIdMap: FRAGS.FragmentIdMap = {
-     *   '5991fa75-2eef-4825-90b3-85177f51a9c9': [123, 245, 389],
-     *   '3469077e-39bf-4fc9-b3e6-4a1d78ad52b0': [454, 587, 612],
-     * };
-     * boundingBoxer.addFragmentIdMap(fragmentIdMap);
-     * '''
-     */
-    addFragmentIdMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
-    private static getFragmentBounds;
-}
-import { Component, Disposable, Event, Components } from "../../core";
-/**
- * The Exploder component is responsible for managing the explosion of 3D model fragments (generally by floor). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Exploder). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Exploder).
- */
-export declare class Exploder extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * The height of the explosion animation.
-     * This property determines the vertical distance by which fragments are moved during the explosion.
-     * Default value is 10.
-     */
-    height: number;
-    /**
-     * The group name used for the explosion animation.
-     * This property specifies the group of fragments that will be affected by the explosion.
-     * Default value is "storeys".
-     */
-    groupName: string;
-    /**
-     * A set of strings representing the exploded items.
-     * This set is used to keep track of which items have been exploded.
-     */
-    list: Set<string>;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets the explosion state of the fragments.
-     *
-     * @param active - A boolean indicating whether to activate or deactivate the explosion.
-     *
-     * @remarks
-     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
-     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
-     * If 'active' is false, the fragments are moved back to their original position.
-     *
-     * The method also keeps track of the exploded items using the 'list' set.
-     *
-     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
-     */
-    set(active: boolean): void;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
-/**
- * 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;
-        };
-    };
-}
+import { Component, Disposable, Event } 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).
- */
-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;
+ * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
+ */
+export declare class Components implements Disposable {
     /**
-     * A map representing the classification systems.
-     * The key is the system name, and the value is an object representing the classes within the system.
+     * The version of the @thatopen/components library.
      */
-    list: Classification;
+    static readonly release = "2.1.11";
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    readonly onDisposed: Event<void>;
     /**
-     * Removes a fragment from the classification based on its unique identifier (guid).
-     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
-     *
-     * @param guid - The unique identifier of the fragment to be removed.
+     * The list of components created in this app.
+     * The keys are UUIDs and the values are instances of the components.
      */
-    remove(guid: string): void;
+    readonly list: Map<string, Component>;
     /**
-     * Finds and returns fragments based on the provided filter criteria.
-     * If no filter is provided, it returns all fragments.
-     *
-     * @param filter - An optional object containing filter criteria.
-     * The keys of the object represent the classification system names,
-     * and the values are arrays of class names to match.
-     *
-     * @returns A map of fragment GUIDs to their respective express IDs,
-     * where the express IDs are filtered based on the provided filter criteria.
-     *
-     * @throws Will throw an error if the fragments map is malformed.
+     * If disabled, the animation loop will be stopped.
+     * Default value is false.
      */
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
+    enabled: boolean;
+    private _clock;
     /**
-     * Classifies fragments based on their modelID.
+     * Adds a component to the list of components.
+     * Throws an error if a component with the same UUID already exists.
      *
-     * @param modelID - The unique identifier of the model to classify fragments by.
-     * @param group - The FragmentsGroup containing the fragments to be classified.
+     * @param uuid - The unique identifier of the component.
+     * @param instance - The instance of the component to be added.
      *
-     * @remarks
-     * This method iterates through the fragments in the provided group,
-     * and classifies them based on their modelID.
-     * The classification is stored in the 'list.models' property,
-     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
+     * @throws Will throw an error if a component with the same UUID already exists.
      *
+     * @internal
      */
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    add(uuid: string, instance: Component): void;
     /**
-     * Classifies fragments based on their PredefinedType property.
+     * Retrieves a component instance by its constructor function.
+     * If the component does not exist in the list, it will be created and added.
      *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
+     * @template U - The type of the component to retrieve.
+     * @param Component - The constructor function of the component to retrieve.
      *
-     * @remarks
-     * This method iterates through the properties of the fragments in the provided group,
-     * and classifies them based on their PredefinedType property.
-     * The classification is stored in the 'list.predefinedTypes' property,
-     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
+     * @returns The instance of the requested component.
      *
-     * @throws Will throw an error if the fragment ID is not found.
+     * @throws Will throw an error if a component with the same UUID already exists.
+     *
+     * @internal
      */
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    get<U extends Component>(Component: new (components: Components) => U): U;
+    constructor();
     /**
-     * Classifies fragments based on their entity type.
-     *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on their entity type.
-     * The classification is stored in the 'list.entities' property,
-     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
+     * Initializes the Components instance.
+     * This method starts the animation loop, sets the enabled flag to true,
+     * and calls the update method.
      *
-     * @throws Will throw an error if the fragment ID is not found.
+     * @returns {void}
      */
-    byEntity(group: FRAGS.FragmentsGroup): void;
+    init(): void;
     /**
-     * Classifies fragments based on a specific IFC relationship.
+     * Disposes the memory of all the components and tools of this instance of
+     * the library. A memory leak will be created if:
      *
-     * @param group - The FragmentsGroup containing the fragments to be classified.
-     * @param ifcRel - The IFC relationship number to classify fragments by.
-     * @param systemName - The name of the classification system to store the classification.
+     * - An instance of the library ends up out of scope and this function isn't
+     * called. This is especially relevant in Single Page Applications (React,
+     * Angular, Vue, etc).
      *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on the specified IFC relationship.
-     * The classification is stored in the 'list' property under the specified system name,
-     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     * - Any of the objects of this instance (meshes, geometries,materials, etc) is
+     * referenced by a reference type (object or array).
+     *
+     * You can learn more about how Three.js handles memory leaks
+     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
      *
-     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
      */
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    dispose(): void;
+    private update;
+    private static setupBVH;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { Component } from "../Types";
+/**
+ * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ */
+export declare class Disposer extends Component {
+    private _disposedComponents;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * Classifies fragments based on their spatial structure in the IFC model.
-     *
-     * @param model - The FragmentsGroup containing the fragments to be classified.
-     * @param config - The configuration for the classifier. It includes "useProperties", which is true by default
-     * (if false, the classification will use the expressIDs instead of the names), and "isolate", which will make
-     * the classifier just pick the WEBIFC categories provided.
-     *
-     * @remarks
-     * This method iterates through the relations of the fragments in the provided group,
-     * and classifies them based on their spatial structure in the IFC model.
-     * The classification is stored in the 'list' property under the system name "spatialStructures",
-     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
-     *
-     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    bySpatialStructure(model: FRAGS.FragmentsGroup, config: {
-        useProperties?: boolean;
-        isolate?: Set<number>;
-    }): Promise<void>;
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
+    constructor(components: Components);
     /**
-     * Sets the color of the specified fragments.
+     * Return the UUIDs of all disposed components.
+     */
+    get(): Set<string>;
+    /**
+     * Removes a mesh, its geometry and its materials from memory. If you are
+     * using any of these in other parts of the application, make sure that you
+     * remove them from the mesh before disposing it.
      *
-     * @param items - A map of fragment IDs to their respective express IDs.
-     * @param color - The color to set for the fragments.
-     * @param override - A boolean indicating whether to override the existing color of the fragments.
+     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
+     * to remove.
      *
-     * @remarks
-     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
-     * and sets their color using the 'setColor' method of the FragmentsGroup class.
+     * @param materials - whether to dispose the materials of the mesh.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @param recursive - whether to recursively dispose the children of the mesh.
      */
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
     /**
-     * Resets the color of the specified fragments to their original color.
-     *
-     * @param items - A map of fragment IDs to their respective express IDs.
-     *
-     * @remarks
-     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
-     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
+     * Disposes a geometry from memory.
      *
-     * @throws Will throw an error if the fragment with the specified ID is not found.
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
      */
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
 }
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
+import { Components } from "../Components";
 /**
- * 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 manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
  */
-export declare class Hider extends Component {
+export declare class Raycasters extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
     /** {@link Component.enabled} */
     enabled: boolean;
+    /**
+     * A Map that stores raycasters for each world.
+     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     */
+    list: Map<string, SimpleRaycaster>;
+    /** {@link Disposable.onDisposed} */
+    onDisposed: Event<unknown>;
     constructor(components: Components);
     /**
-     * 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.
+     * Retrieves a SimpleRaycaster instance for the given world.
+     * If a SimpleRaycaster instance already exists for the world, it will be returned.
+     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
      *
-     * @returns {void}
+     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
+     * @returns The SimpleRaycaster instance for the given world.
      */
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    get(world: World): SimpleRaycaster;
     /**
-     * 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.
+     * Deletes the SimpleRaycaster instance associated with the given world.
+     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
      *
+     * @param world - The world for which to delete the SimpleRaycaster instance.
      * @returns {void}
      */
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
 }
-import * as WEBIFC from "web-ifc";
-import { Components, Disposable, Event, Component } from "../../core";
-import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
+import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
+import { Components } from "../Components";
+import { SimpleWorld } from "./src";
 /**
- * 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).
+ * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
  */
-export declare class 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: "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;
-    }>;
+export declare class Worlds extends Component implements Updateable, Disposable {
     /**
-     * Event triggered when assets are streamed.
-     * Contains the streamed assets.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    readonly onAssetStreamed: Event<StreamedAsset[]>;
+    static readonly uuid: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * Event triggered to indicate the progress of the streaming process.
-     * Contains the progress percentage.
+     * An event that is triggered when a new world is created.
+     * The event passes the newly created world as a parameter.
      */
-    readonly onProgress: Event<number>;
+    readonly onWorldCreated: Event<World>;
     /**
-     * Event triggered when the IFC file is loaded.
-     * Contains the loaded IFC file data.
+     * An event that is triggered when a world is deleted.
+     * The event passes the UUID of the deleted world as a parameter.
      */
-    readonly onIfcLoaded: Event<Uint8Array>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    readonly onWorldDeleted: Event<string>;
     /**
-     * Settings for the IfcGeometryTiler.
+     * A collection of worlds managed by this component.
+     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
      */
-    settings: IfcStreamingSettings;
+    list: Map<string, World>;
     /** {@link Component.enabled} */
     enabled: boolean;
-    /**
-     * The WebIFC API instance used for IFC file processing.
-     */
-    webIfc: WEBIFC.IfcAPI;
-    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(): void;
     /**
-     * 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.
+     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
      *
-     * @remarks
-     * This method cleans up any resources after the streaming process is complete.
+     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
+     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
+     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
      *
-     * @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);
-     * '''
+     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
      */
-    streamFromBuffer(data: Uint8Array): Promise<void>;
+    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
     /**
-     * This method streams the IFC file from a given callback.
+     * Deletes a world from the list of worlds.
      *
-     * @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.
+     * @param {World} world - The world to be deleted.
      *
-     * @remarks
-     * This method cleans up any resources after the streaming process is complete.
+     * @throws {Error} - Throws an error if the provided world is not found in the list.
      *
+     * @returns {void}
      */
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllGeometries;
-    private cleanUp;
-    private getMesh;
-    private getGeometry;
-    private streamAssets;
-    private streamGeometries;
-}
-import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Represents an edge measurement result.
- */
-export interface MeasureEdge {
-    /**
-     * The distance between the two points of the edge.
-     */
-    distance: number;
+    delete(world: World): void;
     /**
-     * The two points that define the edge.
+     * Disposes of the Worlds component and all its managed worlds.
+     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
+     * and triggers the onDisposed event.
+     *
+     * @returns {void}
      */
-    points: THREE.Vector3[];
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(delta?: number): void | Promise<void>;
 }
+import { Component, Disposable, World, Event } from "../Types";
+import { GridConfig, SimpleGrid } from "./src";
+import { Components } from "../Components";
 /**
- * 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).
+ * 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 MeasurementUtils extends Component {
+export declare class Grids extends Component implements Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static uuid: string;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Utility method to calculate the distance from a point to a line segment.
-     *
-     * @param point - The point from which to calculate the distance.
-     * @param lineStart - The start point of the line segment.
-     * @param lineEnd - The end point of the line segment.
-     * @param clamp - If true, the distance will be clamped to the line segment's length.
-     * @returns The distance from the point to the line segment.
-     */
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    /**
-     * Method to get the face of a mesh that contains a given triangle index.
-     * It also returns the edges of the found face and their indices.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param triangleIndex - The index of the triangle within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
-     */
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
+    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
     /**
-     * Method to get the vertices and normal of a mesh face at a given index.
-     * It also applies instance transformation if provided.
-     *
-     * @param mesh - The mesh to get the face from. It must be indexed.
-     * @param faceIndex - The index of the face within the mesh.
-     * @param instance - The instance of the mesh (optional).
-     * @returns An object containing the vertices and normal of the face.
-     * @throws Will throw an error if the geometry is not indexed.
+     * A map of world UUIDs to their corresponding grid instances.
      */
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
+    list: Map<string, SimpleGrid>;
     /**
-     * Method to round the vector's components to a specified number of decimal places.
-     * This is used to ensure numerical precision in edge detection.
-     *
-     * @param vector - The vector to round.
-     * @returns The vector with rounded components.
+     * The default configuration for grid creation.
      */
-    round(vector: THREE.Vector3): void;
+    config: Required<GridConfig>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
     /**
-     * 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.
+     * Creates a new grid for the given world.
+     * Throws an error if a grid already exists for the world.
      *
-     * @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.
+     * @param world - The world to create the grid for.
+     * @returns The newly created grid.
      *
-     * @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.
+     * @throws Will throw an error if a grid already exists for the given world.
      */
-    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    create(world: World): SimpleGrid;
     /**
-     * Calculates the total volume of a set of meshes.
+     * Deletes the grid associated with the given world.
+     * If a grid does not exist for the given world, this method does nothing.
      *
-     * @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 world for which to delete the grid.
      *
      * @remarks
-     * This method calculates the volume of each mesh in the provided array and returns the total volume
-     * and its bounding sphere.
-     *
+     * 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.
      */
-    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
-    private getFaceData;
-    private getVolumeOfMesh;
-    private getSignedVolumeOfTriangle;
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
 }
-import * as WEBIFC from "web-ifc";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
+import { Components } from "../Components";
 /**
- * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
+ * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
  */
-export declare class IfcJsonExporter extends Component {
+export declare class MiniMaps extends Component implements Updateable, Disposable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /** {@link Component.enabled} */
     enabled: boolean;
+    /**
+     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
+     */
+    list: Map<string, MiniMap>;
     constructor(components: Components);
     /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
+     * Creates a new {@link MiniMap} instance associated with the given world.
+     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
+     *
+     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
+     * @returns The newly created {@link MiniMap} instance.
+     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
      */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+    create(world: World): MiniMap;
+    /**
+     * Deletes a {@link MiniMap} instance associated with the given world ID.
+     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
+     *
+     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
+     * @returns {void}
+     */
+    delete(id: string): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Updateable.update} */
+    update(): void;
 }
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-import { IfcFragmentSettings } from "./src";
-import { Component, Components, Event, Disposable } from "../../core";
+import { Components } from "../Components";
+import { MeshCullerRenderer, CullerRendererSettings } from "./src";
+import { Component, Event, Disposable, World } from "../Types";
 /**
- * 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).
+ * 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 IfcLoader 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: "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>;
+    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
     /**
-     * The settings for the IfcLoader.
-     * It includes options for excluding categories, setting WASM paths, and more.
+     * An event that is triggered when the Cullers component is disposed.
      */
-    settings: IfcFragmentSettings;
+    readonly onDisposed: Event<unknown>;
+    private _enabled;
     /**
-     * The instance of the Web-IFC library used for handling IFC data.
+     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
      */
-    webIfc: WEBIFC.IfcAPI;
+    list: Map<string, MeshCullerRenderer>;
     /** {@link Component.enabled} */
-    enabled: boolean;
-    private _material;
-    private _spatialTree;
-    private _metaData;
-    private _fragmentInstances;
-    private _civil;
-    private _visitedFragments;
-    private _materialT;
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(value: boolean);
     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.
-     *
-     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
-     *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * const group = await ifcLoader.load(ifcData);
-     * '''
-     */
-    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
     /**
-     * Reads an IFC file and initializes the Web-IFC library.
-     *
-     * @param data - The Uint8Array containing the IFC file data.
-     *
-     * @returns A Promise that resolves when the IFC file is opened and initialized.
+     * Creates a new MeshCullerRenderer for the given world.
+     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
      *
-     * @remarks
-     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
-     * It also opens the IFC model using the provided data and settings.
+     * @param world - The world for which to create the MeshCullerRenderer.
+     * @param config - Optional configuration settings for the MeshCullerRenderer.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * await ifcLoader.readIfcFile(ifcData);
-     * '''
+     * @returns The newly created or existing MeshCullerRenderer for the given world.
      */
-    readIfcFile(data: Uint8Array): Promise<number>;
+    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
     /**
-     * Cleans up the IfcLoader component by resetting the Web-IFC library,
-     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
+     * 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.
      *
-     * @remarks
-     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
+     * @param world - The world for which to delete the MeshCullerRenderer.
      *
-     * @example
-     * '''typescript
-     * const ifcLoader = components.get(IfcLoader);
-     * ifcLoader.cleanUp();
-     * '''
+     * @returns {void}
      */
-    cleanUp(): void;
-    private getAllGeometries;
-    private getMesh;
-    private getGeometry;
-    private autoSetWasm;
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
 }
-import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Component, Components, Event, Disposable } from "../../core";
-import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
+import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
+import { SimplePlane } from "./src";
+import { Components } from "../Components";
 /**
- * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
+ * 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 FragmentsManager extends Component implements Disposable {
+export declare class Clipper extends Component implements Createable, Disposable, Hideable {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    static readonly uuid: "66290bc5-18c4-4cd1-9379-2e17a0617611";
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onBeforeDrag: Event<void>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onAfterDrag: Event<void>;
     /**
-     * Event triggered when fragments are loaded.
+     * Event that fires when the user starts creating a clipping plane.
      */
-    readonly onFragmentsLoaded: Event<FragmentsGroup>;
+    readonly onBeforeCreate: Event<unknown>;
     /**
-     * Event triggered when fragments are disposed.
+     * Event that fires when the user cancels the creation of a clipping plane.
      */
-    readonly onFragmentsDisposed: Event<{
-        groupID: string;
-        fragmentIDs: string[];
-    }>;
+    readonly onBeforeCancel: Event<unknown>;
     /**
-     * Map containing all loaded fragments.
-     * The key is the fragment's unique identifier, and the value is the fragment itself.
+     * Event that fires after the user cancels the creation of a clipping plane.
      */
-    readonly list: Map<string, Fragment>;
+    readonly onAfterCancel: Event<unknown>;
     /**
-     * Map containing all loaded fragment groups.
-     * The key is the group's unique identifier, and the value is the group itself.
+     * Event that fires when the user starts deleting a clipping plane.
      */
-    readonly groups: Map<string, FragmentsGroup>;
-    baseCoordinationModel: string;
-    baseCoordinationMatrix: THREE.Matrix4;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    private _loader;
+    readonly onBeforeDelete: Event<unknown>;
     /**
-     * Getter for the meshes of all fragments in the FragmentsManager.
-     * It iterates over the fragments in the list and pushes their meshes into an array.
-     * @returns {THREE.Mesh[]} An array of THREE.Mesh objects representing the fragments.
+     * Event that fires after a clipping plane has been created.
+     * @param plane - The newly created clipping plane.
      */
-    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    readonly onAfterCreate: Event<SimplePlane>;
     /**
-     * Dispose of a specific fragment group.
-     * This method removes the group from the groups map, deletes all fragments within the group from the list,
-     * disposes of the group, and triggers the onFragmentsDisposed event.
-     *
-     * @param group - The fragment group to be disposed.
+     * Event that fires after a clipping plane has been deleted.
+     * @param plane - The deleted clipping plane.
      */
-    disposeGroup(group: FragmentsGroup): void;
+    readonly onAfterDelete: Event<SimplePlane>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
     /**
-     * Loads a binary file that contain fragment geometry.
-     * @param data - The binary data to load.
-     * @param config - Optional configuration for loading.
-     * @param config.coordinate - Whether to apply coordinate transformation. Default is true.
-     * @param config.properties - Ifc properties to set on the loaded fragments. Not to be used when streaming.
-     * @returns The loaded FragmentsGroup.
+     * Whether to force the clipping plane to be orthogonal in the Y direction
+     * (up). This is desirable when clipping a building horizontally and a
+     * clipping plane is created in its roof, which might have a slight
+     * slope for draining purposes.
      */
-    load(data: Uint8Array, config?: Partial<{
-        coordinate: boolean;
-        name: string;
-        properties: FRAGS.IfcProperties;
-        relationsMap: RelationsMap;
-    }>): FragmentsGroup;
+    orthogonalY: boolean;
     /**
-     * Export the specified fragmentsgroup to binary data.
-     * @param group - the fragments group to be exported.
-     * @returns the exported data as binary buffer.
+     * The tolerance that determines whether an almost-horizontal clipping plane
+     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
+     * has to be 'true' for this to apply.
      */
-    export(group: FragmentsGroup): Uint8Array;
+    toleranceOrthogonalY: number;
     /**
-     * Gets a map of model IDs to sets of express IDs for the given fragment ID map.
-     * @param fragmentIdMap - A map of fragment IDs to their corresponding express IDs.
-     * @returns A map of model IDs to sets of express IDs.
+     * The type of clipping plane to be created.
+     * Default is {@link SimplePlane}.
      */
-    getModelIdMap(fragmentIdMap: FRAGS.FragmentIdMap): {
-        [modelID: string]: Set<number>;
-    };
+    Type: new (...args: any) => SimplePlane;
     /**
-     * Converts a map of model IDs to sets of express IDs to a fragment ID map.
-     * @param modelIdMap - A map of model IDs to their corresponding express IDs.
-     * @returns A fragment ID map.
-     * @remarks
-     * This method iterates through the provided model ID map, retrieves the corresponding model from the 'groups' map,
-     * and then calls the 'getFragmentMap' method of the model to obtain a fragment ID map for the given express IDs.
-     * The fragment ID maps are then merged into a single map and returned.
-     * If a model with a given ID is not found in the 'groups' map, the method skips that model and continues with the next one.
+     * A list of all the clipping planes created by this component.
      */
-    modelIdToFragmentIdMap(modelIdMap: {
-        [modelID: string]: Set<number>;
-    }): FRAGS.FragmentIdMap;
+    list: SimplePlane[];
+    /** The material used in all the clipping planes. */
+    private _material;
+    private _size;
+    private _enabled;
+    private _visible;
+    /** {@link Component.enabled} */
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The material of the clipping plane representation. */
+    get material(): THREE.MeshBasicMaterial;
+    /** The material of the clipping plane representation. */
+    set material(material: THREE.MeshBasicMaterial);
+    /** The size of the geometric representation of the clippings planes. */
+    get size(): number;
+    /** The size of the geometric representation of the clippings planes. */
+    set size(size: number);
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** {@link Createable.create} */
+    create(world: World): SimplePlane | null;
     /**
-     * Applies coordinate transformation to the provided models.
-     * If no models are provided, all groups are used.
-     * The first model in the list becomes the base model for coordinate transformation.
-     * All other models are then transformed to match the base model's coordinate system.
+     * Creates a plane in a certain place and with a certain orientation,
+     * without the need of the mouse.
      *
-     * @param models - The models to apply coordinate transformation to.
-     * If not provided, all models are used.
+     * @param world - the world where this plane should be created.
+     * @param normal - the orientation of the clipping plane.
+     * @param point - the position of the clipping plane.
+     * navigation.
      */
-    coordinate(models?: FragmentsGroup[]): void;
+    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): SimplePlane;
     /**
-     * Applies the base coordinate system to the provided object.
-     *
-     * This function takes an object and its original coordinate system as input.
-     * It then inverts the original coordinate system and applies the base coordinate system
-     * to the object. This ensures that the object's position, rotation, and scale are
-     * transformed to match the base coordinate system (which is taken from the first model loaded).
+     * {@link Createable.delete}
      *
-     * @param object - The object to which the base coordinate system will be applied.
-     * This should be an instance of THREE.Object3D.
+     * @param world - the world where the plane to delete is.
+     * @param plane - the plane to delete. If undefined, the first plane
+     * found under the cursor will be deleted.
+     */
+    delete(world: World, plane?: SimplePlane): void;
+    /**
+     * Deletes all the existing clipping planes.
      *
-     * @param originalCoordinateSystem - The original coordinate system of the object.
-     * This should be a THREE.Matrix4 representing the object's transformation matrix.
+     * @param types - the types of planes to be deleted. If not provided, all planes will be deleted.
      */
-    applyBaseCoordinateSystem(object: THREE.Object3D | THREE.Vector3, originalCoordinateSystem: THREE.Matrix4): void;
+    deleteAll(types?: Set<string>): void;
+    private deletePlane;
+    private pickPlane;
+    private getAllPlaneMeshes;
+    private createPlaneFromIntersection;
+    private getWorldNormal;
+    private normalizePlaneDirectionY;
+    private newPlane;
+    private updateMaterialsAndPlanes;
+    private _onStartDragging;
+    private _onEndDragging;
 }
-import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../core";
-import { PropertiesStreamingSettings } from "./src";
+import * as THREE from "three";
+import { Components } from "../Components";
+import { SimpleCamera } from "..";
+import { NavigationMode, NavModeID, ProjectionManager } 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 flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
  */
-export declare class IfcPropertiesTiler extends Component implements Disposable {
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * A ProjectionManager instance that manages the projection modes of the camera.
      */
-    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    readonly projection: ProjectionManager;
     /**
-     * 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.
+     * A THREE.OrthographicCamera instance that represents the orthographic camera.
+     * This camera is used when the projection mode is set to orthographic.
      */
-    readonly onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
-    }>;
+    readonly threeOrtho: THREE.OrthographicCamera;
     /**
-     * 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.
+     * A THREE.PerspectiveCamera instance that represents the perspective camera.
+     * This camera is used when the projection mode is set to perspective.
      */
-    readonly onProgress: AsyncEvent<number>;
+    readonly threePersp: THREE.PerspectiveCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    protected _mode: NavigationMode | null;
+    private previousSize;
     /**
-     * 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.
+     * Getter for the current navigation mode.
+     * Throws an error if the mode is not found or the camera is not initialized.
+     *
+     * @returns {NavigationMode} The current navigation mode.
+     *
+     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
      */
-    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+    get mode(): NavigationMode;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
+     * Sets a new {@link NavigationMode} and disables the previous one.
+     *
+     * @param mode - The {@link NavigationMode} to set.
      */
-    settings: PropertiesStreamingSettings;
+    set(mode: NavModeID): void;
     /**
-     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
+     * Make the camera view fit all the specified meshes.
+     *
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
      */
-    webIfc: WEBIFC.IfcAPI;
-    /** {@link Disposable.dispose} */
-    dispose(): Promise<void>;
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
     /**
-     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
+     * Allows or prevents all user input.
      *
-     * @param data - The Uint8Array containing the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
+     * @param active - whether to enable or disable user inputs.
      */
-    streamFromBuffer(data: Uint8Array): Promise<void>;
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoPerspCameraAspect;
+}
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Component to export all the properties from an IFC to a JS object. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/IfcJsonExporter). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/IfcJsonExporter).
+ */
+export declare class IfcJsonExporter extends Component {
     /**
-     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
-     *
-     * @param loadCallback - A callback function that loads the IFC file data.
-     * @returns A Promise that resolves when the streaming process is complete.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllProperties;
-    private cleanUp;
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc](https://github.com/ThatOpen/engine_web-ifc) to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
+     */
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
 }
 import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
 export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
 import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
@@ -1392,622 +979,930 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      * @returns A JSON string representing the serialized relations of all models processed by the indexer.
      *          If no relations have been indexed, an empty object is returned as a JSON string.
      */
-    serializeAllRelations(): string;
+    serializeAllRelations(): string;
+    /**
+     * Converts a JSON string representing relations between entities into a structured map.
+     * This method parses the JSON string to reconstruct the relations map that indexes
+     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
+     * and the values are maps where each key is a relation type ID and its value is an array
+     * of express IDs of entities related through that relation type.
+     *
+     * @param json The JSON string to be parsed into the relations map.
+     * @returns A 'Map' where the key is the express ID of an entity as a number, and the value
+     * is another 'Map'. This inner map's key is the relation type ID as a number, and its value
+     * is an array of express IDs (as numbers) of entities related through that relation type.
+     */
+    getRelationsMapFromJSON(json: string): RelationsMap;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Adds relations between an entity and other entities in a BIM model.
+     *
+     * @param model - The BIM model to which the relations will be added.
+     * @param expressID - The expressID of the entity within the model.
+     * @param relationName - The IFC schema inverse attribute of the relation to add (e.g., "IsDefinedBy", "ContainsElements").
+     * @param relIDs - The expressIDs of the related entities within the model.
+     *
+     * @throws An error if the relation name is not a valid relation name.
+     */
+    addEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute, ...relIDs: number[]): void;
+    /**
+     * Gets the children of the given element recursively. E.g. in a model with project - site - building - storeys - rooms, passing a storey will include all its children and the children of the rooms contained in it.
+     *
+     * @param model The BIM model whose children to get.
+     * @param expressID The expressID of the item whose children to get.
+     * @param found An optional parameter that includes a set of expressIDs where the found element IDs will be added.
+     *
+     * @returns A 'Set' with the expressIDs of the found items.
+     */
+    getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
+}
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Components, Disposable, Event } from "../../core";
+/**
+ * A simple implementation of bounding box that works for fragments. The resulting bbox is not 100% precise, but it's fast, and should suffice for general use cases such as camera zooming or general boundary determination. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/BoundingBoxer). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/BoundingBoxer).
+ */
+export declare class BoundingBoxer extends Component implements Disposable {
+    static readonly uuid: "d1444724-dba6-4cdd-a0c7-68ee1450d166";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    private _absoluteMin;
+    private _absoluteMax;
+    private _meshes;
+    constructor(components: Components);
+    /**
+     * A static method to calculate the dimensions of a given bounding box.
+     *
+     * @param bbox - The bounding box to calculate the dimensions for.
+     * @returns An object containing the width, height, depth, and center of the bounding box.
+     */
+    static getDimensions(bbox: THREE.Box3): {
+        width: number;
+        height: number;
+        depth: number;
+        center: THREE.Vector3;
+    };
+    /**
+     * A static method to create a new bounding box boundary.
+     *
+     * @param positive - A boolean indicating whether to create a boundary for positive or negative values.
+     * @returns A new THREE.Vector3 representing the boundary.
+     *
+     * @remarks
+     * This method is used to create a new boundary for calculating bounding boxes.
+     * It sets the x, y, and z components of the returned vector to positive or negative infinity,
+     * depending on the value of the 'positive' parameter.
+     *
+     * @example
+     * '''typescript
+     * const positiveBound = BoundingBoxer.newBound(true);
+     * console.log(positiveBound); // Output: Vector3 { x: Infinity, y: Infinity, z: Infinity }
+     *
+     * const negativeBound = BoundingBoxer.newBound(false);
+     * console.log(negativeBound); // Output: Vector3 { x: -Infinity, y: -Infinity, z: -Infinity }
+     * '''
+     */
+    static newBound(positive: boolean): THREE.Vector3;
     /**
-     * Converts a JSON string representing relations between entities into a structured map.
-     * This method parses the JSON string to reconstruct the relations map that indexes
-     * entity relations by their express IDs. The outer map keys are the express IDs of entities,
-     * and the values are maps where each key is a relation type ID and its value is an array
-     * of express IDs of entities related through that relation type.
+     * A static method to calculate the bounding box of a set of points.
      *
-     * @param json The JSON string to be parsed into the relations map.
-     * @returns A 'Map' where the key is the express ID of an entity as a number, and the value
-     * is another 'Map'. This inner map's key is the relation type ID as a number, and its value
-     * is an array of express IDs (as numbers) of entities related through that relation type.
+     * @param points - An array of THREE.Vector3 representing the points.
+     * @param min - An optional THREE.Vector3 representing the minimum bounds. If not provided, it will be calculated.
+     * @param max - An optional THREE.Vector3 representing the maximum bounds. If not provided, it will be calculated.
+     * @returns A THREE.Box3 representing the bounding box of the given points.
+     *
+     * @remarks
+     * This method calculates the bounding box of a set of points by iterating through each point and updating the minimum and maximum bounds accordingly.
+     * If the 'min' or 'max' parameters are provided, they will be used as the initial bounds. Otherwise, the initial bounds will be set to positive and negative infinity.
+     *
+     * @example
+     * '''typescript
+     * const points = [
+     *   new THREE.Vector3(1, 2, 3),
+     *   new THREE.Vector3(4, 5, 6),
+     *   new THREE.Vector3(7, 8, 9),
+     * ];
+     *
+     * const bbox = BoundingBoxer.getBounds(points);
+     * console.log(bbox); // Output: Box3 { min: Vector3 { x: 1, y: 2, z: 3 }, max: Vector3 { x: 7, y: 8, z: 9 } }
+     * '''
      */
-    getRelationsMapFromJSON(json: string): RelationsMap;
+    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
     /** {@link Disposable.dispose} */
     dispose(): void;
     /**
-     * Adds relations between an entity and other entities in a BIM model.
+     * Returns the bounding box of the calculated fragments.
      *
-     * @param model - The BIM model to which the relations will be added.
-     * @param expressID - The expressID of the entity within the model.
-     * @param relationName - The IFC schema inverse attribute of the relation to add (e.g., "IsDefinedBy", "ContainsElements").
-     * @param relIDs - The expressIDs of the related entities within the model.
+     * @returns A new THREE.Box3 instance representing the bounding box.
      *
-     * @throws An error if the relation name is not a valid relation name.
+     * @remarks
+     * This method clones the internal minimum and maximum vectors and returns a new THREE.Box3 instance.
+     * The returned box represents the bounding box of the calculated fragments.
+     *
+     * @example
+     * '''typescript
+     * const boundingBox = boundingBoxer.get();
+     * console.log(boundingBox); // Output: Box3 { min: Vector3 { x: -10, y: -10, z: -10 }, max: Vector3 { x: 10, y: 10, z: 10 } }
+     * '''
      */
-    addEntityRelations(model: FragmentsGroup, expressID: number, relationName: InverseAttribute, ...relIDs: number[]): void;
+    get(): THREE.Box3;
     /**
-     * Gets the children of the given element recursively. E.g. in a model with project - site - building - storeys - rooms, passing a storey will include all its children and the children of the rooms contained in it.
+     * Calculates and returns a sphere that encompasses the entire bounding box.
      *
-     * @param model The BIM model whose children to get.
-     * @param expressID The expressID of the item whose children to get.
-     * @param found An optional parameter that includes a set of expressIDs where the found element IDs will be added.
+     * @returns A new THREE.Sphere instance representing the calculated sphere.
      *
-     * @returns A 'Set' with the expressIDs of the found items.
-     */
-    getEntityChildren(model: FragmentsGroup, expressID: number, found?: Set<number>): Set<number>;
-}
-import { Component, Disposable, Event } from "../Types";
-/**
- * The entry point of the Components library. It can create, delete and access all the components of the library globally, update all the updatable components automatically and dispose all the components, preventing memory leaks.
- */
-export declare class Components implements Disposable {
-    /**
-     * The version of the @thatopen/components library.
-     */
-    static readonly release = "2.1.9";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<void>;
-    /**
-     * The list of components created in this app.
-     * The keys are UUIDs and the values are instances of the components.
-     */
-    readonly list: Map<string, Component>;
-    /**
-     * If disabled, the animation loop will be stopped.
-     * Default value is false.
+     * @remarks
+     * This method calculates the center and radius of a sphere that encompasses the entire bounding box.
+     * The center is calculated as the midpoint between the minimum and maximum bounds of the bounding box.
+     * The radius is calculated as the distance from the center to the minimum bound.
+     *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.add(fragmentsGroup);
+     * const boundingSphere = boundingBoxer.getSphere();
+     * console.log(boundingSphere); // Output: Sphere { center: Vector3 { x: 0, y: 0, z: 0 }, radius: 10 }
+     * '''
      */
-    enabled: boolean;
-    private _clock;
+    getSphere(): THREE.Sphere;
     /**
-     * Adds a component to the list of components.
-     * Throws an error if a component with the same UUID already exists.
+     * Returns a THREE.Mesh instance representing the bounding box.
      *
-     * @param uuid - The unique identifier of the component.
-     * @param instance - The instance of the component to be added.
+     * @returns A new THREE.Mesh instance representing the bounding box.
      *
-     * @throws Will throw an error if a component with the same UUID already exists.
+     * @remarks
+     * This method calculates the dimensions of the bounding box using the 'getDimensions' method.
+     * It then creates a new THREE.BoxGeometry with the calculated dimensions.
+     * A new THREE.Mesh is created using the box geometry, and it is added to the '_meshes' array.
+     * The position of the mesh is set to the center of the bounding box.
      *
-     * @internal
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.add(fragmentsGroup);
+     * const boundingBoxMesh = boundingBoxer.getMesh();
+     * scene.add(boundingBoxMesh);
+     * '''
      */
-    add(uuid: string, instance: Component): void;
+    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
     /**
-     * Retrieves a component instance by its constructor function.
-     * If the component does not exist in the list, it will be created and added.
+     * Resets the internal minimum and maximum vectors to positive and negative infinity, respectively.
+     * This method is used to prepare the BoundingBoxer for a new set of fragments.
      *
-     * @template U - The type of the component to retrieve.
-     * @param Component - The constructor function of the component to retrieve.
+     * @remarks
+     * This method is called when a new set of fragments is added to the BoundingBoxer.
+     * It ensures that the bounding box calculations are accurate and up-to-date.
      *
-     * @returns The instance of the requested component.
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.add(fragmentsGroup);
+     * // ...
+     * boundingBoxer.reset();
+     * '''
+     */
+    reset(): void;
+    /**
+     * Adds a FragmentsGroup to the BoundingBoxer.
      *
-     * @throws Will throw an error if a component with the same UUID already exists.
+     * @param group - The FragmentsGroup to add.
      *
-     * @internal
+     * @remarks
+     * This method iterates through each fragment in the provided FragmentsGroup,
+     * and calls the 'addMesh' method for each fragment's mesh.
+     *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.add(fragmentsGroup);
+     * '''
      */
-    get<U extends Component>(Component: new (components: Components) => U): U;
-    constructor();
+    add(group: FragmentsGroup): void;
     /**
-     * Initializes the Components instance.
-     * This method starts the animation loop, sets the enabled flag to true,
-     * and calls the update method.
+     * Adds a mesh to the BoundingBoxer and calculates the bounding box.
      *
-     * @returns {void}
+     * @param mesh - The mesh to add. It can be an instance of THREE.InstancedMesh, THREE.Mesh, or FRAGS.CurveMesh.
+     * @param itemIDs - An optional iterable of numbers representing the item IDs.
+     *
+     * @remarks
+     * This method calculates the bounding box of the provided mesh and updates the internal minimum and maximum vectors.
+     * If the mesh is an instance of THREE.InstancedMesh, it calculates the bounding box for each instance.
+     * If the mesh is an instance of FRAGS.FragmentMesh and itemIDs are provided, it calculates the bounding box for the specified item IDs.
+     *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * boundingBoxer.addMesh(mesh);
+     * '''
      */
-    init(): void;
+    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
     /**
-     * Disposes the memory of all the components and tools of this instance of
-     * the library. A memory leak will be created if:
+     * Uses a FragmentIdMap to add its meshes to the bb calculation.
      *
-     * - An instance of the library ends up out of scope and this function isn't
-     * called. This is especially relevant in Single Page Applications (React,
-     * Angular, Vue, etc).
+     * This method iterates through the provided 'fragmentIdMap', retrieves the corresponding fragment from the 'FragmentsManager',
+     * and then calls the 'addMesh' method for each fragment's mesh, passing the expression IDs as the second parameter.
      *
-     * - Any of the objects of this instance (meshes, geometries,materials, etc) is
-     * referenced by a reference type (object or array).
+     * @param fragmentIdMap - A mapping of fragment IDs to their corresponding expression IDs.
      *
-     * You can learn more about how Three.js handles memory leaks
-     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+     * @remarks
+     * This method is used to add a mapping of fragment IDs to their corresponding expression IDs.
+     * It ensures that the bounding box calculations are accurate and up-to-date by updating the internal minimum and maximum vectors.
      *
+     * @example
+     * '''typescript
+     * const boundingBoxer = components.get(BoundingBoxer);
+     * const fragmentIdMap: FRAGS.FragmentIdMap = {
+     *   '5991fa75-2eef-4825-90b3-85177f51a9c9': [123, 245, 389],
+     *   '3469077e-39bf-4fc9-b3e6-4a1d78ad52b0': [454, 587, 612],
+     * };
+     * boundingBoxer.addFragmentIdMap(fragmentIdMap);
+     * '''
      */
-    dispose(): void;
-    private update;
-    private static setupBVH;
+    addFragmentIdMap(fragmentIdMap: FRAGS.FragmentIdMap): void;
+    private static getFragmentBounds;
 }
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
+}
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
 /**
- * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ * A component that hides or isolates fragments within a 3D scene. It extends the base Component class and provides methods to control fragment visibility and isolation. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Hider). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Hider).
  */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
+export declare class Hider extends Component {
     /**
      * A unique identifier for the component.
      * This UUID is used to register the component within the Components system.
      */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    /** {@link Component.enabled} */
+    enabled: boolean;
     constructor(components: Components);
     /**
-     * Return the UUIDs of all disposed 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}
      */
-    get(): Set<string>;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
     /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
+     * 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 materials - whether to dispose the materials of the mesh.
+     * @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 recursive - whether to recursively dispose the children of the mesh.
+     * @returns {void}
      */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
+}
+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 { 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 {
     /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
+     * A system within the classification.
+     * The key is the system name, and the value is an object representing the classes within the system.
      */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
+    [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;
+        };
+    };
 }
-import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
-import { Components } from "../Components";
-import { SimpleWorld } from "./src";
 /**
- * A class representing a collection of worlds within a game engine. It manages the creation, deletion, and update of worlds. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Worlds). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Worlds).
+ * 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 Worlds extends Component implements Updateable, Disposable {
+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: "fdb61dc4-2ec1-4966-b83d-54ea795fad4a";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * An event that is triggered when a new world is created.
-     * The event passes the newly created world as a parameter.
-     */
-    readonly onWorldCreated: Event<World>;
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * An event that is triggered when a world is deleted.
-     * The event passes the UUID of the deleted world as a parameter.
+     * A map representing the classification systems.
+     * The key is the system name, and the value is an object representing the classes within the system.
      */
-    readonly onWorldDeleted: Event<string>;
+    list: Classification;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * A collection of worlds managed by this component.
-     * The key is the unique identifier (UUID) of the world, and the value is the World instance.
+     * Removes a fragment from the classification based on its unique identifier (guid).
+     * This method iterates through all classification systems and classes, and deletes the fragment with the specified guid from the respective group.
+     *
+     * @param guid - The unique identifier of the fragment to be removed.
      */
-    list: Map<string, World>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    remove(guid: string): void;
     /**
-     * Creates a new instance of a SimpleWorld and adds it to the list of worlds.
+     * Finds and returns fragments based on the provided filter criteria.
+     * If no filter is provided, it returns all fragments.
      *
-     * @template T - The type of the scene, extending from BaseScene. Defaults to BaseScene.
-     * @template U - The type of the camera, extending from BaseCamera. Defaults to BaseCamera.
-     * @template S - The type of the renderer, extending from BaseRenderer. Defaults to BaseRenderer.
+     * @param filter - An optional object containing filter criteria.
+     * The keys of the object represent the classification system names,
+     * and the values are arrays of class names to match.
      *
-     * @throws {Error} - Throws an error if a world with the same UUID already exists in the list.
+     * @returns A map of fragment GUIDs to their respective express IDs,
+     * where the express IDs are filtered based on the provided filter criteria.
+     *
+     * @throws Will throw an error if the fragments map is malformed.
      */
-    create<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer>(): SimpleWorld<T, U, S>;
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
     /**
-     * Deletes a world from the list of worlds.
+     * Classifies fragments based on their modelID.
      *
-     * @param {World} world - The world to be deleted.
+     * @param modelID - The unique identifier of the model to classify fragments by.
+     * @param group - The FragmentsGroup containing the fragments to be classified.
      *
-     * @throws {Error} - Throws an error if the provided world is not found in the list.
+     * @remarks
+     * This method iterates through the fragments in the provided group,
+     * and classifies them based on their modelID.
+     * The classification is stored in the 'list.models' property,
+     * with the modelID as the key and a map of fragment IDs to their respective express IDs as the value.
      *
-     * @returns {void}
      */
-    delete(world: World): void;
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
     /**
-     * Disposes of the Worlds component and all its managed worlds.
-     * This method sets the enabled flag to false, disposes of all worlds, clears the list,
-     * and triggers the onDisposed event.
+     * Classifies fragments based on their PredefinedType property.
      *
-     * @returns {void}
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the properties of the fragments in the provided group,
+     * and classifies them based on their PredefinedType property.
+     * The classification is stored in the 'list.predefinedTypes' property,
+     * with the PredefinedType as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found.
      */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(delta?: number): void | Promise<void>;
-}
-import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
-import { Components } from "../Components";
-/**
- * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
- */
-export declare class Grids extends Component implements Disposable {
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Classifies fragments based on their entity type.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their entity type.
+     * The classification is stored in the 'list.entities' property,
+     * with the entity type as the key and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found.
      */
-    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    byEntity(group: FRAGS.FragmentsGroup): void;
     /**
-     * A map of world UUIDs to their corresponding grid instances.
+     * Classifies fragments based on a specific IFC relationship.
+     *
+     * @param group - The FragmentsGroup containing the fragments to be classified.
+     * @param ifcRel - The IFC relationship number to classify fragments by.
+     * @param systemName - The name of the classification system to store the classification.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on the specified IFC relationship.
+     * The classification is stored in the 'list' property under the specified system name,
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found or if the IFC relationship is not valid.
      */
-    list: Map<string, SimpleGrid>;
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
     /**
-     * The default configuration for grid creation.
+     * Classifies fragments based on their spatial structure in the IFC model.
+     *
+     * @param model - The FragmentsGroup containing the fragments to be classified.
+     * @param config - The configuration for the classifier. It includes "useProperties", which is true by default
+     * (if false, the classification will use the expressIDs instead of the names), and "isolate", which will make
+     * the classifier just pick the WEBIFC categories provided.
+     *
+     * @remarks
+     * This method iterates through the relations of the fragments in the provided group,
+     * and classifies them based on their spatial structure in the IFC model.
+     * The classification is stored in the 'list' property under the system name "spatialStructures",
+     * with the relationship name as the class name and a map of fragment IDs to their respective express IDs as the value.
+     *
+     * @throws Will throw an error if the fragment ID is not found or if the model relations do not exist.
      */
-    config: Required<GridConfig>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
+    bySpatialStructure(model: FRAGS.FragmentsGroup, config?: {
+        useProperties?: boolean;
+        isolate?: Set<number>;
+    }): Promise<void>;
     /**
-     * Creates a new grid for the given world.
-     * Throws an error if a grid already exists for the world.
+     * Sets the color of the specified fragments.
      *
-     * @param world - The world to create the grid for.
-     * @returns The newly created grid.
+     * @param items - A map of fragment IDs to their respective express IDs.
+     * @param color - The color to set for the fragments.
+     * @param override - A boolean indicating whether to override the existing color of the fragments.
      *
-     * @throws Will throw an error if a grid already exists for the given world.
+     * @remarks
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and sets their color using the 'setColor' method of the FragmentsGroup class.
+     *
+     * @throws Will throw an error if the fragment with the specified ID is not found.
      */
-    create(world: World): SimpleGrid;
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
     /**
-     * Deletes the grid associated with the given world.
-     * If a grid does not exist for the given world, this method does nothing.
+     * Resets the color of the specified fragments to their original color.
      *
-     * @param world - The world for which to delete the grid.
+     * @param items - A map of fragment IDs to their respective express IDs.
      *
      * @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.
+     * This method iterates through the provided fragment IDs, retrieves the corresponding fragments,
+     * and resets their color using the 'resetColor' method of the FragmentsGroup class.
+     *
+     * @throws Will throw an error if the fragment with the specified ID is not found.
      */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    resetColor(items: FRAGS.FragmentIdMap): void;
+    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number, parentID?: number | null): void;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
-import { Components } from "../Components";
+import { Component, Disposable, Event, Components } from "../../core";
 /**
- * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
+ * 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 Raycasters 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: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /** {@link Component.enabled} */
     enabled: boolean;
     /**
-     * A Map that stores raycasters for each world.
-     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
+     * The height of the explosion animation.
+     * This property determines the vertical distance by which fragments are moved during the explosion.
+     * Default value is 10.
      */
-    list: Map<string, SimpleRaycaster>;
-    /** {@link Disposable.onDisposed} */
-    onDisposed: Event<unknown>;
-    constructor(components: Components);
+    height: number;
     /**
-     * Retrieves a SimpleRaycaster instance for the given world.
-     * If a SimpleRaycaster instance already exists for the world, it will be returned.
-     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
-     *
-     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
-     * @returns The SimpleRaycaster instance for the given world.
+     * 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".
      */
-    get(world: World): SimpleRaycaster;
+    groupName: string;
     /**
-     * Deletes the SimpleRaycaster instance associated with the given world.
-     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
-     *
-     * @param world - The world for which to delete the SimpleRaycaster instance.
-     * @returns {void}
+     * A set of strings representing the exploded items.
+     * This set is used to keep track of which items have been exploded.
      */
-    delete(world: World): void;
+    list: Set<string>;
+    constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /**
+     * Sets the explosion state of the fragments.
+     *
+     * @param active - A boolean indicating whether to activate or deactivate the explosion.
+     *
+     * @remarks
+     * This method applies a vertical transformation to the fragments based on the 'active' parameter.
+     * If 'active' is true, the fragments are moved upwards by a distance determined by the 'height' property.
+     * If 'active' is false, the fragments are moved back to their original position.
+     *
+     * The method also keeps track of the exploded items using the 'list' set.
+     *
+     * @throws Will throw an error if the 'Classifier' or 'FragmentsManager' components are not found in the 'components' system.
+     */
+    set(active: boolean): void;
 }
-import * as THREE from "three";
-import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
-import { SimplePlane } from "./src";
-import { Components } from "../Components";
+import * as WEBIFC from "web-ifc";
+import { Components, Disposable, Event, Component } from "../../core";
+import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
 /**
- * A lightweight component to easily create, delete and handle [clipping planes](https://threejs.org/docs/#api/en/materials/Material.clippingPlanes). 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Clipper). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Clipper).
- *
- * @param components - the instance of {@link Components} used.
- * E.g. {@link SimplePlane}.
+ * A 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 Clipper extends Component implements Createable, Disposable, Hideable {
+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: "66290bc5-18c4-4cd1-9379-2e17a0617611";
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onBeforeDrag: Event<void>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onAfterDrag: Event<void>;
+    static readonly uuid: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
     /**
-     * Event that fires when the user starts creating a clipping plane.
+     * Event triggered when geometry is streamed.
+     * Contains the streamed geometry data and its buffer.
      */
-    readonly onBeforeCreate: Event<unknown>;
+    readonly onGeometryStreamed: Event<{
+        buffer: Uint8Array;
+        data: StreamedGeometries;
+    }>;
     /**
-     * Event that fires when the user cancels the creation of a clipping plane.
+     * Event triggered when assets are streamed.
+     * Contains the streamed assets.
      */
-    readonly onBeforeCancel: Event<unknown>;
+    readonly onAssetStreamed: Event<StreamedAsset[]>;
     /**
-     * Event that fires after the user cancels the creation of a clipping plane.
+     * Event triggered to indicate the progress of the streaming process.
+     * Contains the progress percentage.
      */
-    readonly onAfterCancel: Event<unknown>;
+    readonly onProgress: Event<number>;
     /**
-     * Event that fires when the user starts deleting a clipping plane.
+     * Event triggered when the IFC file is loaded.
+     * Contains the loaded IFC file data.
      */
-    readonly onBeforeDelete: Event<unknown>;
+    readonly onIfcLoaded: Event<Uint8Array>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
     /**
-     * Event that fires after a clipping plane has been created.
-     * @param plane - The newly created clipping plane.
+     * Settings for the IfcGeometryTiler.
      */
-    readonly onAfterCreate: Event<SimplePlane>;
+    settings: IfcStreamingSettings;
+    /** {@link Component.enabled} */
+    enabled: boolean;
     /**
-     * Event that fires after a clipping plane has been deleted.
-     * @param plane - The deleted clipping plane.
+     * The WebIFC API instance used for IFC file processing.
      */
-    readonly onAfterDelete: Event<SimplePlane>;
+    webIfc: WEBIFC.IfcAPI;
+    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(): void;
+    /**
+     * 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 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.
+     *
+     * @remarks
+     * This method cleans up any resources after the streaming process is complete.
+     *
+     */
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllGeometries;
+    private cleanUp;
+    private getMesh;
+    private getGeometry;
+    private streamAssets;
+    private streamGeometries;
+}
+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>;
     /**
-     * Whether to force the clipping plane to be orthogonal in the Y direction
-     * (up). This is desirable when clipping a building horizontally and a
-     * clipping plane is created in its roof, which might have a slight
-     * slope for draining purposes.
+     * An event triggered when the IFC file starts loading.
      */
-    orthogonalY: boolean;
+    readonly onIfcStartedLoading: Event<void>;
     /**
-     * The tolerance that determines whether an almost-horizontal clipping plane
-     * will be forced to be orthogonal to the Y direction. {@link orthogonalY}
-     * has to be 'true' for this to apply.
+     * An event triggered when the setup process is completed.
      */
-    toleranceOrthogonalY: number;
+    readonly onSetup: Event<void>;
     /**
-     * The type of clipping plane to be created.
-     * Default is {@link SimplePlane}.
+     * The settings for the IfcLoader.
+     * It includes options for excluding categories, setting WASM paths, and more.
      */
-    Type: new (...args: any) => SimplePlane;
+    settings: IfcFragmentSettings;
     /**
-     * A list of all the clipping planes created by this component.
+     * The instance of the Web-IFC library used for handling IFC data.
      */
-    list: SimplePlane[];
-    /** The material used in all the clipping planes. */
-    private _material;
-    private _size;
-    private _enabled;
-    private _visible;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
+    webIfc: WEBIFC.IfcAPI;
     /** {@link Component.enabled} */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The material of the clipping plane representation. */
-    get material(): THREE.MeshBasicMaterial;
-    /** The material of the clipping plane representation. */
-    set material(material: THREE.MeshBasicMaterial);
-    /** The size of the geometric representation of the clippings planes. */
-    get size(): number;
-    /** The size of the geometric representation of the clippings planes. */
-    set size(size: number);
+    enabled: boolean;
+    private _material;
+    private _spatialTree;
+    private _metaData;
+    private _fragmentInstances;
+    private _civil;
+    private _visitedFragments;
+    private _materialT;
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
-    /** {@link Createable.create} */
-    create(world: World): SimplePlane | null;
     /**
-     * Creates a plane in a certain place and with a certain orientation,
-     * without the need of the mouse.
+     * Sets up the IfcLoader component with the provided configuration.
      *
-     * @param world - the world where this plane should be created.
-     * @param normal - the orientation of the clipping plane.
-     * @param point - the position of the clipping plane.
-     * navigation.
+     * @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.
+     *
+     * @returns A Promise that resolves to the FragmentsGroup containing the loaded and processed IFC data.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * const group = await ifcLoader.load(ifcData);
+     * '''
+     */
+    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    /**
+     * Reads an IFC file and initializes the Web-IFC library.
+     *
+     * @param data - The Uint8Array containing the IFC file data.
+     *
+     * @returns A Promise that resolves when the IFC file is opened and initialized.
+     *
+     * @remarks
+     * This method sets the WASM path and initializes the Web-IFC library based on the provided settings.
+     * It also opens the IFC model using the provided data and settings.
+     *
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * await ifcLoader.readIfcFile(ifcData);
+     * '''
      */
-    createFromNormalAndCoplanarPoint(world: World, normal: THREE.Vector3, point: THREE.Vector3): SimplePlane;
+    readIfcFile(data: Uint8Array): Promise<number>;
     /**
-     * {@link Createable.delete}
+     * Cleans up the IfcLoader component by resetting the Web-IFC library,
+     * clearing the visited fragments and fragment instances maps, and creating a new instance of the Web-IFC library.
      *
-     * @param world - the world where the plane to delete is.
-     * @param plane - the plane to delete. If undefined, the first plane
-     * found under the cursor will be deleted.
-     */
-    delete(world: World, plane?: SimplePlane): void;
-    /**
-     * Deletes all the existing clipping planes.
+     * @remarks
+     * This method is called automatically after using the .load() method, so usually you don't need to use it manually.
      *
-     * @param types - the types of planes to be deleted. If not provided, all planes will be deleted.
+     * @example
+     * '''typescript
+     * const ifcLoader = components.get(IfcLoader);
+     * ifcLoader.cleanUp();
+     * '''
      */
-    deleteAll(types?: Set<string>): void;
-    private deletePlane;
-    private pickPlane;
-    private getAllPlaneMeshes;
-    private createPlaneFromIntersection;
-    private getWorldNormal;
-    private normalizePlaneDirectionY;
-    private newPlane;
-    private updateMaterialsAndPlanes;
-    private _onStartDragging;
-    private _onEndDragging;
+    cleanUp(): void;
+    private getAllGeometries;
+    private getMesh;
+    private getGeometry;
+    private autoSetWasm;
 }
-import { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
-import { Components } from "../Components";
+import { Fragment, FragmentsGroup } from "@thatopen/fragments";
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components, Event, Disposable } from "../../core";
+import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
 /**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
+ * Component to load, delete and manage [fragments](https://github.com/ThatOpen/engine_fragment) efficiently. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/FragmentsManager). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/FragmentsManager).
  */
-export declare class MiniMaps extends Component implements Updateable, Disposable {
+export declare class FragmentsManager 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: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
+    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
     /** {@link Disposable.onDisposed} */
     readonly onDisposed: Event<unknown>;
+    /**
+     * Event triggered when fragments are loaded.
+     */
+    readonly onFragmentsLoaded: Event<FragmentsGroup>;
+    /**
+     * Event triggered when fragments are disposed.
+     */
+    readonly onFragmentsDisposed: Event<{
+        groupID: string;
+        fragmentIDs: string[];
+    }>;
+    /**
+     * Map containing all loaded fragments.
+     * The key is the fragment's unique identifier, and the value is the fragment itself.
+     */
+    readonly list: Map<string, Fragment>;
+    /**
+     * Map containing all loaded fragment groups.
+     * The key is the group's unique identifier, and the value is the group itself.
+     */
+    readonly groups: Map<string, FragmentsGroup>;
+    baseCoordinationModel: string;
+    baseCoordinationMatrix: THREE.Matrix4;
     /** {@link Component.enabled} */
     enabled: boolean;
+    private _loader;
     /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
+     * Getter for the meshes of all fragments in the FragmentsManager.
+     * It iterates over the fragments in the list and pushes their meshes into an array.
+     * @returns {THREE.Mesh[]} An array of THREE.Mesh objects representing the fragments.
      */
-    list: Map<string, MiniMap>;
+    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
     constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Creates a new {@link MiniMap} instance associated with the given world.
-     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
+     * Dispose of a specific fragment group.
+     * This method removes the group from the groups map, deletes all fragments within the group from the list,
+     * disposes of the group, and triggers the onFragmentsDisposed event.
      *
-     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
-     * @returns The newly created {@link MiniMap} instance.
-     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
+     * @param group - The fragment group to be disposed.
      */
-    create(world: World): MiniMap;
+    disposeGroup(group: FragmentsGroup): void;
     /**
-     * Deletes a {@link MiniMap} instance associated with the given world ID.
-     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
-     *
-     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
-     * @returns {void}
+     * Loads a binary file that contain fragment geometry.
+     * @param data - The binary data to load.
+     * @param config - Optional configuration for loading.
+     * @param config.coordinate - Whether to apply coordinate transformation. Default is true.
+     * @param config.properties - Ifc properties to set on the loaded fragments. Not to be used when streaming.
+     * @returns The loaded FragmentsGroup.
      */
-    delete(id: string): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
-}
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-import { Components } from "../Components";
-import { MeshCullerRenderer, CullerRendererSettings } from "./src";
-import { Component, Event, Disposable, World } from "../Types";
-/**
- * A component that provides culling functionality for meshes in a 3D scene. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Cullers). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Cullers).
- */
-export declare class Cullers extends Component implements Disposable {
+    load(data: Uint8Array, config?: Partial<{
+        coordinate: boolean;
+        name: string;
+        properties: FRAGS.IfcProperties;
+        relationsMap: RelationsMap;
+    }>): FragmentsGroup;
     /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
+     * Export the specified fragmentsgroup to binary data.
+     * @param group - the fragments group to be exported.
+     * @returns the exported data as binary buffer.
      */
-    static readonly uuid: "69f2a50d-c266-44fc-b1bd-fa4d34be89e6";
+    export(group: FragmentsGroup): Uint8Array;
     /**
-     * An event that is triggered when the Cullers component is disposed.
+     * Gets a map of model IDs to sets of express IDs for the given fragment ID map.
+     * @param fragmentIdMap - A map of fragment IDs to their corresponding express IDs.
+     * @returns A map of model IDs to sets of express IDs.
      */
-    readonly onDisposed: Event<unknown>;
-    private _enabled;
+    getModelIdMap(fragmentIdMap: FRAGS.FragmentIdMap): {
+        [modelID: string]: Set<number>;
+    };
     /**
-     * A map of MeshCullerRenderer instances, keyed by their world UUIDs.
+     * Converts a map of model IDs to sets of express IDs to a fragment ID map.
+     * @param modelIdMap - A map of model IDs to their corresponding express IDs.
+     * @returns A fragment ID map.
+     * @remarks
+     * This method iterates through the provided model ID map, retrieves the corresponding model from the 'groups' map,
+     * and then calls the 'getFragmentMap' method of the model to obtain a fragment ID map for the given express IDs.
+     * The fragment ID maps are then merged into a single map and returned.
+     * If a model with a given ID is not found in the 'groups' map, the method skips that model and continues with the next one.
      */
-    list: Map<string, MeshCullerRenderer>;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(value: boolean);
-    constructor(components: Components);
+    modelIdToFragmentIdMap(modelIdMap: {
+        [modelID: string]: Set<number>;
+    }): FRAGS.FragmentIdMap;
     /**
-     * Creates a new MeshCullerRenderer for the given world.
-     * If a MeshCullerRenderer already exists for the world, it will return the existing one.
-     *
-     * @param world - The world for which to create the MeshCullerRenderer.
-     * @param config - Optional configuration settings for the MeshCullerRenderer.
+     * Applies coordinate transformation to the provided models.
+     * If no models are provided, all groups are used.
+     * The first model in the list becomes the base model for coordinate transformation.
+     * All other models are then transformed to match the base model's coordinate system.
      *
-     * @returns The newly created or existing MeshCullerRenderer for the given world.
+     * @param models - The models to apply coordinate transformation to.
+     * If not provided, all models are used.
      */
-    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
+    coordinate(models?: FragmentsGroup[]): void;
     /**
-     * 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.
+     * Applies the base coordinate system to the provided object.
      *
-     * @param world - The world for which to delete the MeshCullerRenderer.
+     * This function takes an object and its original coordinate system as input.
+     * It then inverts the original coordinate system and applies the base coordinate system
+     * to the object. This ensures that the object's position, rotation, and scale are
+     * transformed to match the base coordinate system (which is taken from the first model loaded).
      *
-     * @returns {void}
+     * @param object - The object to which the base coordinate system will be applied.
+     * This should be an instance of THREE.Object3D.
+     *
+     * @param originalCoordinateSystem - The original coordinate system of the object.
+     * This should be a THREE.Matrix4 representing the object's transformation matrix.
      */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    applyBaseCoordinateSystem(object: THREE.Object3D | THREE.Vector3, originalCoordinateSystem: THREE.Matrix4): void;
 }
-import * as THREE from "three";
-import { Components } from "../Components";
-import { SimpleCamera } from "..";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+import * as WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "./src";
 /**
- * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
+ * 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 OrthoPerspectiveCamera extends SimpleCamera {
+export declare class IfcPropertiesTiler extends Component implements Disposable {
     /**
-     * A ProjectionManager instance that manages the projection modes of the camera.
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
      */
-    readonly projection: ProjectionManager;
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
     /**
-     * A THREE.OrthographicCamera instance that represents the orthographic camera.
-     * This camera is used when the projection mode is set to orthographic.
+     * 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 threeOrtho: THREE.OrthographicCamera;
+    readonly onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
+    }>;
     /**
-     * A THREE.PerspectiveCamera instance that represents the perspective camera.
-     * This camera is used when the projection mode is set to perspective.
+     * 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 threePersp: THREE.PerspectiveCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    protected _mode: NavigationMode | null;
-    private previousSize;
+    readonly onProgress: AsyncEvent<number>;
     /**
-     * Getter for the current navigation mode.
-     * Throws an error if the mode is not found or the camera is not initialized.
-     *
-     * @returns {NavigationMode} The current navigation mode.
-     *
-     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
+     * 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.
      */
-    get mode(): NavigationMode;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    readonly onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    /**
+     * An instance of the PropertiesStreamingSettings class, which holds the settings for the streaming process.
+     */
+    settings: PropertiesStreamingSettings;
     /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
-     *
-     * @param mode - The {@link NavigationMode} to set.
+     * An instance of the IfcAPI class from the Web-IFC library, which provides methods for reading and processing IFC data.
      */
-    set(mode: NavModeID): void;
+    webIfc: WEBIFC.IfcAPI;
+    /** {@link Disposable.dispose} */
+    dispose(): Promise<void>;
     /**
-     * Make the camera view fit all the specified meshes.
+     * This method converts properties from an IFC file to tiles given its data as a Uint8Array.
      *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
+     * @param data - The Uint8Array containing the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
      */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    streamFromBuffer(data: Uint8Array): Promise<void>;
     /**
-     * Allows or prevents all user input.
+     * This method converts properties from an IFC file to tiles using a given callback function to read the file.
      *
-     * @param active - whether to enable or disable user inputs.
+     * @param loadCallback - A callback function that loads the IFC file data.
+     * @returns A Promise that resolves when the streaming process is complete.
      */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private cleanUp;
 }
 import * as THREE from "three";
 import { Component, Components, Disposable, Event, World } from "../core";
@@ -2089,41 +1984,253 @@ export declare class VertexPicker extends Component implements Disposable {
      * };
      * '''
      */
-    set config(value: Partial<VertexPickerConfig>);
+    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;
+}
+/**
+ * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
+ *
+ * @remarks
+ * This map is used to provide a mapping between IFC entity type numbers and their names.
+ * It is useful for identifying and processing different types of IFC elements in a project.
+ *
+ */
+export declare const IfcElements: {
+    [key: number]: string;
+};
+import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Represents an edge measurement result.
+ */
+export interface MeasureEdge {
+    /**
+     * The distance between the two points of the edge.
+     */
+    distance: number;
+    /**
+     * The two points that define the edge.
+     */
+    points: THREE.Vector3[];
+}
+/**
+ * Utility component for performing measurements on 3D meshes by providing methods for measuring distances between edges and faces. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MeasurementUtils). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MeasurementUtils).
+ */
+export declare class MeasurementUtils extends Component {
+    /**
+     * A unique identifier for the component.
+     * This UUID is used to register the component within the Components system.
+     */
+    static uuid: string;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Utility method to calculate the distance from a point to a line segment.
+     *
+     * @param point - The point from which to calculate the distance.
+     * @param lineStart - The start point of the line segment.
+     * @param lineEnd - The end point of the line segment.
+     * @param clamp - If true, the distance will be clamped to the line segment's length.
+     * @returns The distance from the point to the line segment.
+     */
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    /**
+     * Method to get the face of a mesh that contains a given triangle index.
+     * It also returns the edges of the found face and their indices.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param triangleIndex - The index of the triangle within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the edges of the found face and their indices, or null if no face was found.
+     */
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    /**
+     * Method to get the vertices and normal of a mesh face at a given index.
+     * It also applies instance transformation if provided.
+     *
+     * @param mesh - The mesh to get the face from. It must be indexed.
+     * @param faceIndex - The index of the face within the mesh.
+     * @param instance - The instance of the mesh (optional).
+     * @returns An object containing the vertices and normal of the face.
+     * @throws Will throw an error if the geometry is not indexed.
+     */
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    /**
+     * Method to round the vector's components to a specified number of decimal places.
+     * This is used to ensure numerical precision in edge detection.
+     *
+     * @param vector - The vector to round.
+     * @returns The vector with rounded components.
+     */
+    round(vector: THREE.Vector3): void;
+    /**
+     * Calculates the volume of a set of fragments.
+     *
+     * @param frags - A map of fragment IDs to their corresponding item IDs.
+     * @returns The total volume of the fragments and the bounding sphere.
+     *
+     * @remarks
+     * This method creates a set of instanced meshes from the given fragments and item IDs.
+     * It then calculates the volume of each mesh and returns the total volume and its bounding sphere.
+     *
+     * @throws Will throw an error if the geometry of the meshes is not indexed.
+     * @throws Will throw an error if the fragment manager is not available.
+     */
+    getVolumeFromFragments(frags: FRAGS.FragmentIdMap): number;
+    /**
+     * Calculates the total volume of a set of meshes.
+     *
+     * @param meshes - An array of meshes or instanced meshes to calculate the volume from.
+     * @returns The total volume of the meshes and the bounding sphere.
+     *
+     * @remarks
+     * This method calculates the volume of each mesh in the provided array and returns the total volume
+     * and its bounding sphere.
+     *
+     */
+    getVolumeFromMeshes(meshes: THREE.InstancedMesh[] | THREE.Mesh[]): number;
+    private getFaceData;
+    private getVolumeOfMesh;
+    private getSignedVolumeOfTriangle;
+}
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
+}
+import * as THREE from "three";
+import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
+/**
+ * A class representing a 2D minimap of a 3D world.
+ */
+export declare class MiniMap implements Resizeable, Updateable, Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<unknown>;
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<unknown>;
+    /** {@link Resizeable.onResize} */
+    readonly onResize: Event<THREE.Vector2>;
+    /**
+     * The front offset of the minimap.
+     * It determines how much the minimap's view is offset from the camera's view.
+     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
+     */
+    frontOffset: number;
+    /**
+     * The override material for the minimap.
+     * It is used to render the depth information of the world onto the minimap.
+     */
+    overrideMaterial: THREE.MeshDepthMaterial;
+    /**
+     * The background color of the minimap.
+     * It is used to set the background color of the minimap's renderer.
+     */
+    backgroundColor: THREE.Color;
+    /**
+     * The WebGL renderer for the minimap.
+     * It is used to render the minimap onto the screen.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * A flag indicating whether the minimap is enabled.
+     * If disabled, the minimap will not update or render.
+     */
+    enabled: boolean;
+    /**
+     * The world in which the minimap is displayed.
+     * It provides access to the 3D scene, camera, and other relevant world elements.
+     */
+    world: World;
+    private _lockRotation;
+    private _camera;
+    private _plane;
+    private _size;
+    private _tempVector1;
+    private _tempVector2;
+    private _tempTarget;
+    private readonly down;
+    /**
+     * Gets or sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     */
+    get lockRotation(): boolean;
+    /**
+     * Sets whether the minimap rotation is locked.
+     * When rotation is locked, the minimap will always face the same direction as the camera.
+     * @param active - If 'true', rotation is locked. If 'false', rotation is not locked.
+     */
+    set lockRotation(active: boolean);
     /**
-     * Gets the current 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
-     * '''
+     * Gets the current zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @returns The current zoom level of the minimap.
      */
-    get config(): Partial<VertexPickerConfig>;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    get zoom(): number;
     /**
-     * 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'.
+     * Sets the zoom level of the minimap.
+     * The zoom level determines how much of the world is visible on the minimap.
+     * @param value - The new zoom level of the minimap.
      */
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
+    set zoom(value: number);
+    constructor(world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /** Returns the camera used by the MiniMap */
+    get(): THREE.OrthographicCamera;
+    /** {@link Updateable.update} */
+    update(): void;
+    /** {@link Resizeable.getSize} */
+    getSize(): THREE.Vector2;
+    /** {@link Resizeable.resize} */
+    resize(size?: THREE.Vector2): void;
+    private updatePlanes;
 }
 import * as FRAGS from "@thatopen/fragments";
 export declare class IfcPropertiesUtils {
@@ -2150,30 +2257,21 @@ 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>>>;
 }
-/**
- * A map of IFC element types to their corresponding names. The keys are the IFC entity type numbers, and the values are the names of the IFC entities.
- *
- * @remarks
- * This map is used to provide a mapping between IFC entity type numbers and their names.
- * It is useful for identifying and processing different types of IFC elements in a project.
- *
- */
-export declare const IfcElements: {
-    [key: number]: string;
-};
 /**
  * A map that associates each unique integer identifier (IFC Entity ID) with its corresponding category name. This map is used to map IFC entities to their respective categories for easier identification and processing.
  */
 export declare const IfcCategoryMap: {
     [key: number]: string;
 };
-import * as WEBIFC from "web-ifc";
-export interface IfcItemsCategories {
-    [itemID: number]: number;
-}
-export declare class IfcCategories {
-    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
-}
+/**
+ * A Set of unique numbers representing different types of IFC geometries.
+ */
+export declare const GeometryTypes: Set<number>;
+import { InverseAttribute } from "./types";
+export declare const relToAttributesMap: Map<number, {
+    forRelating: InverseAttribute;
+    forRelated: InverseAttribute;
+}>;
 import * as WEBIFC from "web-ifc";
 /** Configuration of the IFC-fragment conversion. */
 export declare class IfcFragmentSettings {
@@ -2215,39 +2313,6 @@ export declare class IfcFragmentSettings {
      */
     customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
 }
-/**
- * A Set of unique numbers representing different types of IFC geometries.
- */
-export declare const GeometryTypes: Set<number>;
-import { InverseAttribute } from "./types";
-export declare const relToAttributesMap: Map<number, {
-    forRelating: InverseAttribute;
-    forRelated: InverseAttribute;
-}>;
-import * as WEBIFC from "web-ifc";
-import { IfcItemsCategories } from "../../../ifc";
-export declare class SpatialStructure {
-    itemsByFloor: IfcItemsCategories;
-    private _units;
-    setUp(webIfc: WEBIFC.IfcAPI): void;
-    cleanUp(): void;
-}
-import * as FRAGS from "@thatopen/fragments";
-import * as WEBIFC from "web-ifc";
-export declare class SpatialIdsFinder {
-    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
-}
-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;
-}
 /**
  * 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.
  */
@@ -2426,93 +2491,32 @@ export declare abstract class Component extends Base {
     abstract enabled: boolean;
 }
 import * as THREE from "three";
-import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
+import CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
 /**
- * A class representing a 2D minimap of a 3D world.
+ * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
  */
-export declare class MiniMap implements Resizeable, Updateable, Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    frontOffset: number;
-    /**
-     * The override material for the minimap.
-     * It is used to render the depth information of the world onto the minimap.
-     */
-    overrideMaterial: THREE.MeshDepthMaterial;
-    /**
-     * The background color of the minimap.
-     * It is used to set the background color of the minimap's renderer.
-     */
-    backgroundColor: THREE.Color;
-    /**
-     * The WebGL renderer for the minimap.
-     * It is used to render the minimap onto the screen.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * A flag indicating whether the minimap is enabled.
-     * If disabled, the minimap will not update or render.
-     */
-    enabled: boolean;
-    /**
-     * The world in which the minimap is displayed.
-     * It provides access to the 3D scene, camera, and other relevant world elements.
-     */
-    world: World;
-    private _lockRotation;
-    private _camera;
-    private _plane;
-    private _size;
-    private _tempVector1;
-    private _tempVector2;
-    private _tempTarget;
-    private readonly down;
+export declare abstract class BaseCamera extends BaseWorldItem {
     /**
-     * Gets or sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
+     * Whether the camera is enabled or not.
      */
-    get lockRotation(): boolean;
+    abstract enabled: boolean;
     /**
-     * Sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     * @param active - If 'true', rotation is locked. If 'false', rotation is not locked.
+     * The Three.js camera instance.
      */
-    set lockRotation(active: boolean);
+    abstract three: THREE.Camera;
     /**
-     * Gets the current zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @returns The current zoom level of the minimap.
+     * Optional CameraControls instance for controlling the camera.
+     * This property is only available if the camera is controllable.
      */
-    get zoom(): number;
+    abstract controls?: CameraControls;
     /**
-     * Sets the zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @param value - The new zoom level of the minimap.
+     * Checks whether the instance is {@link CameraControllable}.
+     *
+     * @returns True if the instance is controllable, false otherwise.
      */
-    set zoom(value: number);
-    constructor(world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** Returns the camera used by the MiniMap */
-    get(): THREE.OrthographicCamera;
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Resizeable.getSize} */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize(size?: THREE.Vector2): void;
-    private updatePlanes;
+    hasCameraControls: () => this is CameraControllable;
 }
 import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
@@ -2533,29 +2537,6 @@ export declare abstract class Base {
     /** Whether is component is {@link Configurable}. */
     isConfigurable: () => this is Configurable<any>;
 }
-import { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
-import { Components } from "../../Components";
-/**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
- */
-export declare abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
-    /**
-     * Event that is triggered when a world is added or removed from the 'worlds' map.
-     * The event payload contains the world instance and the action ("added" or "removed").
-     */
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
-    /**
-     * The current world this item is associated with. It can be null if no world is currently active.
-     */
-    currentWorld: World | null;
-    protected constructor(components: Components);
-}
 import * as THREE from "three";
 import { Vector2 } from "three";
 import { Event } from "./event";
@@ -2621,33 +2602,41 @@ export declare abstract class BaseRenderer extends BaseWorldItem implements Upda
      */
     setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
 }
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
+import { Base } from "./base";
+import { World } from "./world";
+import { Event } from "./event";
+import { Components } from "../../Components";
 /**
- * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
+ * One of the elements that make a world. It can be either a scene, a camera or a renderer.
  */
-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 abstract class BaseWorldItem extends Base {
+    readonly worlds: Map<string, World>;
     /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
+     * 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").
      */
-    abstract controls?: CameraControls;
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
     /**
-     * Checks whether the instance is {@link CameraControllable}.
-     *
-     * @returns True if the instance is controllable, false otherwise.
+     * The current world this item is associated with. It can be null if no world is currently active.
      */
-    hasCameraControls: () => this is CameraControllable;
+    currentWorld: World | null;
+    protected constructor(components: Components);
+}
+import * as FRAGS from "@thatopen/fragments";
+import * as WEBIFC from "web-ifc";
+export declare class SpatialIdsFinder {
+    static get(model: FRAGS.FragmentsGroup, webIfc: WEBIFC.IfcAPI): void;
+}
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
 }
 import * as THREE from "three";
 import { Disposable } from "./interfaces";
@@ -2704,29 +2693,6 @@ export interface World extends Disposable, Updateable {
     isDisposing: boolean;
 }
 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 { Hideable, Event, World, Disposable } from "../../Types";
 import { Components } from "../../Components";
 /**
@@ -2786,6 +2752,29 @@ export declare class SimpleGrid implements Hideable, Disposable {
     private updateZoom;
 }
 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 { Components } from "../../Components";
 import { Event, World, Disposable } from "../../Types";
 import { Mouse } from "./mouse";
@@ -2838,103 +2827,151 @@ export declare class SimpleRaycaster implements Disposable {
     private filterClippingPlanes;
 }
 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 * as THREE from "three";
-import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
+import { Components } from "../../Components";
+import { AsyncEvent, Event, World } 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.
+ * Settings to configure the CullerRenderer.
  */
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
+export interface CullerRendererSettings {
     /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
+     * Interval in milliseconds at which the visibility check should be performed.
+     * Default value is 1000.
      */
-    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>;
+    updateInterval?: number;
+    /**
+     * Width of the render target used for visibility checks.
+     * Default value is 512.
+     */
+    width?: number;
+    /**
+     * Height of the render target used for visibility checks.
+     * Default value is 512.
+     */
+    height?: number;
+    /**
+     * Whether the visibility check should be performed automatically.
+     * Default value is true.
+     */
+    autoUpdate?: boolean;
+}
+/**
+ * A base renderer to determine visibility on screen.
+ */
+export declare class CullerRenderer {
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
+    readonly onDisposed: Event<string>;
     /**
-     * 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.
+     * 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.
      */
-    isDisposing: boolean;
+    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
     /**
-     * Indicates whether the world is currently enabled.
-     * When disabled, the world will not be updated.
+     * Whether this renderer is active or not. If not, it won't render anything.
      */
     enabled: boolean;
     /**
-     * A unique identifier for the world.
+     * 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.
      */
-    uuid: string;
+    needsUpdate: boolean;
     /**
-     * An optional name for the world.
+     * Render the internal scene used to determine the object visibility. Used
+     * for debugging purposes.
      */
-    name?: string;
-    private _scene?;
-    private _camera?;
-    private _renderer;
+    renderDebugFrame: boolean;
+    /** The components instance to which this renderer belongs. */
+    components: Components;
+    /** The world instance to which this renderer belongs. */
+    readonly world: World;
+    /** The THREE.js renderer used to make the visibility test. */
+    readonly renderer: THREE.WebGLRenderer;
+    protected autoUpdate: boolean;
+    protected updateInterval: number;
+    protected readonly worker: Worker;
+    protected readonly scene: THREE.Scene;
+    private _width;
+    private _height;
+    private _availableColor;
+    private readonly renderTarget;
+    private readonly bufferSize;
+    private readonly _buffer;
+    protected _isWorkerBusy: boolean;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * Getter for the scene. If no scene is initialized, it throws an error.
-     * @returns The current scene.
+     * 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.
      */
-    get scene(): T;
+    updateVisibility: (force?: boolean) => Promise<void>;
+    protected getAvailableColor(): {
+        r: number;
+        g: number;
+        b: number;
+        code: string;
+    };
+    protected increaseColor(): void;
+    protected decreaseColor(): void;
+    private applySettings;
+}
+import * as THREE from "three";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import { Components } from "../../Components";
+import { Event, World, Disposable } from "../../Types";
+/**
+ * A renderer to hide/show meshes depending on their visibility from the user's point of view.
+ */
+export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
     /**
-     * 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.
+     * Event triggered when the visibility of meshes is updated.
+     * Contains two sets: seen and unseen.
      */
-    set scene(scene: T);
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
     /**
-     * Getter for the camera. If no camera is initialized, it throws an error.
-     * @returns The current camera.
+     * Pixels in screen a geometry must occupy to be considered "seen".
+     * Default value is 100.
      */
-    get camera(): U;
+    threshold: number;
     /**
-     * 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.
+     * Map of color code to THREE.InstancedMesh.
+     * Used to keep track of color-coded meshes.
      */
-    set camera(camera: U);
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
     /**
-     * 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).
+     * Flag to indicate if the renderer is currently processing.
+     * Used to prevent concurrent processing.
      */
-    get renderer(): S | null;
+    isProcessing: boolean;
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private _intervalID;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
     /**
-     * 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.
+     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
+     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
      */
-    set renderer(renderer: S | null);
-    /** {@link Updateable.update} */
-    update(delta?: number): void;
-    /** {@link Disposable.dispose} */
-    dispose(disposeResources?: boolean): void;
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    /**
+     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
+     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
+     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
+     * @returns {void}
+     */
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
 }
 import * as THREE from "three";
 import { BaseScene, Configurable, Event } from "../../Types";
@@ -3029,21 +3066,117 @@ export declare class SimpleRenderer extends BaseRenderer {
     private onContextLost;
     private onContextBack;
 }
-import { IfcFragmentSettings } from "../../IfcLoader/src";
+import * as THREE from "three";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer, Disposable, Updateable } from "../../Types";
 /**
- * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
+ * 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 IfcStreamingSettings extends IfcFragmentSettings {
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World, Disposable, Updateable {
     /**
-     * Minimum number of geometries to be streamed.
-     * Defaults to 10 geometries.
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh). These meshes will be taken into account in operations like raycasting.
      */
-    minGeometrySize: number;
+    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>;
     /**
-     * Minimum amount of assets to be streamed.
-     * Defaults to 1000 assets.
+     * 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.
      */
-    minAssetsSize: number;
+    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;
+}
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
+ */
+export declare class FirstPersonMode implements NavigationMode {
+    private camera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "FirstPerson";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
+}
+import { NavigationMode } from "./types";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: OrthoPerspectiveCamera;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: OrthoPerspectiveCamera);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
 }
 import * as THREE from "three";
 import CameraControls from "camera-controls";
@@ -3107,136 +3240,6 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
     private setupEvents;
     private static getSubsetOfThree;
 }
-/**
- * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
- */
-export interface StreamedGeometries {
-    [id: number]: {
-        /** The bounding box of the geometry as a Float32Array. */
-        boundingBox: Float32Array;
-        /** A boolean indicating whether the geometry has holes. */
-        hasHoles: boolean;
-        /** An optional file path for the geometry data. */
-        geometryFile?: string;
-    };
-}
-/**
- * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
- */
-export interface StreamedAsset {
-    /** The unique identifier of the asset. */
-    id: number;
-    /** An array of geometries associated with the asset. */
-    geometries: {
-        /** The unique identifier of the geometry. */
-        geometryID: number;
-        /** The transformation matrix of the geometry as a number array. */
-        transformation: number[];
-        /** The color of the geometry as a number array. */
-        color: number[];
-    }[];
-}
-import * as 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 { Components } from "../../Components";
-import { AsyncEvent, Event, World } from "../../Types";
-/**
- * Settings to configure the CullerRenderer.
- */
-export interface CullerRendererSettings {
-    /**
-     * Interval in milliseconds at which the visibility check should be performed.
-     * Default value is 1000.
-     */
-    updateInterval?: number;
-    /**
-     * Width of the render target used for visibility checks.
-     * Default value is 512.
-     */
-    width?: number;
-    /**
-     * Height of the render target used for visibility checks.
-     * Default value is 512.
-     */
-    height?: number;
-    /**
-     * Whether the visibility check should be performed automatically.
-     * Default value is true.
-     */
-    autoUpdate?: boolean;
-}
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class CullerRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onViewUpdated: Event<any> | AsyncEvent<any>;
-    /**
-     * Whether this renderer is active or not. If not, it won't render anything.
-     */
-    enabled: boolean;
-    /**
-     * Needs to check whether there are objects that need to be hidden or shown.
-     * You can bind this to the camera movement, to a certain interval, etc.
-     */
-    needsUpdate: boolean;
-    /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
-     */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected autoUpdate: boolean;
-    protected updateInterval: number;
-    protected readonly worker: Worker;
-    protected readonly scene: THREE.Scene;
-    private _width;
-    private _height;
-    private _availableColor;
-    private readonly renderTarget;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
-     */
-    updateVisibility: (force?: boolean) => Promise<void>;
-    protected getAvailableColor(): {
-        r: number;
-        g: number;
-        b: number;
-        code: string;
-    };
-    protected increaseColor(): void;
-    protected decreaseColor(): void;
-    private applySettings;
-}
 import * as THREE from "three";
 import { Hideable, Disposable, Event, World } from "../../Types";
 import { Components } from "../../Components";
@@ -3335,95 +3338,51 @@ export declare class SimplePlane implements Disposable, Hideable {
     private preventCameraMovement;
     private newHelper;
     private static newPlaneMesh;
-}
-import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
+}
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../Types";
+import { OrthoPerspectiveCamera } from "../index";
 /**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
  */
-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>;
-    }>;
+export declare class ProjectionManager {
     /**
-     * Pixels in screen a geometry must occupy to be considered "seen".
-     * Default value is 100.
+     * Event that fires when the {@link CameraProjection} changes.
      */
-    threshold: number;
+    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
     /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
+     * Current projection mode of the camera.
+     * Default is "Perspective".
      */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    current: CameraProjection;
     /**
-     * Flag to indicate if the renderer is currently processing.
-     * Used to prevent concurrent processing.
+     * The camera controlled by this ProjectionManager.
+     * It can be either a PerspectiveCamera or an OrthographicCamera.
      */
-    isProcessing: boolean;
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private _intervalID;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    private _component;
+    private _previousDistance;
+    constructor(camera: OrthoPerspectiveCamera);
     /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
+     * 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.
      */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    set(projection: CameraProjection): Promise<void>;
     /**
-     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
-     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
-     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     * @returns {void}
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
      */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
-}
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
- */
-export declare class FirstPersonMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "FirstPerson";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
-}
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: OrthoPerspectiveCamera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getPerspectiveDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
 }
 /**
  * The projection system of the camera.
@@ -3451,6 +3410,85 @@ export interface NavigationMode {
     /** 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;
+}
+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 * 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;
+}
+/**
+ * A dictionary of geometries streamed from a server. Each geometry is identified by a unique number (id), and contains information about its bounding box, whether it has holes, and an optional file path for the geometry data.
+ */
+export interface StreamedGeometries {
+    [id: number]: {
+        /** The bounding box of the geometry as a Float32Array. */
+        boundingBox: Float32Array;
+        /** A boolean indicating whether the geometry has holes. */
+        hasHoles: boolean;
+        /** An optional file path for the geometry data. */
+        geometryFile?: string;
+    };
+}
+/**
+ * A streamed asset, which consists of multiple geometries. Each geometry in the asset is identified by a unique number (geometryID), and contains information about its transformation and color.
+ */
+export interface StreamedAsset {
+    /** The unique identifier of the asset. */
+    id: number;
+    /** An array of geometries associated with the asset. */
+    geometries: {
+        /** The unique identifier of the geometry. */
+        geometryID: number;
+        /** The transformation matrix of the geometry as a number array. */
+        transformation: number[];
+        /** The color of the geometry as a number array. */
+        color: number[];
+    }[];
+}
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
     [modelID: string]: RelationsMap;
@@ -3475,70 +3513,32 @@ export type InverseAttributes = [
     "ContainsElements"
 ];
 export type InverseAttribute = InverseAttributes[number];
-import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
+import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ * Settings for streaming IFC geometry and assets. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-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);
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
     /**
-     * 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.
+     * Minimum number of geometries to be streamed.
+     * Defaults to 10 geometries.
      */
-    set(projection: CameraProjection): Promise<void>;
+    minGeometrySize: number;
     /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
+     * Minimum amount of assets to be streamed.
+     * Defaults to 1000 assets.
      */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
+    minAssetsSize: number;
 }
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
+import { IfcFragmentSettings } from "../../IfcLoader/src";
 /**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
+ * Settings for streaming properties. Extends {@link IfcFragmentSettings} to inherit common settings.
  */
-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;
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    /**
+     * Amount of properties to be streamed.
+     * Defaults to 100 properties.
+     */
+    propertiesSize: number;
 }
 import { BufferGeometry } from "three";
 import * as THREE from "three";