@thatopen/components 2.0.6 → 2.0.8

package/dist/namespace.d.ts

@@ -1,337 +1,4 @@
 declare namespace OBC {
-import { Component, Disposable, Event, Components } from "../../core";
-export declare class Exploder extends Component implements Disposable {
-    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
-    enabled: boolean;
-    height: number;
-    groupName: string;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    list: Set<string>;
-    constructor(components: Components);
-    dispose(): void;
-    set(active: boolean): void;
-}
-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 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);
-    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 THREE from "three";
-import * as FRAGS from "@thatopen/fragments";
-import { Disposable, Component, Event, Components } from "../../core";
-export interface Classification {
-    [system: string]: {
-        [className: string]: FRAGS.FragmentIdMap;
-    };
-}
-export declare class Classifier extends Component implements Disposable {
-    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    list: Classification;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(components: Components);
-    private onFragmentsDisposed;
-    dispose(): void;
-    remove(guid: string): void;
-    find(filter?: {
-        [name: string]: string[];
-    }): FRAGS.FragmentIdMap;
-    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
-    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
-    byEntity(group: FRAGS.FragmentsGroup): void;
-    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
-    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
-    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
-    resetColor(items: FRAGS.FragmentIdMap): void;
-    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
-}
-import * as FRAGS from "@thatopen/fragments";
-import { Components, Component } from "../../core";
-export declare class Hider extends Component {
-    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
-    enabled: boolean;
-    constructor(components: Components);
-    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
-    isolate(items: FRAGS.FragmentIdMap): void;
-    private updateCulledVisibility;
-}
-import * as 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 {
-    static readonly uuid: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
-    onGeometryStreamed: Event<{
-        buffer: Uint8Array;
-        data: StreamedGeometries;
-    }>;
-    onAssetStreamed: Event<StreamedAsset[]>;
-    onProgress: Event<number>;
-    onIfcLoaded: Event<Uint8Array>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    settings: IfcStreamingSettings;
-    enabled: boolean;
-    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);
-    dispose(): void;
-    streamFromBuffer(data: Uint8Array): Promise<void>;
-    streamFromCallBack(loadCallback: WEBIFC.ModelLoadCallback): Promise<void>;
-    private readIfcFile;
-    private streamIfcFile;
-    private streamAllGeometries;
-    private cleanUp;
-    private getMesh;
-    private getGeometry;
-    private streamAssets;
-    private streamGeometries;
-}
-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).
- */
-export declare class FragmentsManager extends Component implements Disposable {
-    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    readonly onFragmentsLoaded: Event<FragmentsGroup>;
-    readonly onFragmentsDisposed: Event<{
-        groupID: string;
-        fragmentIDs: string[];
-    }>;
-    /** All the created [fragments](https://github.com/ThatOpen/engine_fragment). */
-    readonly list: Map<string, Fragment>;
-    readonly groups: Map<string, FragmentsGroup>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    baseCoordinationModel: string;
-    private _loader;
-    /** The list of meshes of the created fragments. */
-    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    disposeGroup(group: FragmentsGroup): void;
-    /**
-     * 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, config?: Partial<{
-        coordinate: boolean;
-        name: string;
-        properties: FRAGS.IfcProperties;
-        relationsMap: RelationsMap;
-    }>): FragmentsGroup;
-    /**
-     * Export the specified fragments.
-     * @param group - the fragments group to be exported.
-     * @returns the exported data as binary buffer.
-     */
-    export(group: FragmentsGroup): Uint8Array;
-    coordinate(models?: FragmentsGroup[]): 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 IfcLoader 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 _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 * 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";
-import * as FRAG from "@thatopen/fragments";
-import { Component, Components } from "../../core";
-/**
- * Object to export all the properties from an IFC to a JS object.
- */
-export declare class IfcJsonExporter extends Component {
-    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Exports all the properties of an IFC into an array of JS objects.
-     * @param webIfc The instance of [web-ifc]{@link https://github.com/ThatOpen/engine_web-ifc} to use.
-     * @param modelID ID of the IFC model whose properties to extract.
-     * @param indirect whether to get the indirect relationships as well.
-     * @param recursiveSpatial whether to get the properties of spatial items recursively
-     * to make the location data available (e.g. absolute position of building).
-     */
-    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
-}
-import * as WEBIFC from "web-ifc";
-import { FragmentsGroup } from "@thatopen/fragments";
-import { Component, Disposable, Event, Components } from "../../core";
-type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
-type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
-type NumericPropTypes = "IfcInteger" | "IfcReal";
-interface ChangeMap {
-    [modelID: string]: Set<number>;
-}
-interface AttributeListener {
-    [modelID: string]: {
-        [expressID: number]: {
-            [attributeName: string]: Event<String | Boolean | Number>;
-        };
-    };
-}
-export declare class IfcPropertiesManager extends Component implements Disposable {
-    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    readonly onRequestFile: Event<unknown>;
-    ifcToExport: ArrayBuffer | null;
-    readonly onElementToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        elementID: number;
-    }>;
-    readonly onPropToPset: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-        propID: number;
-    }>;
-    readonly onPsetRemoved: Event<{
-        model: FragmentsGroup;
-        psetID: number;
-    }>;
-    readonly onDataChanged: Event<{
-        model: FragmentsGroup;
-        expressID: number;
-    }>;
-    wasm: {
-        path: string;
-        absolute: boolean;
-    };
-    enabled: boolean;
-    attributeListeners: AttributeListener;
-    selectedModel?: FragmentsGroup;
-    changeMap: ChangeMap;
-    constructor(components: Components);
-    dispose(): void;
-    private increaseMaxID;
-    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
-    private newGUID;
-    private getOwnerHistory;
-    private registerChange;
-    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
-    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
-        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
-        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
-    }>;
-    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
-    private newSingleProperty;
-    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
-    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
-    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
-    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
-    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
-    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
-}
-export {};
 import * as WEBIFC from "web-ifc";
 import { FragmentsGroup } from "@thatopen/fragments";
 import { Disposable, Event, Component, Components } from "../../core";
@@ -464,6 +131,112 @@ export declare class IfcRelationsIndexer extends Component implements Disposable
     dispose(): void;
 }
 export type { InverseAttribute, RelationsMap } from "./src/types";
+import * as WEBIFC from "web-ifc";
+import * as FRAG from "@thatopen/fragments";
+import { Component, Components } from "../../core";
+/**
+ * Object to export all the properties from an IFC to a JS object.
+ */
+export declare class IfcJsonExporter extends Component {
+    static readonly uuid: "b32c4332-cd67-436e-ba7f-196646c7a635";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    /**
+     * Exports all the properties of an IFC into an array of JS objects.
+     * @param webIfc The instance of [web-ifc]{@link https://github.com/ThatOpen/engine_web-ifc} to use.
+     * @param modelID ID of the IFC model whose properties to extract.
+     * @param indirect whether to get the indirect relationships as well.
+     * @param recursiveSpatial whether to get the properties of spatial items recursively
+     * to make the location data available (e.g. absolute position of building).
+     */
+    export(webIfc: WEBIFC.IfcAPI, modelID: number, indirect?: boolean, recursiveSpatial?: boolean): Promise<FRAG.IfcProperties>;
+}
+import { Component, Disposable, World, Event } from "../Types";
+import { SimpleRaycaster } from "./src";
+import { Components } from "../Components";
+export declare class Raycasters extends Component implements Disposable {
+    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+    enabled: boolean;
+    list: Map<string, SimpleRaycaster>;
+    onDisposed: Event<unknown>;
+    constructor(components: Components);
+    get(world: World): SimpleRaycaster;
+    delete(world: World): void;
+    dispose(): void;
+}
+import * as WEBIFC from "web-ifc";
+import { FragmentsGroup } from "@thatopen/fragments";
+import { Component, Disposable, Event, Components } from "../../core";
+type BooleanPropTypes = "IfcBoolean" | "IfcLogical";
+type StringPropTypes = "IfcText" | "IfcLabel" | "IfcIdentifier";
+type NumericPropTypes = "IfcInteger" | "IfcReal";
+interface ChangeMap {
+    [modelID: string]: Set<number>;
+}
+interface AttributeListener {
+    [modelID: string]: {
+        [expressID: number]: {
+            [attributeName: string]: Event<String | Boolean | Number>;
+        };
+    };
+}
+export declare class IfcPropertiesManager extends Component implements Disposable {
+    static readonly uuid: "58c2d9f0-183c-48d6-a402-dfcf5b9a34df";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<string>;
+    readonly onRequestFile: Event<unknown>;
+    ifcToExport: ArrayBuffer | null;
+    readonly onElementToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        elementID: number;
+    }>;
+    readonly onPropToPset: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+        propID: number;
+    }>;
+    readonly onPsetRemoved: Event<{
+        model: FragmentsGroup;
+        psetID: number;
+    }>;
+    readonly onDataChanged: Event<{
+        model: FragmentsGroup;
+        expressID: number;
+    }>;
+    wasm: {
+        path: string;
+        absolute: boolean;
+    };
+    enabled: boolean;
+    attributeListeners: AttributeListener;
+    selectedModel?: FragmentsGroup;
+    changeMap: ChangeMap;
+    constructor(components: Components);
+    dispose(): void;
+    private increaseMaxID;
+    static getIFCSchema(model: FragmentsGroup): import("@thatopen/fragments").IfcSchema;
+    private newGUID;
+    private getOwnerHistory;
+    private registerChange;
+    setData(model: FragmentsGroup, ...dataToSave: Record<string, any>[]): Promise<void>;
+    newPset(model: FragmentsGroup, name: string, description?: string): Promise<{
+        pset: WEBIFC.IFC2X3.IfcPropertySet | WEBIFC.IFC4.IfcPropertySet | WEBIFC.IFC4X3.IfcPropertySet;
+        rel: WEBIFC.IFC4X3.IfcRelDefinesByProperties | WEBIFC.IFC4.IfcRelDefinesByProperties | WEBIFC.IFC2X3.IfcRelDefinesByProperties;
+    }>;
+    removePset(model: FragmentsGroup, ...psetID: number[]): Promise<void>;
+    private newSingleProperty;
+    newSingleStringProperty(model: FragmentsGroup, type: StringPropTypes, name: string, value: string): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    newSingleNumericProperty(model: FragmentsGroup, type: NumericPropTypes, name: string, value: number): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    newSingleBooleanProperty(model: FragmentsGroup, type: BooleanPropTypes, name: string, value: boolean): Promise<WEBIFC.IFC2X3.IfcPropertySingleValue | WEBIFC.IFC4.IfcPropertySingleValue | WEBIFC.IFC4X3.IfcPropertySingleValue>;
+    removePsetProp(model: FragmentsGroup, psetID: number, propID: number): Promise<void>;
+    addElementToPset(model: FragmentsGroup, psetID: number, ...elementID: number[]): Promise<void>;
+    addPropToPset(model: FragmentsGroup, psetID: number, ...propID: number[]): Promise<void>;
+    saveToIfc(model: FragmentsGroup, ifcToSaveOn: Uint8Array): Promise<Uint8Array>;
+    setAttributeListener(model: FragmentsGroup, expressID: number, attributeName: string): Promise<Event<String | Number | Boolean>>;
+}
+export {};
 import { Component, Disposable, Event } from "../Types";
 /**
  * The entry point of the Components library.
@@ -508,37 +281,13 @@ export declare class Components implements Disposable {
      * - Any of the objects of this instance (meshes, geometries, etc) is
      * referenced by a reference type (object or array).
      *
-     * You can learn more about how Three.js handles memory leaks
-     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
-     *
-     */
-    dispose(): void;
-    private update;
-    private static setupBVH;
-}
-import * as THREE from "three";
-import { Component, Components } from "../../core";
-export interface MeasureEdge {
-    distance: number;
-    points: THREE.Vector3[];
-}
-export declare class MeasurementUtils extends Component {
-    enabled: boolean;
-    static uuid: string;
-    constructor(components: Components);
-    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
-        edges: MeasureEdge[];
-        indices: Set<number>;
-    } | null;
-    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
-    private getFaceData;
-    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
-        p1: THREE.Vector3;
-        p2: THREE.Vector3;
-        p3: THREE.Vector3;
-        faceNormal: THREE.Vector3;
-    };
-    private round;
+     * You can learn more about how Three.js handles memory leaks
+     * [here](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
+     *
+     */
+    dispose(): void;
+    private update;
+    private static setupBVH;
 }
 import * as THREE from "three";
 import { Components } from "../Components";
@@ -583,18 +332,29 @@ export declare class Disposer extends Component {
     private disposeChildren;
     private static disposeMaterial;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
-import { Components } from "../Components";
-export declare class Raycasters extends Component implements Disposable {
-    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
+import * as THREE from "three";
+import { Component, Components } from "../../core";
+export interface MeasureEdge {
+    distance: number;
+    points: THREE.Vector3[];
+}
+export declare class MeasurementUtils extends Component {
     enabled: boolean;
-    list: Map<string, SimpleRaycaster>;
-    onDisposed: Event<unknown>;
+    static uuid: string;
     constructor(components: Components);
-    get(world: World): SimpleRaycaster;
-    delete(world: World): void;
-    dispose(): void;
+    getFace(mesh: THREE.InstancedMesh | THREE.Mesh, triangleIndex: number, instance?: number): {
+        edges: MeasureEdge[];
+        indices: Set<number>;
+    } | null;
+    static distanceFromPointToLine(point: THREE.Vector3, lineStart: THREE.Vector3, lineEnd: THREE.Vector3, clamp?: boolean): number;
+    private getFaceData;
+    getVerticesAndNormal(mesh: THREE.Mesh | THREE.InstancedMesh, faceIndex: number, instance: number | undefined): {
+        p1: THREE.Vector3;
+        p2: THREE.Vector3;
+        p3: THREE.Vector3;
+        faceNormal: THREE.Vector3;
+    };
+    private round;
 }
 import { Component, Disposable, Updateable, World, Event, BaseScene, BaseCamera, BaseRenderer } from "../Types";
 import { Components } from "../Components";
@@ -665,28 +425,6 @@ export declare class UUID {
     static create(): string;
     static validate(uuid: string): void;
 }
-import { Component, Disposable, World, Event } from "../Types";
-import { GridConfig, SimpleGrid } from "./src";
-import { Components } from "../Components";
-export declare class Grids extends Component implements Disposable {
-    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
-    list: Map<string, SimpleGrid>;
-    readonly onDisposed: Event<unknown>;
-    config: Required<GridConfig>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    create(world: World): SimpleGrid;
-    delete(world: World): void;
-    dispose(): void;
-}
-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 { Component, Components, Event, World } from "../core";
 export interface VertexPickerConfig {
@@ -715,9 +453,6 @@ export declare class VertexPicker extends Component {
     private getVertices;
     private getVertex;
 }
-export declare const IfcElements: {
-    [key: number]: string;
-};
 import * as THREE from "three";
 import { Component, Createable, Disposable, Event, Hideable, World } from "../Types";
 import { SimplePlane } from "./src";
@@ -817,6 +552,21 @@ export declare class Clipper extends Component implements Createable, Disposable
     private _onStartDragging;
     private _onEndDragging;
 }
+import { Component, Disposable, World, Event } from "../Types";
+import { GridConfig, SimpleGrid } from "./src";
+import { Components } from "../Components";
+export declare class Grids extends Component implements Disposable {
+    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
+    list: Map<string, SimpleGrid>;
+    readonly onDisposed: Event<unknown>;
+    config: Required<GridConfig>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    constructor(components: Components);
+    create(world: World): SimpleGrid;
+    delete(world: World): void;
+    dispose(): void;
+}
 import { Components } from "../Components";
 import { MeshCullerRenderer, CullerRendererSettings } from "./src";
 import { Component, Event, Disposable, World } from "../Types";
@@ -855,86 +605,270 @@ export declare class Cullers extends Component implements Disposable {
      */
     set enabled(value: boolean);
     constructor(components: Components);
-    /**
-   * Creates a new MeshCullerRenderer for the given world.
-   * If a MeshCullerRenderer already exists for the world, it will return the existing one.
-   *
-   * @param world - The world for which to create the MeshCullerRenderer.
-   * @param config - Optional configuration settings for the MeshCullerRenderer.
-   *
-   * @returns The newly created or existing MeshCullerRenderer for the given world.
-   */
-    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
+    /**
+   * Creates a new MeshCullerRenderer for the given world.
+   * If a MeshCullerRenderer already exists for the world, it will return the existing one.
+   *
+   * @param world - The world for which to create the MeshCullerRenderer.
+   * @param config - Optional configuration settings for the MeshCullerRenderer.
+   *
+   * @returns The newly created or existing MeshCullerRenderer for the given world.
+   */
+    create(world: World, config?: Partial<CullerRendererSettings>): MeshCullerRenderer;
+    delete(world: World): void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+}
+import { MiniMap } from "./src";
+import { Component, Updateable, World, Event, Disposable } from "../Types";
+import { Components } from "../Components";
+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;
+    update(): void;
+}
+import * as THREE from "three";
+import { Components } from "../Components";
+import { SimpleCamera } from "..";
+import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+/**
+ * A flexible camera that uses
+ * [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to
+ * 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 | null;
+    readonly projection: ProjectionManager;
+    readonly threeOrtho: THREE.OrthographicCamera;
+    readonly threePersp: THREE.PerspectiveCamera;
+    protected readonly _userInputButtons: any;
+    protected readonly _frustumSize = 50;
+    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
+    private previousSize;
+    get mode(): NavigationMode;
+    constructor(components: Components);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    /**
+     * Sets a new {@link NavigationMode} and disables the previous one.
+     *
+     * @param mode - The {@link NavigationMode} to set.
+     */
+    set(mode: NavModeID): void;
+    /**
+     * Make the camera view fit all the specified meshes.
+     *
+     * @param meshes the meshes to fit. If it is not defined, it will
+     * evaluate {@link Components.meshes}.
+     * @param offset the distance to the fit object
+     */
+    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    /**
+     * Allows or prevents all user input.
+     *
+     * @param active - whether to enable or disable user inputs.
+     */
+    setUserInput(active: boolean): void;
+    private disableUserInput;
+    private enableUserInput;
+    private newOrthoCamera;
+    private setOrthoPerspCameraAspect;
+}
+import * as THREE from "three";
+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 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);
+    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 THREE from "three";
+import * as FRAGS from "@thatopen/fragments";
+import { Disposable, Component, Event, Components } from "../../core";
+export interface Classification {
+    [system: string]: {
+        [className: string]: FRAGS.FragmentIdMap;
+    };
+}
+export declare class Classifier extends Component implements Disposable {
+    static readonly uuid: "e25a7f3c-46c4-4a14-9d3d-5115f24ebeb7";
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    list: Classification;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    constructor(components: Components);
+    private onFragmentsDisposed;
+    dispose(): void;
+    remove(guid: string): void;
+    find(filter?: {
+        [name: string]: string[];
+    }): FRAGS.FragmentIdMap;
+    byModel(modelID: string, group: FRAGS.FragmentsGroup): void;
+    byPredefinedType(group: FRAGS.FragmentsGroup): Promise<void>;
+    byEntity(group: FRAGS.FragmentsGroup): void;
+    byIfcRel(group: FRAGS.FragmentsGroup, ifcRel: number, systemName: string): Promise<void>;
+    bySpatialStructure(model: FRAGS.FragmentsGroup): Promise<void>;
+    setColor(items: FRAGS.FragmentIdMap, color: THREE.Color, override?: boolean): void;
+    resetColor(items: FRAGS.FragmentIdMap): void;
+    protected saveItem(group: FRAGS.FragmentsGroup, systemName: string, className: string, expressID: number): void;
+}
+import { Component, Disposable, Event, Components } from "../../core";
+export declare class Exploder extends Component implements Disposable {
+    static readonly uuid: "d260618b-ce88-4c7d-826c-6debb91de3e2";
+    enabled: boolean;
+    height: number;
+    groupName: string;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    list: Set<string>;
+    constructor(components: Components);
+    dispose(): void;
+    set(active: boolean): void;
+}
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+import { IfcFragmentSettings } from "./src";
+import { Component, Components, Event, Disposable } from "../../core";
+export declare class IfcLoader 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 _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 { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
-import { Components } from "../Components";
-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>;
+import * as FRAGS from "@thatopen/fragments";
+import { Components, Component } from "../../core";
+export declare class Hider extends Component {
+    static readonly uuid: "dd9ccf2d-8a21-4821-b7f6-2949add16a29";
     enabled: boolean;
-    list: Map<string, MiniMap>;
     constructor(components: Components);
-    create(world: World): MiniMap;
-    delete(id: string): void;
-    dispose(): void;
-    update(): void;
+    set(visible: boolean, items?: FRAGS.FragmentIdMap): void;
+    isolate(items: FRAGS.FragmentIdMap): void;
+    private updateCulledVisibility;
 }
+import { Fragment, FragmentsGroup } from "@thatopen/fragments";
 import * as THREE from "three";
-import { Components } from "../Components";
-import { SimpleCamera } from "..";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
+import * as FRAGS from "@thatopen/fragments";
+import { Component, Components, Event, Disposable } from "../../core";
+import { RelationsMap } from "../../ifc/IfcRelationsIndexer/src/types";
 /**
- * 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.
+ * Object that can efficiently load binary files that contain
+ * [fragment geometry](https://github.com/ThatOpen/engine_fragment).
  */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
-    /**
-     * The current {@link NavigationMode}.
-     */
-    _mode: NavigationMode | null;
-    readonly projection: ProjectionManager;
-    readonly threeOrtho: THREE.OrthographicCamera;
-    readonly threePersp: THREE.PerspectiveCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    private previousSize;
-    get mode(): NavigationMode;
+export declare class FragmentsManager extends Component implements Disposable {
+    static readonly uuid: "fef46874-46a3-461b-8c44-2922ab77c806";
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    readonly onFragmentsLoaded: Event<FragmentsGroup>;
+    readonly onFragmentsDisposed: Event<{
+        groupID: string;
+        fragmentIDs: string[];
+    }>;
+    /** All the created [fragments](https://github.com/ThatOpen/engine_fragment). */
+    readonly list: Map<string, Fragment>;
+    readonly groups: Map<string, FragmentsGroup>;
+    /** {@link Component.enabled} */
+    enabled: boolean;
+    baseCoordinationModel: string;
+    private _loader;
+    /** The list of meshes of the created fragments. */
+    get meshes(): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[];
     constructor(components: Components);
     /** {@link Disposable.dispose} */
     dispose(): void;
+    disposeGroup(group: FragmentsGroup): 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
+     * 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.
      */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
+    load(data: Uint8Array, config?: Partial<{
+        coordinate: boolean;
+        name: string;
+        properties: FRAGS.IfcProperties;
+        relationsMap: RelationsMap;
+    }>): FragmentsGroup;
     /**
-     * Allows or prevents all user input.
-     *
-     * @param active - whether to enable or disable user inputs.
+     * Export the specified fragments.
+     * @param group - the fragments group to be exported.
+     * @returns the exported data as binary buffer.
      */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
+    export(group: FragmentsGroup): Uint8Array;
+    coordinate(models?: FragmentsGroup[]): void;
+}
+export declare const IfcElements: {
+    [key: number]: string;
+};
+import * as WEBIFC from "web-ifc";
+export interface IfcItemsCategories {
+    [itemID: number]: number;
+}
+export declare class IfcCategories {
+    getAll(webIfc: WEBIFC.IfcAPI, modelID: number): IfcItemsCategories;
 }
 import * as FRAGS from "@thatopen/fragments";
 export declare class IfcPropertiesUtils {
@@ -965,19 +899,77 @@ export declare const IfcCategoryMap: {
     [key: number]: string;
 };
 export declare const GeometryTypes: Set<number>;
+import * as WEBIFC from "web-ifc";
+import { Components, Disposable, Event, Component } from "../../core";
+import { IfcStreamingSettings, StreamedGeometries, StreamedAsset } from "./src";
+export declare class IfcGeometryTiler extends Component implements Disposable {
+    static readonly uuid: "d9999a00-e1f5-4d3f-8cfe-c56e08609764";
+    onGeometryStreamed: Event<{
+        buffer: Uint8Array;
+        data: StreamedGeometries;
+    }>;
+    onAssetStreamed: Event<StreamedAsset[]>;
+    onProgress: Event<number>;
+    onIfcLoaded: Event<Uint8Array>;
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    settings: IfcStreamingSettings;
+    enabled: boolean;
+    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);
+    dispose(): void;
+    streamFromBuffer(data: Uint8Array): Promise<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 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 { 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 THREE from "three";
 import { Resizeable, Updateable, World, Event, Disposable } from "../../Types";
 export declare class MiniMap implements Resizeable, Updateable, Disposable {
@@ -999,52 +991,26 @@ export declare class MiniMap implements Resizeable, Updateable, Disposable {
     private _tempVector1;
     private _tempVector2;
     private _tempTarget;
-    private readonly down;
-    get lockRotation(): boolean;
-    set lockRotation(active: boolean);
-    get zoom(): number;
-    set zoom(value: number);
-    constructor(world: World);
-    dispose(): void;
-    get(): THREE.OrthographicCamera;
-    update(): void;
-    getSize(): THREE.Vector2;
-    resize(size?: THREE.Vector2): void;
-    private updatePlanes;
-}
-/**
- * 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.
-     */
-    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;
+    private readonly down;
+    get lockRotation(): boolean;
+    set lockRotation(active: boolean);
+    get zoom(): number;
+    set zoom(value: number);
+    constructor(world: World);
+    dispose(): void;
+    get(): THREE.OrthographicCamera;
+    update(): void;
+    getSize(): THREE.Vector2;
+    resize(size?: THREE.Vector2): void;
+    private updatePlanes;
+}
+import * as WEBIFC from "web-ifc";
+import { IfcItemsCategories } from "../../../ifc";
+export declare class SpatialStructure {
+    itemsByFloor: IfcItemsCategories;
+    private _units;
+    setUp(webIfc: WEBIFC.IfcAPI): void;
+    cleanUp(): void;
 }
 /**
  * Simple event handler by
@@ -1204,23 +1170,6 @@ export interface CameraControllable {
     controls: CameraControls;
 }
 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>;
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
-    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
@@ -1238,6 +1187,40 @@ export declare abstract class Component extends Base {
      */
     abstract enabled: boolean;
 }
+/**
+ * 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.
+     */
+    remove(handler: T extends void ? {
+        (): void;
+    } : {
+        (data: T): void;
+    }): void;
+    /** Triggers all the callbacks assigned to this event. */
+    trigger: (data?: T) => void;
+    /** Gets rid of all the suscribed events. */
+    reset(): void;
+    private handlers;
+}
 import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
 import { Components } from "../../Components";
 /**
@@ -1257,6 +1240,34 @@ 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>;
+    readonly onWorldChanged: Event<{
+        world: World;
+        action: "added" | "removed";
+    }>;
+    currentWorld: World | null;
+    protected constructor(components: Components);
+}
+import * as THREE from "three";
+import CameraControls from "camera-controls";
+import { BaseWorldItem } from "./base-world-item";
+import { CameraControllable } from "./interfaces";
+export declare abstract class BaseCamera extends BaseWorldItem {
+    abstract enabled: boolean;
+    abstract three: THREE.Camera;
+    abstract controls?: CameraControls;
+    /** Whether is instance is {@link CameraControllable}. */
+    hasCameraControls: () => this is CameraControllable;
+}
 import * as THREE from "three";
 import { Vector2 } from "three";
 import { Event } from "./event";
@@ -1298,30 +1309,6 @@ 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";
-export declare abstract class BaseCamera extends BaseWorldItem {
-    abstract enabled: boolean;
-    abstract three: THREE.Camera;
-    abstract controls?: CameraControls;
-    /** Whether is instance is {@link CameraControllable}. */
-    hasCameraControls: () => this is CameraControllable;
-}
-import * as THREE from "three";
-import { BaseScene } from "./base-scene";
-import { BaseCamera } from "./base-camera";
-import { BaseRenderer } from "./base-renderer";
-import { Updateable, Disposable } from "./interfaces";
-export interface World extends Disposable, Updateable {
-    meshes: Set<THREE.Mesh>;
-    scene: BaseScene;
-    camera: BaseCamera;
-    renderer: BaseRenderer | null;
-    uuid: string;
-    isDisposing: boolean;
-}
-import * as THREE from "three";
 import { Disposable } from "./interfaces";
 import { Event } from "./event";
 import { Components } from "../../Components";
@@ -1335,138 +1322,17 @@ export declare abstract class BaseScene extends BaseWorldItem implements Disposa
     dispose(): void;
 }
 import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
-/**
- * A helper to easily get the real position of the mouse in the Three.js canvas
- * to work with tools like the
- * [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has
- * been transformed through CSS or doesn't occupy the whole screen.
- */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
-    /**
-     * The real position of the mouse of the Three.js canvas.
-     */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private setupEvents;
-}
-import * as THREE from "three";
-import { Hideable, Event, World, Disposable } from "../../Types";
-import { Components } from "../../Components";
-export interface GridConfig {
-    color: THREE.Color;
-    size1: number;
-    size2: number;
-    distance: number;
-}
-/**
- * An infinite grid. Created by
- * [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper)
- * and translated to typescript by
- * [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
- */
-export declare class SimpleGrid implements Hideable, Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    world: World;
-    components: Components;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    get fade(): boolean;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    set fade(active: boolean);
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World, config: GridConfig);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
-}
-import * as THREE from "three";
-import { 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.Object3D[]): 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 { Event, Base, World, BaseScene, BaseCamera, BaseRenderer } from "../../Types";
-import { Components } from "../../Components";
-export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World {
-    /**
-     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh).
-     */
-    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
-    readonly onAfterUpdate: Event<unknown>;
-    readonly onBeforeUpdate: Event<unknown>;
-    isDisposing: boolean;
-    enabled: boolean;
-    uuid: string;
-    name?: string;
-    readonly onDisposed: Event<unknown>;
-    private _scene?;
-    private _camera?;
-    private _renderer;
-    get scene(): T;
-    set scene(scene: T);
-    get camera(): U;
-    set camera(camera: U);
-    get renderer(): S | null;
-    set renderer(renderer: S | null);
-    constructor(components: Components);
-    update(delta?: number): void;
-    dispose(disposeResources?: boolean): void;
+import { BaseScene } from "./base-scene";
+import { BaseCamera } from "./base-camera";
+import { BaseRenderer } from "./base-renderer";
+import { Updateable, Disposable } from "./interfaces";
+export interface World extends Disposable, Updateable {
+    meshes: Set<THREE.Mesh>;
+    scene: BaseScene;
+    camera: BaseCamera;
+    renderer: BaseRenderer | null;
+    uuid: string;
+    isDisposing: boolean;
 }
 import * as THREE from "three";
 import { BaseScene, Configurable, Event } from "../../Types";
@@ -1499,6 +1365,34 @@ export declare class SimpleScene extends BaseScene implements Configurable<{}> {
     setup(config?: Partial<SimpleSceneConfig>): void;
 }
 import * as THREE from "three";
+import { Event, Base, World, BaseScene, BaseCamera, BaseRenderer } from "../../Types";
+import { Components } from "../../Components";
+export declare class SimpleWorld<T extends BaseScene = BaseScene, U extends BaseCamera = BaseCamera, S extends BaseRenderer = BaseRenderer> extends Base implements World {
+    /**
+     * All the loaded [meshes](https://threejs.org/docs/#api/en/objects/Mesh).
+     */
+    readonly meshes: Set<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>;
+    readonly onAfterUpdate: Event<unknown>;
+    readonly onBeforeUpdate: Event<unknown>;
+    isDisposing: boolean;
+    enabled: boolean;
+    uuid: string;
+    name?: string;
+    readonly onDisposed: Event<unknown>;
+    private _scene?;
+    private _camera?;
+    private _renderer;
+    get scene(): T;
+    set scene(scene: T);
+    get camera(): U;
+    set camera(camera: U);
+    get renderer(): S | null;
+    set renderer(renderer: S | null);
+    constructor(components: Components);
+    update(delta?: number): void;
+    dispose(disposeResources?: boolean): void;
+}
+import * as THREE from "three";
 import { BaseRenderer, Event } from "../../Types";
 import { Components } from "../../Components";
 /**
@@ -1531,6 +1425,50 @@ export declare class SimpleRenderer extends BaseRenderer {
     private onContextBack;
 }
 import * as THREE from "three";
+import { Hideable, Event, World, Disposable } from "../../Types";
+import { Components } from "../../Components";
+export interface GridConfig {
+    color: THREE.Color;
+    size1: number;
+    size2: number;
+    distance: number;
+}
+/**
+ * An infinite grid. Created by
+ * [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper)
+ * and translated to typescript by
+ * [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
+ */
+export declare class SimpleGrid implements Hideable, Disposable {
+    /** {@link Disposable.onDisposed} */
+    readonly onDisposed: Event<unknown>;
+    world: World;
+    components: Components;
+    /** {@link Hideable.visible} */
+    get visible(): boolean;
+    /** {@link Hideable.visible} */
+    set visible(visible: boolean);
+    /** The material of the grid. */
+    get material(): THREE.ShaderMaterial;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    get fade(): boolean;
+    /**
+     * Whether the grid should fade away with distance. Recommended to be true for
+     * perspective cameras and false for orthographic cameras.
+     */
+    set fade(active: boolean);
+    readonly three: THREE.Mesh;
+    private _fade;
+    constructor(components: Components, world: World, config: GridConfig);
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private setupEvents;
+    private updateZoom;
+}
+import * as THREE from "three";
 import CameraControls from "camera-controls";
 import { Disposable, Updateable, Event, BaseCamera } from "../../Types";
 import { Components } from "../../Components";
@@ -1576,192 +1514,26 @@ export declare class SimpleCamera extends BaseCamera implements Updateable, Disp
     private setupEvents;
     private static getSubsetOfThree;
 }
-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 {
-    /** Whether to extract the IFC properties into a JSON. */
-    includeProperties: boolean;
-    /**
-     * Generate the geometry for categories that are not included by default,
-     * like IFCSPACE.
-     */
-    optionalCategories: number[];
-    /** Whether to use the coordination data coming from the IFC files. */
-    coordinate: boolean;
-    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    wasm: {
-        path: string;
-        absolute: boolean;
-        logLevel?: WEBIFC.LogLevel;
-    };
-    /** List of categories that won't be converted to fragments. */
-    excludedCategories: Set<number>;
-    /** Whether to save the absolute location of all IFC items. */
-    saveLocations: boolean;
-    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
-    webIfc: WEBIFC.LoaderSettings;
-    autoSetWasm: boolean;
-    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
-}
-import * as WEBIFC from "web-ifc";
-export declare class IfcMetadataReader {
-    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
-}
-import { IfcFragmentSettings } from "../../IfcLoader/src";
-/** 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 { AsyncEvent, Component, Disposable, Event } from "../../../core";
-import { PropertiesStreamingSettings } from "./streaming-settings";
-export declare class FragmentPropsStreamConverter 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<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 getIndices;
-    private cleanUp;
-}
-export interface StreamedGeometries {
-    [id: number]: {
-        boundingBox: Float32Array;
-        hasHoles: boolean;
-        geometryFile?: string;
-    };
-}
-export interface StreamedAsset {
-    id: number;
-    geometries: {
-        geometryID: number;
-        transformation: number[];
-        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 { 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): void;
-    /** {@link Updateable.update} */
-    update: () => void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private reset;
-    protected toggleControls(state: boolean): void;
-    private newTransformControls;
-    private initializeControls;
-    private createArrowBoundingBox;
-    private changeDrag;
-    private notifyDraggingChanged;
-    private preventCameraMovement;
-    private newHelper;
-    private static newPlaneMesh;
-}
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
- * A {@link NavigationMode} that allows first person navigation,
- * simulating FPS video games.
+ * A {@link NavigationMode} that allows to navigate floorplans in 2D,
+ * like many BIM tools.
  */
-export declare class FirstPersonMode implements NavigationMode {
+export declare class PlanMode implements NavigationMode {
     private camera;
     /** {@link NavigationMode.enabled} */
     enabled: boolean;
     /** {@link NavigationMode.id} */
-    readonly id = "FirstPerson";
+    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;
-    private setupFirstPersonCamera;
 }
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
@@ -1783,23 +1555,19 @@ export declare class OrbitMode implements NavigationMode {
 import { NavigationMode } from "./types";
 import { OrthoPerspectiveCamera } from "../index";
 /**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D,
- * like many BIM tools.
+ * A {@link NavigationMode} that allows first person navigation,
+ * simulating FPS video games.
  */
-export declare class PlanMode implements NavigationMode {
+export declare class FirstPersonMode 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;
+    readonly id = "FirstPerson";
     constructor(camera: OrthoPerspectiveCamera);
     /** {@link NavigationMode.set} */
     set(active: boolean): void;
+    private setupFirstPersonCamera;
 }
 import * as THREE from "three";
 import { CameraProjection } from "./types";
@@ -1866,6 +1634,68 @@ export interface NavigationMode {
     enabled: 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 { 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.Object3D[]): 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 { Components } from "../../Components";
 import { AsyncEvent, Event, World } from "../../Types";
 export interface CullerRendererSettings {
@@ -1961,6 +1791,176 @@ export declare class MeshCullerRenderer extends CullerRenderer {
     private handleWorkerMessage;
     private getAvailableMaterial;
 }
+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): void;
+    /** {@link Updateable.update} */
+    update: () => void;
+    /** {@link Disposable.dispose} */
+    dispose(): void;
+    private reset;
+    protected toggleControls(state: boolean): void;
+    private newTransformControls;
+    private initializeControls;
+    private createArrowBoundingBox;
+    private changeDrag;
+    private notifyDraggingChanged;
+    private preventCameraMovement;
+    private newHelper;
+    private static newPlaneMesh;
+}
+import * as WEBIFC from "web-ifc";
+/** Configuration of the IFC-fragment conversion. */
+export declare class IfcFragmentSettings {
+    /** Whether to extract the IFC properties into a JSON. */
+    includeProperties: boolean;
+    /**
+     * Generate the geometry for categories that are not included by default,
+     * like IFCSPACE.
+     */
+    optionalCategories: number[];
+    /** Whether to use the coordination data coming from the IFC files. */
+    coordinate: boolean;
+    /** Path of the WASM for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    wasm: {
+        path: string;
+        absolute: boolean;
+        logLevel?: WEBIFC.LogLevel;
+    };
+    /** List of categories that won't be converted to fragments. */
+    excludedCategories: Set<number>;
+    /** Whether to save the absolute location of all IFC items. */
+    saveLocations: boolean;
+    /** Loader settings for [web-ifc](https://github.com/ThatOpen/engine_web-ifc). */
+    webIfc: WEBIFC.LoaderSettings;
+    autoSetWasm: boolean;
+    customLocateFileHandler: WEBIFC.LocateFileHandlerFn | null;
+}
+import * as THREE from "three";
+import * as WEBIFC from "web-ifc";
+import * as FRAGS from "@thatopen/fragments";
+export declare class CivilReader {
+    defLineMat: THREE.LineBasicMaterial;
+    read(webIfc: WEBIFC.IfcAPI): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    get(civilItems: any): {
+        alignments: Map<number, FRAGS.Alignment>;
+        coordinationMatrix: THREE.Matrix4;
+    } | undefined;
+    private getCurves;
+}
+import * as WEBIFC from "web-ifc";
+export declare class IfcMetadataReader {
+    getNameInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+    getDescriptionInfo(webIfc: WEBIFC.IfcAPI): Record<string, any>;
+}
+import { IfcFragmentSettings } from "../../IfcLoader/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 interface StreamedGeometries {
+    [id: number]: {
+        boundingBox: Float32Array;
+        hasHoles: boolean;
+        geometryFile?: string;
+    };
+}
+export interface StreamedAsset {
+    id: number;
+    geometries: {
+        geometryID: number;
+        transformation: number[];
+        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 WEBIFC from "web-ifc";
+import { AsyncEvent, Component, Disposable, Event } from "../../../core";
+import { PropertiesStreamingSettings } from "./streaming-settings";
+export declare class FragmentPropsStreamConverter 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<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 getIndices;
+    private cleanUp;
+}
 export type RelationsMap = Map<number, Map<number, number[]>>;
 export interface ModelsRelationMap {
     [modelID: string]: RelationsMap;