@thatopen/components 2.0.0-alpha.11 → 2.0.0-alpha.13

package/dist/namespace.d.ts

@@ -1,4 +1,47 @@
 declare namespace OBC {
+import * as THREE from "three";
+import { Components } from "../Components";
+import { Component } from "../Types";
+/**
+ * A tool to safely remove meshes and geometries from memory to
+ * [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+ */
+export declare class Disposer extends Component {
+    private _disposedComponents;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
+    constructor(components: Components);
+    /**
+     * {@link Component.uuid}.
+     * @return the list of UUIDs of deleted components.
+     */
+    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 object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
+     * to remove.
+     *
+     * @param materials - whether to dispose the materials of the mesh.
+     *
+     * @param recursive - whether to recursively dispose the children of the mesh.
+     */
+    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
+    /**
+     * Disposes a geometry from memory.
+     *
+     * @param geometry - the
+     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
+     * to remove.
+     */
+    disposeGeometry(geometry: THREE.BufferGeometry): void;
+    private disposeGeometryAndMaterials;
+    private disposeChildren;
+    private static disposeMaterial;
+}
 import { Component, Disposable, World, Event } from "../Types";
 import { SimpleRaycaster } from "./src";
 import { Components } from "../Components";
@@ -64,49 +107,6 @@ export declare class Components implements Disposable {
     private update;
     private static setupBVH;
 }
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes and geometries from memory to
- * [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * {@link Component.uuid}.
-     * @return the list of UUIDs of deleted components.
-     */
-    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 object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
-    /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
-     */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}
 import { Component, Disposable, World, Event } from "../Types";
 import { GridConfig, SimpleGrid } from "./src";
 export declare class Grids extends Component implements Disposable {
@@ -136,21 +136,6 @@ export declare class Worlds extends Component implements Updateable, Disposable
     dispose(): void;
     update(delta?: number): void | Promise<void>;
 }
-import { Component, Components, Disposable, Updateable, World, Event } from "../../core";
-import { MiniMap } from "./src";
-export declare class MiniMaps extends Component implements Updateable, Disposable {
-    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    readonly onAfterUpdate: Event<unknown>;
-    readonly onBeforeUpdate: Event<unknown>;
-    readonly onDisposed: Event<unknown>;
-    enabled: boolean;
-    list: Map<string, MiniMap>;
-    constructor(components: Components);
-    create(world: World): MiniMap;
-    delete(id: string): void;
-    dispose(): void | Promise<void>;
-    update(): void;
-}
 import * as THREE from "three";
 import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
 import { SimplePlane } from "./src";
@@ -255,55 +240,6 @@ export declare class Clipper<T extends SimplePlane> extends Component implements
     private _onEndDragging;
 }
 import * as THREE from "three";
-import { Components } from "../../core/Components";
-import { SimpleCamera } from "../../core";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
-/**
- * A flexible camera that uses
- * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
- * easily control the camera in 2D and 3D. It supports multiple navigation
- * modes, such as 2D floor plan navigation, first person and 3D orbit.
- */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
-    /**
-     * The current {@link NavigationMode}.
-     */
-    mode: NavigationMode;
-    readonly projection: ProjectionManager;
-    readonly threeOrtho: THREE.OrthographicCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    get current(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
-     *
-     * @param mode - The {@link NavigationMode} to set.
-     */
-    set(mode: NavModeID): void;
-    /**
-     * Make the camera view fit all the specified meshes.
-     *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
-     */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
-    /**
-     * Allows or prevents all user input.
-     *
-     * @param active - whether to enable or disable user inputs.
-     */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoCameraAspect;
-}
-import * as THREE from "three";
 import { Component, Disposable, Event } from "../Types";
 import { Components } from "../Components";
 /**
@@ -374,6 +310,70 @@ export declare class Cullers extends Component implements Disposable {
     /** {@link Disposable.dispose} */
     dispose(): void;
 }
+import { Component, Components, Disposable, Updateable, World, Event } from "../../core";
+import { MiniMap } from "./src";
+export declare class MiniMaps extends Component implements Updateable, Disposable {
+    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
+    readonly onAfterUpdate: Event<unknown>;
+    readonly onBeforeUpdate: Event<unknown>;
+    readonly onDisposed: Event<unknown>;
+    enabled: boolean;
+    list: Map<string, MiniMap>;
+    constructor(components: Components);
+    create(world: World): MiniMap;
+    delete(id: string): void;
+    dispose(): void | Promise<void>;
+    update(): void;
+}
+import * as THREE from "three";
+import { Components } from "../../core/Components";
+import { SimpleCamera } from "../../core";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+/**
+ * A flexible camera that uses
+ * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
+ * easily control the camera in 2D and 3D. It supports multiple navigation
+ * modes, such as 2D floor plan navigation, first person and 3D orbit.
+ */
+export declare class OrthoPerspectiveCamera extends SimpleCamera {
+    /**
+     * The current {@link NavigationMode}.
+     */
+    mode: NavigationMode;
+    readonly projection: ProjectionManager;
+    readonly threeOrtho: THREE.OrthographicCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    get current(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets a new {@link NavigationMode} and disables the previous one.
+     *
+     * @param mode - The {@link NavigationMode} to set.
+     */
+    set(mode: NavModeID): void;
+    /**
+     * Make the camera view fit all the specified meshes.
+     *
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
+     */
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    /**
+     * Allows or prevents all user input.
+     *
+     * @param active - whether to enable or disable user inputs.
+     */
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoCameraAspect;
+}
 import * as WEBIFC from "web-ifc";
 import * as FRAG from "@thatopen/fragments";
 /**
@@ -427,46 +427,10 @@ export declare class IfcPropertiesFinder extends Component implements Disposable
     private arrayUnion;
     private getConditionFunctions;
 }
-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.
- */
-export declare class BoundingBoxes 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);
-    static getDimensions(bbox: THREE.Box3): {
-        width: number;
-        height: number;
-        depth: number;
-        center: THREE.Vector3;
-    };
-    static newBound(positive: boolean): THREE.Vector3;
-    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    get(): THREE.Box3;
-    getSphere(): THREE.Sphere;
-    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
-    reset(): void;
-    add(group: FragmentsGroup): void;
-    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
-    private static getFragmentBounds;
-}
 import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Disposable, Event, Component, Components } from "../../core";
-import { RelationsMap, ModelsRelationMap, InverseAttributes, InverseAttribute } from "./src/types";
+import { RelationsMap, ModelsRelationMap, InverseAttribute } from "./src/types";
 /**
  * Indexer for IFC entities, facilitating the indexing and retrieval of IFC entity relationships.
  * It is designed to process models properties by indexing their IFC entities' relations based on predefined inverse attributes, and provides methods to query these relations.
@@ -481,11 +445,8 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
         relationsMap: RelationsMap;
     }>;
     private _relToAttributesMap;
-    /**
-     * Array of inverse attribute names.
-     * This array is used to define the inverse attributes that the indexer will process and index.
-     */
-    readonly inverseAttributes: InverseAttributes;
+    private _inverseAttributes;
+    private _ifcRels;
     /**
      * Holds the relationship mappings for each model processed by the indexer.
      * The structure is a map where each key is a model's UUID, and the value is another map.
@@ -497,7 +458,6 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     readonly relationMaps: ModelsRelationMap;
     constructor(components: Components);
     private onFragmentsDisposed;
-    private getAttributeRels;
     /**
      * Adds a relation map to the model's relations map.
      *
@@ -525,7 +485,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      */
     process(model: FragmentsGroup): Promise<RelationsMap>;
     /**
-     * Processes a given model from a WebIfc API to index its IFC entities relations based on predefined inverse attributes.
+     * Processes a given model from a WebIfc API to index its IFC entities relations.
      *
      * @param ifcApi - The WebIfc API instance from which to retrieve the model's properties.
      * @param modelID - The unique identifier of the model within the WebIfc API.
@@ -598,13 +558,7 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
      */
     dispose(): void;
 }
-import * as THREE from "three";
-export declare function obbFromPoints(vertices: ArrayLike<number>): {
-    center: THREE.Vector3;
-    halfSizes: THREE.Vector3;
-    rotation: THREE.Matrix3;
-    transformation: THREE.Matrix4;
-};
+export type { InverseAttribute } from "./src/types";
 import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Component, Disposable, Event, Components } from "../../core";
@@ -678,15 +632,61 @@ export declare class IfcPropertiesManager extends Component implements Disposabl
     setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
 }
 export {};
+import * as THREE from "three";
+export interface MeasureEdge {
+    distance: number;
+    points: THREE.Vector3[];
+}
+export declare class MeasurementUtils {
+    static getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    private static getFaceData;
+    static getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    private static round;
+}
+import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
-export declare class FragmentHider extends Component {
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+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.
+ */
+export declare class BoundingBoxes 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);
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
+    static getDimensions(bbox: THREE.Box3): {
+        width: number;
+        height: number;
+        depth: number;
+        center: THREE.Vector3;
+    };
+    static newBound(positive: boolean): THREE.Vector3;
+    static getBounds(points: THREE.Vector3[], min?: THREE.Vector3, max?: THREE.Vector3): THREE.Box3;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    get(): THREE.Box3;
+    getSphere(): THREE.Sphere;
+    getMesh(): THREE.Mesh<THREE.BoxGeometry, THREE.Material | THREE.Material[], THREE.Object3DEventMap>;
+    reset(): void;
+    add(group: FragmentsGroup): void;
+    addMesh(mesh: THREE.InstancedMesh | THREE.Mesh | FRAGS.CurveMesh, itemIDs?: Iterable<number>): void;
+    private static getFragmentBounds;
 }
 import { Component, Disposable, Event, Components } from "../../core";
 export declare class FragmentExploder extends Component implements Disposable {
@@ -703,37 +703,54 @@ export declare class FragmentExploder extends Component implements Disposable {
     reset(): void;
     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";
-export declare class FragmentIfcLoader extends Component implements Disposable {
-    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
-    readonly onIfcStartedLoading: Event<void>;
-    readonly onSetup: Event<void>;
+export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
+import * as THREE from "three";
+export declare function obbFromPoints(vertices: ArrayLike<number>): {
+    center: THREE.Vector3;
+    halfSizes: THREE.Vector3;
+    rotation: THREE.Matrix3;
+    transformation: THREE.Matrix4;
+};
+import * as THREE from "three";
+export declare class MaterialsUtils {
+    static isTransparent(material: THREE.Material): boolean;
+}
+import * as THREE from "three";
+import { Component, Components, Event, World, Disposable } from "../core";
+export interface VertexPickerConfig {
+    showOnlyVertex: boolean;
+    snapDistance: number;
+    previewElement: HTMLElement;
+}
+export declare class VertexPicker extends Component implements Disposable {
+    onVertexFound: Event<THREE.Vector3>;
+    onVertexLost: Event<THREE.Vector3>;
+    components: Components;
+    private _pickedPoint;
+    private _config;
+    private _enabled;
+    private _workingPlane;
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    settings: IfcFragmentSettings;
-    enabled: boolean;
-    webIfc: WEBIFC.IfcAPI;
-    private _material;
-    private _spatialTree;
-    private _metaData;
-    private _fragmentInstances;
-    private _civil;
-    private _propertyExporter;
-    private _visitedFragments;
-    private _materialT;
-    constructor(components: Components);
+    readonly onDisposed: Event<unknown>;
+    set enabled(value: boolean);
+    get enabled(): boolean;
+    constructor(components: Components, config?: Partial<VertexPickerConfig>);
+    [Symbol.dispose](): void;
+    set workingPlane(plane: THREE.Plane | null);
+    get workingPlane(): THREE.Plane | null;
+    set config(value: Partial<VertexPickerConfig>);
+    get config(): Partial<VertexPickerConfig>;
     dispose(): void;
-    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
-    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
-    readIfcFile(data: Uint8Array): Promise<number>;
-    private getAllGeometries;
-    cleanUp(): void;
-    private getMesh;
-    private getGeometry;
-    private autoSetWasm;
+    get(world: World): THREE.Vector3 | null;
+    private getClosestVertex;
+    private getVertices;
+    private getVertex;
+}
+export declare class UUID {
+    private static _pattern;
+    private static _lut;
+    static create(): string;
+    static validate(uuid: string): void;
 }
 import * as THREE from "three";
 import * as FRAGS from "@thatopen/fragments";
@@ -766,9 +783,53 @@ export declare class FragmentClassifier extends Component implements Disposable
     resetColor(items: FRAGS.FragmentIdMap): void;
     private saveItem;
 }
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+export declare class FragmentHider extends Component {
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
+    enabled: boolean;
+    constructor(components: Components);
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
+}
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
+export declare class FragmentIfcLoader extends Component implements Disposable {
+    static readonly uuid: "a659add7-1418-4771-a0d6-7d4d438e4624";
+    readonly onIfcStartedLoading: Event<void>;
+    readonly onSetup: Event<void>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    settings: IfcFragmentSettings;
+    enabled: boolean;
+    webIfc: WEBIFC.IfcAPI;
+    private _material;
+    private _spatialTree;
+    private _metaData;
+    private _fragmentInstances;
+    private _civil;
+    private _propertyExporter;
+    private _visitedFragments;
+    private _materialT;
+    constructor(components: Components);
+    dispose(): void;
+    setup(config?: Partial<IfcFragmentSettings>): Promise<void>;
+    load(data: Uint8Array, coordinate?: boolean): Promise<FRAGS.FragmentsGroup>;
+    readIfcFile(data: Uint8Array): Promise<number>;
+    private getAllGeometries;
+    cleanUp(): void;
+    private getMesh;
+    private getGeometry;
+    private autoSetWasm;
+}
 import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
 import { Component, Components, Event, Disposable } from "../../core";
+import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
 /**
  * Object that can efficiently load binary files that contain
  * [fragment geometry](https://github.com/ThatOpen/engine_fragment).
@@ -796,12 +857,18 @@ export declare class FragmentManager extends Component implements Disposable {
     dispose(): void;
     disposeGroup(group: FragmentsGroup): void;
     /**
-     * Loads one or many fragments into the scene.
-     * @param data - the bytes containing the data for the fragments to load.
-     * @param coordinate - whether this fragmentsgroup should be federated with the others.
-     * @returns the list of IDs of the loaded fragments.
+     * Loads a binar 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.
      */
-    load(data: Uint8Array, coordinate?: boolean): FragmentsGroup;
+    load(data: Uint8Array, config?: Partial<{
+        coordinate: boolean;
+        properties: FRAGS.IfcProperties;
+        relationsMap: RelationsMap;
+    }>): FragmentsGroup;
     /**
      * Export the specified fragments.
      * @param group - the fragments group to be exported.
@@ -811,52 +878,6 @@ export declare class FragmentManager extends Component implements Disposable {
     coordinate(models?: FragmentsGroup[]): void;
 }
 import * as WEBIFC from "web-ifc";
-import { AsyncEvent, Component, Disposable, Event } from "../../core";
-import { PropertiesStreamingSettings } from "../IfcGeometryTiler";
-export declare class IfcPropertiesTiler extends Component implements Disposable {
-    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
-    onPropertiesStreamed: AsyncEvent<{
-        type: number;
-        data: {
-            [id: number]: any;
-        };
-    }>;
-    onProgress: AsyncEvent<number>;
-    onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    enabled: boolean;
-    settings: PropertiesStreamingSettings;
-    webIfc: WEBIFC.IfcAPI;
-    dispose(): Promise<void>;
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllProperties;
-    private cleanUp;
-}
-import * as THREE from "three";
-export interface MeasureEdge {
-    distance: number;
-    points: THREE.Vector3[];
-}
-export declare class MeasurementUtils {
-    static getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    private static getFaceData;
-    static getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    private static round;
-}
-import * as WEBIFC from "web-ifc";
 import { Components, Disposable, Event, Component } from "../../core";
 import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
 export declare class IfcGeometryTiler extends Component implements Disposable {
@@ -896,47 +917,31 @@ export declare class IfcGeometryTiler extends Component implements Disposable {
     private streamAssets;
     private streamGeometries;
 }
-export declare function isPointInFrontOfPlane(point: number[], planePoint: number[], planeNormal: number[]): boolean;
-import * as THREE from "three";
-export declare class MaterialsUtils {
-    static isTransparent(material: THREE.Material): boolean;
-}
-export declare class UUID {
-    private static _pattern;
-    private static _lut;
-    static create(): string;
-    static validate(uuid: string): void;
-}
-import * as THREE from "three";
-import { Component, Components, Event, World, Disposable } from "../core";
-export interface VertexPickerConfig {
-    showOnlyVertex: boolean;
-    snapDistance: number;
-    previewElement: HTMLElement;
-}
-export declare class VertexPicker extends Component implements Disposable {
-    onVertexFound: Event<THREE.Vector3>;
-    onVertexLost: Event<THREE.Vector3>;
-    components: Components;
-    private _pickedPoint;
-    private _config;
-    private _enabled;
-    private _workingPlane;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    set enabled(value: boolean);
-    get enabled(): boolean;
-    constructor(components: Components, config?: Partial<VertexPickerConfig>);
-    [Symbol.dispose](): void;
-    set workingPlane(plane: THREE.Plane | null);
-    get workingPlane(): THREE.Plane | null;
-    set config(value: Partial<VertexPickerConfig>);
-    get config(): Partial<VertexPickerConfig>;
-    dispose(): void;
-    get(world: World): THREE.Vector3 | null;
-    private getClosestVertex;
-    private getVertices;
-    private getVertex;
+import * as WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../core";
+import { PropertiesStreamingSettings } from "../IfcGeometryTiler";
+export declare class IfcPropertiesTiler extends Component implements Disposable {
+    static readonly uuid: "88d2c89c-ce32-47d7-8cb6-d51e4b311a0b";
+    onPropertiesStreamed: AsyncEvent<{
+        type: number;
+        data: {
+            [id: number]: any;
+        };
+    }>;
+    onProgress: AsyncEvent<number>;
+    onIndicesStreamed: AsyncEvent<Map<number, Map<number, number[]>>>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    enabled: boolean;
+    settings: PropertiesStreamingSettings;
+    webIfc: WEBIFC.IfcAPI;
+    dispose(): Promise<void>;
+    streamFromBuffer(data: Uint8Array): Promise<void>;
+    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
+    private readIfcFile;
+    private streamIfcFile;
+    private streamAllProperties;
+    private cleanUp;
 }
 import * as WEBIFC from "web-ifc";
 export interface IfcItemsCategories {
@@ -945,6 +950,9 @@ export interface IfcItemsCategories {
 export declare class IfcCategories {
     getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
 }
+export declare const IfcElements: {
+    [key: number]: string;
+};
 import * as FRAGS from "@thatopen/fragments";
 export declare class IfcPropertiesUtils {
     static getUnits(group: FRAGS.FragmentsGroup): Promise<number>;
@@ -973,9 +981,6 @@ export declare class IfcPropertiesUtils {
 export declare const IfcCategoryMap: {
     [key: number]: string;
 };
-export declare const IfcElements: {
-    [key: number]: string;
-};
 import * as THREE from "three";
 import { Event, Resizeable, Updateable, Disposable, World } from "../../../core";
 export declare class MiniMap implements Resizeable, Updateable, Disposable {
@@ -1011,43 +1016,6 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     private updatePlanes;
 }
 export declare const GeometryTypes: Set<number>;
-export declare const getRelationMap: (properties: Record<string, Record<string, any>>, relationType: number, onElementsFound?: ((relatingID: number, relatedIDs: number[]) => void) | undefined) => {
-    [relatingID: number]: number[];
-};
-export declare const relToAttributesMap: Map<number, {
-    forRelating?: "IsDecomposedBy" | "Decomposes" | "AssociatedTo" | "HasAssociations" | "ClassificationForObjects" | "IsGroupedBy" | "HasAssignments" | "IsDefinedBy" | "DefinesOcurrence" | "IsTypedBy" | "Types" | "Defines" | "ContainedInStructure" | "ContainsElements" | undefined;
-    forRelated?: "IsDecomposedBy" | "Decomposes" | "AssociatedTo" | "HasAssociations" | "ClassificationForObjects" | "IsGroupedBy" | "HasAssignments" | "IsDefinedBy" | "DefinesOcurrence" | "IsTypedBy" | "Types" | "Defines" | "ContainedInStructure" | "ContainsElements" | undefined;
-}>;
-import * as THREE from "three";
-import { BaseScene, Configurable, Event } from "../../Types";
-import { Components } from "../../Components";
-export interface SimpleSceneConfig {
-    directionalLight: {
-        color: THREE.Color;
-        intensity: number;
-        position: THREE.Vector3;
-    };
-    ambientLight: {
-        color: THREE.Color;
-        intensity: number;
-    };
-}
-/**
- * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add
- * objects hierarchically, and easily dispose them when you are finished with it.
- * @noInheritDoc
- */
-export declare class SimpleScene extends BaseScene implements Configurable<{}> {
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    three: THREE.Scene;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<SimpleScene>;
-    config: Required<SimpleSceneConfig>;
-    constructor(components: Components);
-    /** Creates a simple and nice default set up for the scene (e.g. lighting). */
-    setup(config?: Partial<SimpleSceneConfig>): void;
-}
 import * as THREE from "three";
 import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer } from "../../Types";
 import { Components } from "../../Components";
@@ -1074,6 +1042,11 @@ export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends Base
     update(delta?: number): void;
     dispose(disposeResources?: boolean): void;
 }
+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 {
@@ -1082,110 +1055,35 @@ export declare class SpatialStructure {
     setUp(webIfc: WEBIFC.IfcAPI): void;
     cleanUp(): void;
 }
-import { NavigationMode } from "./types";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning
- * like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: any;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: any);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
-}
 import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
+import { BaseScene, Configurable, Event } from "../../Types";
 import { Components } from "../../Components";
-/**
- * A basic camera that uses
- * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
- * easily control the camera in 2D and 3D. Check out it's API to find out
- * what features it offers.
- */
-export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<SimpleCamera>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<SimpleCamera>;
-    readonly onAspectUpdated: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    readonly three: THREE.PerspectiveCamera;
-    private _allControls;
-    /**
-     * The object that controls the camera. An instance of
-     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
-     * Transforming the camera directly will have no effect: you need to use this
-     * object to move, rotate, look at objects, etc.
-     */
-    get controls(): CameraControls;
-    /** {@link Component.enabled} */
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(enabled: boolean);
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(_delta: number): void;
-    /**
-     * Updates the aspect of the camera to match the size of the
-     * {@link Components.renderer}.
-     */
-    updateAspect: () => void;
-    private setupCamera;
-    private newCameraControls;
-    private setupEvents;
-    private static getSubsetOfThree;
-}
-import { NavigationMode } from "./types";
-/**
- * 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: any);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
+export interface SimpleSceneConfig {
+    directionalLight: {
+        color: THREE.Color;
+        intensity: number;
+        position: THREE.Vector3;
+    };
+    ambientLight: {
+        color: THREE.Color;
+        intensity: number;
+    };
 }
 /**
- * The projection system of the camera.
- */
-export type CameraProjection = "Perspective" | "Orthographic";
-/**
- * The extensible list of supported navigation modes.
- */
-export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
-/**
- * An object that determines the behavior of the camera controls
- * and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ * A basic 3D [scene](https://threejs.org/docs/#api/en/scenes/Scene) to add
+ * objects hierarchically, and easily dispose them when you are finished with it.
+ * @noInheritDoc
  */
-export interface NavigationMode {
-    /** The unique ID of this navigation mode. */
-    id: NavModeID;
-    /**
-     * Enable or disable this navigation mode.
-     * When a new navigation mode is enabled, the previous navigation mode
-     * must be disabled.
-     *
-     * @param active - whether to enable or disable this mode.
-     * @param options - any additional data required to enable or disable it.
-     * */
-    set: (active: boolean, options?: any) => void;
-    /** Whether this navigation mode is active or not. */
-    enabled: boolean;
+export declare class SimpleScene extends BaseScene implements Configurable<{}> {
+    /** {@link Configurable.isSetup} */
+    isSetup: boolean;
+    three: THREE.Scene;
+    /** {@link Configurable.onSetup} */
+    readonly onSetup: Event<SimpleScene>;
+    config: Required<SimpleSceneConfig>;
+    constructor(components: Components);
+    /** Creates a simple and nice default set up for the scene (e.g. lighting). */
+    setup(config?: Partial<SimpleSceneConfig>): void;
 }
 import * as THREE from "three";
 import { BaseRenderer, Event } from "../../Types";
@@ -1219,157 +1117,50 @@ export declare class SimpleRenderer extends BaseRenderer {
     private onContextBack;
 }
 import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../../core";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
- */
-export declare class ProjectionManager {
-    /**
-     * Event that fires when the {@link CameraProjection} changes.
-     */
-    readonly onChanged: Event<THREE.Camera>;
-    current: CameraProjection;
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    private _component;
-    private _previousDistance;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    constructor(camera: OrthoPerspectiveCamera);
-    /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
-     *
-     * @param projection - the new projection to set. If it is the current projection,
-     * it will have no effect.
-     */
-    set(projection: CameraProjection): Promise<void>;
-    /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
-     */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
-}
-import { NavigationMode } from "./types";
-/**
- * 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: any);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-}
-import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
+import CameraControls from "camera-controls";
+import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
+import { Components } from "../../Components";
 /**
- * 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.
+ * A basic camera that uses
+ * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
+ * easily control the camera in 2D and 3D. Check out it's API to find out
+ * what features it offers.
  */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
+export declare class SimpleCamera extends BaseCamera implements Updateable, Disposable {
+    /** {@link Updateable.onBeforeUpdate} */
+    readonly onBeforeUpdate: Event<SimpleCamera>;
+    /** {@link Updateable.onAfterUpdate} */
+    readonly onAfterUpdate: Event<SimpleCamera>;
+    readonly onAspectUpdated: Event<unknown>;
     /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
+    readonly onDisposed: Event<string>;
+    readonly three: THREE.PerspectiveCamera;
+    private _allControls;
     /**
-     * The real position of the mouse of the Three.js canvas.
+     * The object that controls the camera. An instance of
+     * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls).
+     * Transforming the camera directly will have no effect: you need to use this
+     * object to move, rotate, look at objects, etc.
      */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private setupEvents;
-}
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
-/**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster)
- * that allows to easily get items from the scene using the mouse and touch
- * events.
- */
-export declare class SimpleRaycaster implements Disposable {
+    get controls(): CameraControls;
     /** {@link Component.enabled} */
-    enabled: boolean;
-    components: Components;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
-    readonly three: THREE.Raycaster;
-    world: World;
-    constructor(components: Components, world: World);
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(enabled: boolean);
+    constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    /** {@link Updateable.update} */
+    update(_delta: number): void;
     /**
-     * Throws a ray from the camera to the mouse or touch event point and returns
-     * the first item found. This also takes into account the clipping planes
-     * used by the renderer.
-     *
-     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
-     * to query. If not provided, it will query all the meshes stored in
-     * {@link Components.meshes}.
-     */
-    castRay(items?: THREE.Mesh[]): THREE.Intersection | null;
-    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
-    private intersect;
-    private filterClippingPlanes;
-}
-/**
- * Simple event handler by
- * [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540).
- * Keep in mind that:
- * - If you want to remove it later, you might want to declare the callback as
- * an object.
- * - If you want to maintain the reference to 'this', you will need to declare
- * the callback as an arrow function.
- */
-export declare class Event<T> {
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
+     * Updates the aspect of the camera to match the size of the
+     * {@link Components.renderer}.
      */
-    remove(handler: T extends void ? {
-        (): void;
-    } : {
-        (data: T): void;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => void;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
+    updateAspect: () => void;
+    private setupCamera;
+    private newCameraControls;
+    private setupEvents;
+    private static getSubsetOfThree;
 }
 /**
  * Simple event handler by
@@ -1380,27 +1171,27 @@ export declare class Event<T> {
  * - If you want to maintain the reference to 'this', you will need to declare
  * the callback as an arrow function.
  */
-export declare class AsyncEvent<T> {
+export declare class Event<T> {
     /**
      * Add a callback to this event instance.
      * @param handler - the callback to be added to this event.
      */
     add(handler: T extends void ? {
-        (): Promise<void>;
+        (): void;
     } : {
-        (data: T): Promise<void>;
+        (data: T): void;
     }): void;
     /**
      * Removes a callback from this event instance.
      * @param handler - the callback to be removed from this event.
      */
     remove(handler: T extends void ? {
-        (): Promise<void>;
+        (): void;
     } : {
-        (data: T): Promise<void>;
+        (data: T): void;
     }): void;
     /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => Promise<void>;
+    trigger: (data?: T) => void;
     /** Gets rid of all the suscribed events. */
     reset(): void;
     private handlers;
@@ -1528,6 +1319,58 @@ export interface BVHGeometry extends THREE.BufferGeometry {
 export interface CameraControllable {
     controls: CameraControls;
 }
+/**
+ * Simple event handler by
+ * [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540).
+ * Keep in mind that:
+ * - If you want to remove it later, you might want to declare the callback as
+ * an object.
+ * - If you want to maintain the reference to 'this', you will need to declare
+ * the callback as an arrow function.
+ */
+export declare class AsyncEvent<T> {
+    /**
+     * Add a callback to this event instance.
+     * @param handler - the callback to be added to this event.
+     */
+    add(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /**
+     * Removes a callback from this event instance.
+     * @param handler - the callback to be removed from this event.
+     */
+    remove(handler: T extends void ? {
+        (): Promise<void>;
+    } : {
+        (data: T): Promise<void>;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => Promise<void>;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
+}
+import { Base } from "./base";
+/**
+ * Components are the building blocks of this library. Components are singleton
+ * elements that contain specific functionality. For instance, the SimpleClipper
+ * Component can create, delete and handle 3D clipping planes. Components must be
+ * unique (they can't be instanced more than once), and have a static UUID that
+ * identifies them uniquely. The can be accessed globally using the {@link Components}
+ * instance.
+ */
+export declare abstract class Component extends Base {
+    /**
+     * Whether this component is active or not. The behaviour can vary depending
+     * on the type of component. E.g. a disabled dimension tool will stop creating
+     * dimensions, while a disabled camera will stop moving. A disabled component
+     * will not be updated automatically each frame.
+     */
+    abstract enabled: boolean;
+}
 import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
 /**
@@ -1564,24 +1407,6 @@ export declare abstract class BaseWorldItem extends Base {
     currentWorld: World | null;
     protected constructor(components: Components);
 }
-import { Base } from "./base";
-/**
- * Components are the building blocks of this library. Components are singleton
- * elements that contain specific functionality. For instance, the SimpleClipper
- * Component can create, delete and handle 3D clipping planes. Components must be
- * unique (they can't be instanced more than once), and have a static UUID that
- * identifies them uniquely. The can be accessed globally using the {@link Components}
- * instance.
- */
-export declare abstract class Component extends Base {
-    /**
-     * Whether this component is active or not. The behaviour can vary depending
-     * on the type of component. E.g. a disabled dimension tool will stop creating
-     * dimensions, while a disabled camera will stop moving. A disabled component
-     * will not be updated automatically each frame.
-     */
-    abstract enabled: boolean;
-}
 import * as THREE from "three";
 import { Vector2 } from "three";
 import { Event } from "./event";
@@ -1634,67 +1459,6 @@ export declare abstract class BaseCamera extends BaseWorldItem {
     hasCameraControls: () => this is CameraControllable;
 }
 import * as THREE from "three";
-import { Hideable, Disposable, Event, World } from "../../Types";
-import { Components } from "../../Components";
-/**
- * Each of the planes created by {@link SimpleClipper}.
- */
-export declare class SimplePlane implements Disposable, Hideable {
-    /** Event that fires when the user starts dragging a clipping plane. */
-    readonly onDraggingStarted: Event<unknown>;
-    /** Event that fires when the user stops dragging a clipping plane. */
-    readonly onDraggingEnded: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    readonly normal: THREE.Vector3;
-    readonly origin: THREE.Vector3;
-    readonly three: THREE.Plane;
-    protected readonly _helper: THREE.Object3D;
-    protected _visible: boolean;
-    protected _enabled: boolean;
-    components: Components;
-    world: World;
-    private _controlsActive;
-    private readonly _arrowBoundBox;
-    private readonly _planeMesh;
-    private readonly _controls;
-    private readonly _hiddenMaterial;
-    get enabled(): boolean;
-    /** {@link Component.enabled} */
-    set enabled(state: boolean);
-    /** {@link Hideable.visible } */
-    get visible(): boolean;
-    /** {@link Hideable.visible } */
-    set visible(state: boolean);
-    /** The meshes used for raycasting */
-    get meshes(): THREE.Mesh[];
-    /** The material of the clipping plane representation. */
-    get planeMaterial(): THREE.Material | THREE.Material[];
-    /** The material of the clipping plane representation. */
-    set planeMaterial(material: THREE.Material | THREE.Material[]);
-    /** The size of the clipping plane representation. */
-    get size(): number;
-    /** Sets the size of the clipping plane representation. */
-    set size(size: number);
-    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
-    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
-    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): Promise<void>;
-    /** {@link Updateable.update} */
-    update: () => Promise<void>;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private reset;
-    protected toggleControls(state: boolean): void;
-    private newTransformControls;
-    private initializeControls;
-    private createArrowBoundingBox;
-    private changeDrag;
-    private notifyDraggingChanged;
-    private preventCameraMovement;
-    private newHelper;
-    private static newPlaneMesh;
-}
-import * as THREE from "three";
 import { Disposable } from "./interfaces";
 import { Event } from "./event";
 import { Components } from "../../Components";
@@ -1719,6 +1483,122 @@ export interface World extends Disposable, Updateable {
     renderer: BaseRenderer | null;
     uuid: string;
 }
+import { NavigationMode } from "./types";
+/**
+ * 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: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private setupFirstPersonCamera;
+}
+import { NavigationMode } from "./types";
+/**
+ * A {@link NavigationMode} that allows 3D navigation and panning
+ * like in many 3D and CAD softwares.
+ */
+export declare class OrbitMode implements NavigationMode {
+    camera: any;
+    /** {@link NavigationMode.enabled} */
+    enabled: boolean;
+    /** {@link NavigationMode.id} */
+    readonly id = "Orbit";
+    constructor(camera: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+    private activateOrbitControls;
+}
+import { NavigationMode } from "./types";
+/**
+ * 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: any);
+    /** {@link NavigationMode.set} */
+    set(active: boolean): void;
+}
+import * as THREE from "three";
+import { CameraProjection } from "./types";
+import { Event } from "../../../core";
+import { OrthoPerspectiveCamera } from "../index";
+/**
+ * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+ */
+export declare class ProjectionManager {
+    /**
+     * Event that fires when the {@link CameraProjection} changes.
+     */
+    readonly onChanged: Event<THREE.Camera>;
+    current: CameraProjection;
+    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    private _component;
+    private _previousDistance;
+    /** Match Ortho zoom with Perspective distance when changing projection mode */
+    matchOrthoDistanceEnabled: boolean;
+    constructor(camera: OrthoPerspectiveCamera);
+    /**
+     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
+     *
+     * @param projection - the new projection to set. If it is the current projection,
+     * it will have no effect.
+     */
+    set(projection: CameraProjection): Promise<void>;
+    /**
+     * Changes the current {@link CameraProjection} from Ortographic to Perspective
+     * and vice versa.
+     */
+    toggle(): Promise<void>;
+    private setOrthoCamera;
+    private getDims;
+    private setupOrthoCamera;
+    private getDistance;
+    private setPerspectiveCamera;
+}
+/**
+ * The projection system of the camera.
+ */
+export type CameraProjection = "Perspective" | "Orthographic";
+/**
+ * The extensible list of supported navigation modes.
+ */
+export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
+/**
+ * An object that determines the behavior of the camera controls
+ * and the user input (e.g. 2D floor plan mode, first person mode, etc).
+ */
+export interface NavigationMode {
+    /** The unique ID of this navigation mode. */
+    id: NavModeID;
+    /**
+     * Enable or disable this navigation mode.
+     * When a new navigation mode is enabled, the previous navigation mode
+     * must be disabled.
+     *
+     * @param active - whether to enable or disable this mode.
+     * @param options - any additional data required to enable or disable it.
+     * */
+    set: (active: boolean, options?: any) => void;
+    /** Whether this navigation mode is active or not. */
+    enabled: boolean;
+}
 /// <reference types="node" />
 import * as THREE from "three";
 import { Hideable, Event, World } from "../../Types";
@@ -1834,6 +1714,173 @@ export declare class CullerRenderer {
     protected decreaseColor(): void;
     private applySettings;
 }
+export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
+import * as THREE from "three";
+import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
+import { Components } from "../../Components";
+import { Event, World } from "../../Types";
+/**
+ * A renderer to determine a mesh visibility on screen
+ */
+export declare class MeshCullerRenderer extends CullerRenderer {
+    threshold: number;
+    readonly onViewUpdated: Event<{
+        seen: Set<THREE.Mesh>;
+        unseen: Set<THREE.Mesh>;
+    }>;
+    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
+    isProcessing: boolean;
+    private _colorCodeMeshMap;
+    private _meshIDColorCodeMap;
+    private _currentVisibleMeshes;
+    private _recentlyHiddenMeshes;
+    private _intervalID;
+    private readonly _transparentMat;
+    constructor(components: Components, world: World, settings?: CullerRendererSettings);
+    dispose(): void;
+    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
+    private handleWorkerMessage;
+    private getAvailableMaterial;
+}
+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";
+/**
+ * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster)
+ * that allows to easily get items from the scene using the mouse and touch
+ * events.
+ */
+export declare class SimpleRaycaster implements Disposable {
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    components: Components;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    /** The position of the mouse in the screen. */
+    readonly mouse: Mouse;
+    readonly three: THREE.Raycaster;
+    world: World;
+    constructor(components: Components, world: World);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Throws a ray from the camera to the mouse or touch event point and returns
+     * the first item found. This also takes into account the clipping planes
+     * used by the renderer.
+     *
+     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
+     * to query. If not provided, it will query all the meshes stored in
+     * {@link Components.meshes}.
+     */
+    castRay(items?: THREE.Mesh[]): THREE.Intersection | null;
+    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
+    private intersect;
+    private filterClippingPlanes;
+}
+import * as THREE from "three";
+import { Hideable, Disposable, Event, World } from "../../Types";
+import { Components } from "../../Components";
+/**
+ * Each of the planes created by {@link SimpleClipper}.
+ */
+export declare class SimplePlane implements Disposable, Hideable {
+    /** Event that fires when the user starts dragging a clipping plane. */
+    readonly onDraggingStarted: Event<unknown>;
+    /** Event that fires when the user stops dragging a clipping plane. */
+    readonly onDraggingEnded: Event<unknown>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    readonly normal: THREE.Vector3;
+    readonly origin: THREE.Vector3;
+    readonly three: THREE.Plane;
+    protected readonly _helper: THREE.Object3D;
+    protected _visible: boolean;
+    protected _enabled: boolean;
+    components: Components;
+    world: World;
+    private _controlsActive;
+    private readonly _arrowBoundBox;
+    private readonly _planeMesh;
+    private readonly _controls;
+    private readonly _hiddenMaterial;
+    get enabled(): boolean;
+    /** {@link Component.enabled} */
+    set enabled(state: boolean);
+    /** {@link Hideable.visible } */
+    get visible(): boolean;
+    /** {@link Hideable.visible } */
+    set visible(state: boolean);
+    /** The meshes used for raycasting */
+    get meshes(): THREE.Mesh[];
+    /** The material of the clipping plane representation. */
+    get planeMaterial(): THREE.Material | THREE.Material[];
+    /** The material of the clipping plane representation. */
+    set planeMaterial(material: THREE.Material | THREE.Material[]);
+    /** The size of the clipping plane representation. */
+    get size(): number;
+    /** Sets the size of the clipping plane representation. */
+    set size(size: number);
+    get helper(): THREE.Object3D<THREE.Object3DEventMap>;
+    constructor(components: Components, world: World, origin: THREE.Vector3, normal: THREE.Vector3, material: THREE.Material, size?: number, activateControls?: boolean);
+    setFromNormalAndCoplanarPoint(normal: THREE.Vector3, point: THREE.Vector3): Promise<void>;
+    /** {@link Updateable.update} */
+    update: () => Promise<void>;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private reset;
+    protected toggleControls(state: boolean): void;
+    private newTransformControls;
+    private initializeControls;
+    private createArrowBoundingBox;
+    private changeDrag;
+    private notifyDraggingChanged;
+    private preventCameraMovement;
+    private newHelper;
+    private static newPlaneMesh;
+}
+import * as THREE from "three";
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+export declare class CivilReader {
+    defLineMat: THREE.LineBasicMaterial;
+    read(webIfc: WEBIFC.IfcAPI): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    get(civilItems: any): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    private getCurves;
+}
 import * as WEBIFC from "web-ifc";
 /** Configuration of the IFC-fragment conversion. */
 export declare class IfcFragmentSettings {
@@ -1861,54 +1908,20 @@ export declare class IfcFragmentSettings {
     autoSetWasm: boolean;
     customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
 }
-import * as THREE from "three";
-import * as WEBIFC from "web-ifc";
-import * as FRAGS from "@thatopen/fragments";
-export declare class CivilReader {
-    defLineMat: THREE.LineBasicMaterial;
-    read(webIfc: WEBIFC.IfcAPI): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    get(civilItems: any): {
-        alignments: Map<number, FRAGS.Alignment>;
-        coordinationMatrix: THREE.Matrix4;
-    } | undefined;
-    private getCurves;
-}
 import * as WEBIFC from "web-ifc";
 export declare class IfcMetadataReader {
     get(webIfc: WEBIFC.IfcAPI, type: number): string;
 }
-import * as THREE from "three";
-import { CullerRenderer, CullerRendererSettings } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World } from "../../Types";
-/**
- * A renderer to determine a mesh visibility on screen
- */
-export declare class MeshCullerRenderer extends CullerRenderer {
-    threshold: number;
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[]>>;
-    isProcessing: boolean;
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private _intervalID;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World, settings?: CullerRendererSettings);
-    dispose(): void;
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
+import { IfcFragmentSettings } from "../../FragmentIfcLoader/src";
+/** Configuration of the IFC-fragment streaming. */
+export declare class IfcStreamingSettings extends IfcFragmentSettings {
+    minGeometrySize: number;
+    minAssetsSize: number;
+}
+/** Configuration of the IFC-fragment streaming. */
+export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
+    propertiesSize: number;
 }
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;
 import * as WEBIFC from "web-ifc";
 import { AsyncEvent, Component, Disposable, Event } from "../../../core";
 import { PropertiesStreamingSettings } from "./streaming-settings";
@@ -1936,26 +1949,6 @@ export declare class FragmentPropsStreamConverter extends Component implements D
     private getIndices;
     private cleanUp;
 }
-import { IfcFragmentSettings } from "../../FragmentIfcLoader/src";
-/** Configuration of the IFC-fragment streaming. */
-export declare class IfcStreamingSettings extends IfcFragmentSettings {
-    minGeometrySize: number;
-    minAssetsSize: number;
-}
-/** Configuration of the IFC-fragment streaming. */
-export declare class PropertiesStreamingSettings extends IfcFragmentSettings {
-    propertiesSize: 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;
-}
 export interface StreamedGeometries {
     [id: number]: {
         boundingBox: Float32Array;
@@ -1971,6 +1964,16 @@ export interface StreamedAsset {
         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;
+}
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
     [modelID: string]: RelationsMap;