bimatter-viewer-react 0.3.0 → 0.4.1

package/README.md

@@ -109,6 +109,16 @@ You can also load mixed model lists:
 />
 ```
 
+IFC spaces are disabled by default. Enable them per load when room volumes should be loaded as an almost-transparent gray mesh:
+
+```ts
+import { loader } from "bimatter-viewer-react";
+
+await loader.loadModel(["/models/architecture.ifc"], {
+    useIfcSpace: true,
+});
+```
+
 ## Loader API
 
 You can load models yourself and pass parsed data to the viewer:
@@ -137,6 +147,7 @@ function App() {
 ```ts
 await loader.loadModel(["/models/model.bmt"]);
 await loader.loadModel(["/models/model.ifc"]);
+await loader.loadModel(["/models/model.ifc"], { useIfcSpace: true });
 await loader.loadModel(["/models/model.bmt", "/models/model.ifc"]);
 await loader.loadModel(files);
 ```
@@ -199,6 +210,10 @@ function App() {
 
 `P` - Create clipping plane by model intersection
 
+### Dimensions
+
+`M` - Toggle dimension drawing mode
+
 ## Viewer API
 
 ```ts
@@ -214,12 +229,16 @@ viewerRef.current?.geometryUtils.isolateByIds([1, 2, 3]);
 viewerRef.current?.geometryUtils.isolateSelected();
 viewerRef.current?.geometryUtils.resetIsolation();
 viewerRef.current?.geometryUtils.getAllIds();
+viewerRef.current?.geometryUtils.setIfcSpacesVisibility(false);
+viewerRef.current?.geometryUtils.getIfcSpacesVisibility();
+viewerRef.current?.geometryUtils.toggleIIfcSpacesVisibility();
 
 viewerRef.current?.selector.setSelected(0, [10, 20], true);
 viewerRef.current?.selector.addSelected(0, [30]);
 viewerRef.current?.selector.removeSelected(0, [10]);
 viewerRef.current?.selector.resetSelection();
 viewerRef.current?.selector.getSelected();
+viewerRef.current?.selector.collector().ofType("IfcWall").toElements();
 viewerRef.current?.selector.setSelectionColor("#1194bd");
 viewerRef.current?.selector.getSelectionColor();
 viewerRef.current?.selector.setPreselectionColor("#68c6e3");
@@ -230,6 +249,17 @@ viewerRef.current?.colors.clearColor(0, [10]);
 viewerRef.current?.colors.clearModelColors(0);
 viewerRef.current?.colors.clearAllColors();
 
+viewerRef.current?.converter.convertToBmt({
+    activeView: true,
+    useMinVersion: true,
+});
+viewerRef.current?.converter.convertIfcFileToBmt(files, {
+    useIfcColors: true,
+    useIfcElementAssembly: true,
+    useIfcSpace: true,
+    useMinVersion: true,
+});
+
 viewerRef.current?.clipping.createPlane();
 viewerRef.current?.clipping.createClippingRectangle();
 viewerRef.current?.clipping.toggle();
@@ -238,8 +268,23 @@ viewerRef.current?.clipping.setEdgesActive(true);
 viewerRef.current?.clipping.setHelpersActive(true);
 viewerRef.current?.clipping.deleteAllPlanes();
 
+viewerRef.current?.dimensions.setActive(true);
+viewerRef.current?.dimensions.toggle();
+viewerRef.current?.dimensions.cancelDrawing();
+viewerRef.current?.dimensions.changeAxes();
+viewerRef.current?.dimensions.delete();
+viewerRef.current?.dimensions.deleteAll();
+viewerRef.current?.dimensions.setUnit("mm");
+viewerRef.current?.dimensions.setColor("#111827");
+viewerRef.current?.dimensions.setWidth(1);
+viewerRef.current?.dimensions.setSnapDistance(1);
+viewerRef.current?.dimensions.setEndpointScaleFactor(0.015);
+viewerRef.current?.dimensions.getDimensions();
+
 viewerRef.current?.properties.getModelProps();
 viewerRef.current?.properties.getModelStructure();
+viewerRef.current?.properties.exportExcel(0);
+viewerRef.current?.properties.exportAllExcel();
 viewerRef.current?.utils.getUserDevice();
 viewerRef.current?.utils.getDefaultHotkeysEnabled();
 viewerRef.current?.utils.setDefaultHotkeysEnabled(false);
@@ -295,6 +340,8 @@ function App() {
 }
 ```
 
+IFC space visibility is a separate mesh-level layer. When spaces are disabled through `setIfcSpacesVisibility(false)`, `showAll()` does not show them again; use `setIfcSpacesVisibility(true)` or `toggleIIfcSpacesVisibility()` for that.
+
 ## Colorize Elements
 
 Use `viewerRef.current.colors` to apply temporary color overrides to model elements. The color is applied by `modelID` and element ids:
@@ -343,6 +390,89 @@ function App() {
 }
 ```
 
+## Convert To BMT
+
+Use `viewerRef.current.converter` to export loaded models to the BMT format. With `activeView: true`, the converter uses the current viewer state and exports only visible elements.
+
+```tsx
+import { useRef } from "react";
+import { Viewer, type ViewerApi } from "bimatter-viewer-react";
+
+function downloadFiles(files: { blob: Blob; name: string }[]) {
+    files.forEach((file) => {
+        const url = URL.createObjectURL(file.blob);
+        const link = document.createElement("a");
+
+        link.href = url;
+        link.download = file.name;
+        link.click();
+        URL.revokeObjectURL(url);
+    });
+}
+
+function App() {
+    const viewerRef = useRef<ViewerApi>(null);
+
+    function convertToBmt() {
+        const result = viewerRef.current?.converter.convertToBmt({
+            activeView: true,
+            fileName: "model",
+            useMinVersion: true,
+        });
+
+        if (result) {
+            downloadFiles(result.files);
+        }
+    }
+
+    return (
+        <>
+            <button onClick={convertToBmt}>Export BMT</button>
+            <Viewer ref={viewerRef} modelUrls={["/models/model.ifc"]} />
+        </>
+    );
+}
+```
+
+Converter options:
+
+```ts
+viewerRef.current?.converter.convertToBmt({
+    activeView: true,
+    fileName: "model",
+    fileNames: {
+        0: "architecture",
+        1: "structure",
+    },
+    filterElement: ({ modelID, elementID }) => {
+        return modelID === 0 && elementID !== 10;
+    },
+    useMinVersion: true,
+});
+```
+
+`activeView` exports only currently visible elements. This includes hide/isolate state because the viewer passes the current scene state to the converter.
+
+`useMinVersion` exports `name.min.bmt` plus `name_props.json`. Without it, props and structure are written into one `.bmt` file.
+
+`fileName` sets a base name for exported files. `fileNames` sets names per `modelID`.
+
+`filterElement` is an optional custom element filter. Return `true` to keep an element in the exported BMT.
+
+IFC file conversion is also available through the same API:
+
+```ts
+await viewerRef.current?.converter.convertIfcFileToBmt(files, {
+    fileName: "converted_ifc",
+    useIfcColors: true,
+    useIfcElementAssembly: true,
+    useIfcSpace: true,
+    useMinVersion: true,
+});
+```
+
+`useIfcColors`, `useIfcElementAssembly`, and `useIfcSpace` are used when converting IFC files directly. They do not change already loaded model data in `convertToBmt`. `useIfcSpace` loads IFCSPACE geometry as a separate almost-transparent gray mesh when the IFC contains room geometry.
+
 ## Controlled Selection
 
 Selection can be controlled by your app state, including Zustand, Redux, or local React state.
@@ -364,6 +494,34 @@ function App() {
 }
 ```
 
+## Filtered Elements Collector
+
+Use `selector.collector()` to query element properties from loaded models:
+
+```tsx
+import type { IfcClass } from "bimatter-viewer-react";
+
+const wallType: IfcClass = "IfcWall";
+
+const walls = viewerRef.current?.selector
+    .collector()
+    .ofType(wallType)
+    .toElements();
+
+const basicWallIds = viewerRef.current?.selector
+    .collector()
+    .ofModel(0)
+    .ofType("IfcWall")
+    .Where((element) => element.props.Name.startsWith("basic wall"))
+    .toElementsIds();
+```
+
+Without `ofModel()`, `toElements()` returns `{ [modelID]: { elementID, props }[] }` and `toElementsIds()` returns `{ [modelID]: number[] }`.
+
+With `ofModel(0)`, `toElements()` returns `{ elementID, props }[]` and `toElementsIds()` returns `number[]`.
+
+`ofType()` accepts `IfcClass | string`, so TypeScript suggests IFC classes like `"IfcWall"` while still allowing custom type strings.
+
 ## Stats And Profiling
 
 Enable FPS stats and console timing logs:

package/lib/Loaders/BmtConverter.d.ts

@@ -0,0 +1,95 @@
+import { type Object3D } from "three";
+import type { BmtGeomData, BmtModelData } from "./BmtLoader";
+import { type IfcCoordinationMatrixSource, type IfcModelSource } from "./IFCLoader/IFCLoader";
+export type BmtConverterSource = IfcModelSource | IfcModelSource[];
+export type BmtConvertibleModels = BmtModelData | BmtModelData[] | Record<number, BmtModelData>;
+export type BmtVisibleIdsByModel = Record<string | number, Iterable<number>>;
+export type BmtActiveViewFilterParams = {
+    elementID: number;
+    geometry: BmtGeomData;
+    geometryKey: number;
+    modelID: number;
+};
+export type BmtActiveViewFilter = (params: BmtActiveViewFilterParams) => boolean;
+export type BmtConverterOptions = {
+    activeView?: boolean;
+    activeViewRoot?: Object3D | Object3D[] | null;
+    chunk?: number;
+    coordinationMatrix?: IfcCoordinationMatrixSource;
+    fileName?: string;
+    fileNames?: Record<string | number, string>;
+    filterElement?: BmtActiveViewFilter;
+    maxMeshBytes?: number;
+    useIfcColors?: boolean;
+    useIfcElementAssembly?: boolean;
+    useIfcSpace?: boolean;
+    useMinVersion?: boolean;
+    visibleIdsByModel?: BmtVisibleIdsByModel;
+    wasmPath?: string;
+};
+export type BmtConvertedFileType = "bmt" | "json";
+export type BmtConvertedFile = {
+    blob: Blob;
+    bytes: Uint8Array;
+    name: string;
+    type: BmtConvertedFileType;
+};
+export type BmtConversionResult = {
+    files: BmtConvertedFile[];
+    models: Record<number, BmtModelData>;
+};
+export declare class BmtConverter {
+    private readonly textEncoder;
+    private readonly ifcLoader;
+    ConvertIfcFileToBmt(sources: BmtConverterSource, options?: BmtConverterOptions): Promise<BmtConversionResult>;
+    convertIfcFileToBmt(sources: BmtConverterSource, options?: BmtConverterOptions): Promise<BmtConversionResult>;
+    ConvertToBmt(models: BmtConvertibleModels, options?: BmtConverterOptions): BmtConversionResult;
+    convertToBmt(models: BmtConvertibleModels, options?: BmtConverterOptions): BmtConversionResult;
+    private configureIfcLoader;
+    private normalizeModels;
+    private isBmtModelData;
+    private getFileNamesFromSources;
+    private getModelFileBaseName;
+    private normalizeBaseName;
+    private createModelFiles;
+    private createBmtBytes;
+    private writeProps;
+    private writeMeshes;
+    private createMeshPayload;
+    private writeJsonChunk;
+    private writeTextChunk;
+    private writeChunk;
+    private createSerializableModel;
+    private markIfcSpaceGeometries;
+    private markIfcSpaceGeometry;
+    private geometryHasOnlyIds;
+    private getHiddenElementIds;
+    private addGeometryElementIds;
+    private getElementFilter;
+    private filterGeometry;
+    private isValidVertexIndex;
+    private createIndexArray;
+    private filterProps;
+    private filterStructure;
+    private filterStructureNode;
+    private getStructureNodeElementID;
+    private isStructureNode;
+    private getVisibleIdsByModel;
+    private getIfcSpaceIdsByModel;
+    private addVisibleIdsFromObject3D;
+    private isReadableAttribute;
+    private isObjectVisible;
+    private isIfcSpaceObject;
+    private getObjectModelID;
+    private hasMeshMatrices;
+    private getIndexType;
+    private colorToByte;
+    private deflateTypedArray;
+    private deflateBytes;
+    private encodeText;
+    private encodePrettyJson;
+    private isRecord;
+}
+export declare const bmtConverter: BmtConverter;
+export declare function ConvertIfcFileToBmt(sources: BmtConverterSource, options?: BmtConverterOptions): Promise<BmtConversionResult>;
+export declare function ConvertToBmt(models: BmtConvertibleModels, options?: BmtConverterOptions): BmtConversionResult;

package/lib/Loaders/BmtLoader.d.ts

@@ -12,6 +12,7 @@ export interface BmtGeomData {
     pos: Float32Array;
     norm?: Float32Array;
     ind: BmtIndexArray;
+    isIfcSpace?: boolean;
     ids: Uint32Array;
     matrix?: string;
     mat: BmtMaterialData;
@@ -54,6 +55,7 @@ export interface BmtModelData {
     coordinationMatrix?: string;
     data: BmtModelGeometryData;
     grids?: ModelGridsData;
+    name?: string;
     props: BmtModelProps;
     structure: BmtModelStructure;
 }
@@ -85,10 +87,12 @@ export declare class BMTLoader {
         STRUCTURE: number;
         GRIDS: number;
         MATRIX: number;
+        MESHSPACE: number;
     };
     parseMesh(data: Uint8Array): BmtMeshData;
     private getExternalMetadataPath;
     private loadExternalMetadata;
+    private getModelNameFromPath;
     loadModel(path: string): Promise<BmtModelData>;
     parseBinaryFile(data: ArrayBuffer): BmtModelData;
 }

package/lib/Loaders/IFCLoader/IFCLoader.d.ts

@@ -21,6 +21,7 @@ export type IfcCoordinationMatrixSource = Matrix4 | number[] | string | null | u
 export declare class IFCLoader {
     useIfcElemetAssembly: boolean;
     useIfcColors: boolean;
+    useIfcSpace: boolean;
     private coordinationMatrix;
     private parser;
     private propertySerializer;
@@ -58,9 +59,11 @@ export declare class IfcParser {
     private readonly meshMatrix;
     private readonly normalMatrix;
     constructor(parser: IfcAPI, ifcModelID: number, options: IfcParserOptions);
-    parseData(allIds: Set<number>, elementsAssembly: IfcElementsAssembly | null): BmtModelData;
+    parseData(allIds: Set<number>, elementsAssembly: IfcElementsAssembly | null, includeSpaces?: boolean): BmtModelData;
+    private streamGeometryChunks;
     private applyGeometryTransformation;
     private planGeometryChunks;
+    private streamMeshes;
     private getMaterialChunkPlan;
     private deleteFlatMesh;
     private canFitInChunk;

package/lib/SelectableMesh.d.ts

@@ -4,8 +4,9 @@ import type { BmtGeomData, BmtMaterialData } from "./Loaders/BmtLoader";
 type SelectableMeshProps = {
     colorPaletteTexture: DataTexture;
     data: BmtGeomData;
+    isIfcSpace?: boolean;
     material: BmtMaterialData;
     meshMatrix: Matrix4;
 };
-export declare const SelectableMesh: React.MemoExoticComponent<({ colorPaletteTexture, material, data, meshMatrix, }: SelectableMeshProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const SelectableMesh: React.MemoExoticComponent<({ colorPaletteTexture, material, data, isIfcSpace, meshMatrix, }: SelectableMeshProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/lib/Selector/FilteredElementsCollector.d.ts

@@ -0,0 +1,38 @@
+import type * as WebIfc from "web-ifc";
+import type { BmtElementProps, BmtModelData, BmtModelProps } from "../Loaders/BmtLoader";
+type IfcClassConstructor = abstract new (...args: never[]) => unknown;
+type IfcNamespaceClassNames<TNamespace> = Extract<{
+    [Key in keyof TNamespace]: TNamespace[Key] extends IfcClassConstructor ? Key : never;
+}[keyof TNamespace], `Ifc${string}`>;
+export type IfcClass = IfcNamespaceClassNames<typeof WebIfc.IFC2X3> | IfcNamespaceClassNames<typeof WebIfc.IFC4> | IfcNamespaceClassNames<typeof WebIfc.IFC4X3>;
+export type IfcClassName = IfcClass | (string & {});
+export type FilteredElement = {
+    elementID: number;
+    props: BmtElementProps;
+};
+export type FilteredElementWithModel = FilteredElement & {
+    modelID: number;
+};
+export type FilteredElementId = number;
+export type FilteredElementsResult = Record<number, FilteredElement[]>;
+export type FilteredElementIdsResult = Record<number, number[]>;
+export type FilteredElementPredicate = (element: FilteredElementWithModel) => unknown;
+export type FilteredElementsSource = BmtModelData | BmtModelProps | Record<number, BmtModelData> | Record<number, BmtModelProps> | null | undefined;
+export declare class FilteredElementsCollector<TSingleModel extends boolean = false> {
+    private elements;
+    private filters;
+    private selectedModelIDs;
+    constructor(source?: FilteredElementsSource);
+    from(source: FilteredElementsSource): this;
+    ofType(type: IfcClassName | readonly IfcClassName[]): this;
+    ofModel(modelID: number): FilteredElementsCollector<true>;
+    ofModel(modelID: number[]): FilteredElementsCollector<false>;
+    Where(predicate: FilteredElementPredicate): this;
+    where(predicate: FilteredElementPredicate): this;
+    private getFilteredElements;
+    private hasSingleSelectedModel;
+    toElements(): TSingleModel extends true ? FilteredElement[] : FilteredElementsResult;
+    toElementsIds(): TSingleModel extends true ? number[] : FilteredElementIdsResult;
+    toElementIds(): TSingleModel extends true ? number[] : FilteredElementIdsResult;
+}
+export {};

package/lib/api/ViewerApi.d.ts

@@ -2,22 +2,30 @@ import type { ColorRepresentation } from "three";
 import type { SelectedStore, UserDevice, ViewerGridAxesVisibility, ViewerGridAxisSide, ViewerStoreApi } from "../store/ViewerStore";
 import { type ViewerPropertiesApi } from "./ViewerPropertiesApi";
 import type { ViewerClippingApi } from "../utils/ClippingUtils";
+import type { ViewerDimensionsApi } from "../utils/DimentionsUtils";
 import type { ViewerCameraGetIntersection } from "../Camera/useCameraUtils";
+import type { BmtConversionResult, BmtConverterOptions, BmtConverterSource } from "../Loaders/BmtConverter";
+import { FilteredElementsCollector } from "../Selector/FilteredElementsCollector";
 export type { ViewerClippingApi } from "../utils/ClippingUtils";
+export type { ViewerDimensionsApi } from "../utils/DimentionsUtils";
 export type { ViewerCameraGetIntersection } from "../Camera/useCameraUtils";
 export type ViewerSelection = Record<number, number[]>;
 export type ViewerGeometryUtilsApi = {
     getAllIds: () => number[];
+    getIfcSpacesVisibility: () => boolean;
     hideByIds: (ids: number[]) => void;
     hideSelected: () => void;
     isolateByIds: (ids: number[]) => void;
     isolateSelected: () => void;
     resetIsolation: () => void;
+    setIfcSpacesVisibility: (visible: boolean) => void;
     showAll: () => void;
     showByIds: (ids: number[]) => void;
+    toggleIIfcSpacesVisibility: () => void;
 };
 export type ViewerSelectorApi = {
     addSelected: (modelID: number, ids: number[]) => void;
+    collector: () => FilteredElementsCollector;
     getPreselectionColor: () => ColorRepresentation;
     getSelectionColor: () => ColorRepresentation;
     getSelected: () => ViewerSelection;
@@ -54,10 +62,17 @@ export type ViewerCameraApi = {
     fitCamera: () => void;
     getIntersection: ViewerCameraGetIntersection;
 };
+export type ViewerBmtConverterOptions = Pick<BmtConverterOptions, "activeView" | "fileName" | "fileNames" | "filterElement" | "useIfcColors" | "useIfcElementAssembly" | "useIfcSpace" | "useMinVersion">;
+export type ViewerConverterApi = {
+    convertIfcFileToBmt: (sources: BmtConverterSource, options?: ViewerBmtConverterOptions) => Promise<BmtConversionResult>;
+    convertToBmt: (options?: ViewerBmtConverterOptions) => BmtConversionResult;
+};
 export type ViewerApi = {
     camera: ViewerCameraApi;
     clipping: ViewerClippingApi;
     colors: ViewerColorsApi;
+    converter: ViewerConverterApi;
+    dimensions: ViewerDimensionsApi;
     geometryUtils: ViewerGeometryUtilsApi;
     properties: ViewerPropertiesApi;
     selector: ViewerSelectorApi;
@@ -67,6 +82,8 @@ export type ViewerSceneApi = {
     camera: ViewerCameraApi;
     clipping: ViewerClippingApi;
     colors: ViewerColorsApi;
+    converter: ViewerConverterApi;
+    dimensions: ViewerDimensionsApi;
     geometryUtils: ViewerGeometryUtilsApi;
 };
 export declare function serializeSelected(selected: SelectedStore): ViewerSelection;

package/lib/api/ViewerPropertiesApi.d.ts

@@ -1,5 +1,9 @@
 import type { ViewerModelPropsStore, ViewerModelStructureStore, ViewerStoreApi } from "../store/ViewerStore";
+import { type ExportedExcelFile, type ModelPropertiesExcelOptions } from "../utils/ExportUtils";
+export type ViewerPropertiesExcelOptions = ModelPropertiesExcelOptions;
 export type ViewerPropertiesApi = {
+    exportAllExcel: (options?: ViewerPropertiesExcelOptions) => ExportedExcelFile[];
+    exportExcel: (modelID: number, options?: ViewerPropertiesExcelOptions) => ExportedExcelFile | null;
     getModelProps: () => ViewerModelPropsStore;
     getModelStructure: () => ViewerModelStructureStore;
 };

package/lib/api/loader.d.ts

@@ -1,8 +1,12 @@
 import { type BmtModelData } from "../Loaders/BmtLoader";
 export type ViewerModelSource = string | File;
 export type ViewerLoadedModels = Record<number, BmtModelData>;
+export type ViewerLoadModelOptions = {
+    useIfcSpace?: boolean;
+};
 declare class ViewerLoaderApi {
     coordinationMatrix: string | undefined;
+    useIfcSpace: boolean;
     private bmtLoader;
     private ifcLoader;
     private loadedModelCount;
@@ -10,10 +14,12 @@ declare class ViewerLoaderApi {
     private initLoaders;
     private getBmtLoader;
     private getIfcLoader;
+    private getFileSourceMap;
+    private applyBmtMetadata;
     private loadBmtModel;
     private resetCoordinationMatrixState;
     resetCoordinationMatrix(): void;
-    loadModel(sources: ViewerModelSource | ViewerModelSource[]): Promise<ViewerLoadedModels>;
+    loadModel(sources: ViewerModelSource | ViewerModelSource[], options?: ViewerLoadModelOptions): Promise<ViewerLoadedModels>;
 }
 export declare const loader: ViewerLoaderApi;
 export {};

package/lib/index.d.ts

@@ -1,17 +1,24 @@
 export { default as Viewer } from "./Viewer";
 export type { ViewerModelsData, ViewerProps } from "./Viewer";
-export type { ViewerApi, ViewerCameraApi, ViewerCameraGetIntersection, ViewerClippingApi, ViewerColorsApi, ViewerGeometryUtilsApi, ViewerSelection, ViewerSelectorApi, ViewerUtilsApi, } from "./api/ViewerApi";
-export type { ViewerPropertiesApi } from "./api/ViewerPropertiesApi";
+export type { ViewerApi, ViewerCameraApi, ViewerCameraGetIntersection, ViewerClippingApi, ViewerColorsApi, ViewerBmtConverterOptions, ViewerConverterApi, ViewerDimensionsApi, ViewerGeometryUtilsApi, ViewerSelection, ViewerSelectorApi, ViewerUtilsApi, } from "./api/ViewerApi";
+export type { ViewerPropertiesApi, ViewerPropertiesExcelOptions, } from "./api/ViewerPropertiesApi";
 export { BMTLoader } from "./Loaders/BmtLoader";
 export type { BmtModelGeometryData, BmtGeomData, BmtIndexArray, BmtMaterialData, BmtElementProps, BmtModelData, BmtModelProps, BmtModelStructure, BmtModelStructureNode, BmtPropertyRecord, BmtPropertySet, BmtPropertyValue, } from "./Loaders/BmtLoader";
 export { IFCLoader } from "./Loaders/IFCLoader/IFCLoader";
 export type { IfcLoadedModels, IfcModelSource, } from "./Loaders/IFCLoader/IFCLoader";
+export { BmtConverter, ConvertIfcFileToBmt, ConvertToBmt, bmtConverter, } from "./Loaders/BmtConverter";
+export type { BmtActiveViewFilter, BmtActiveViewFilterParams, BmtConvertibleModels, BmtConversionResult, BmtConvertedFile, BmtConvertedFileType, BmtConverterOptions, BmtConverterSource, BmtVisibleIdsByModel, } from "./Loaders/BmtConverter";
 export { ModelGrids } from "./utils/ModelGrids";
 export type { ModelGridAxis, ModelGridData, ModelGridPoint, ModelGridsProps, ModelGridsData, } from "./utils/ModelGrids";
+export { exportExcel, exportModelPropertiesToExcel, } from "./utils/ExportUtils";
+export type { ExportedExcelFile, ExportModelSource, ModelPropertiesExcelOptions, } from "./utils/ExportUtils";
 export { loader } from "./api/loader";
-export type { ViewerLoadedModels, ViewerModelSource } from "./api/loader";
+export type { ViewerLoadedModels, ViewerLoadModelOptions, ViewerModelSource, } from "./api/loader";
+export { FilteredElementsCollector } from "./Selector/FilteredElementsCollector";
+export type { FilteredElement, FilteredElementId, FilteredElementIdsResult, FilteredElementPredicate, FilteredElementsResult, FilteredElementsSource, FilteredElementWithModel, IfcClass, IfcClassName, } from "./Selector/FilteredElementsCollector";
 export { NavigationCube } from "./utils/NavigationCube";
+export { DimensionLine, DimensionsUtils, useDimensionsUtils, type DimensionUnit, } from "./utils/DimentionsUtils";
 export { createViewerStore } from "./store/ViewerStore";
 export { ViewerStoreProvider } from "./store/ViewerStoreProvider";
 export { useViewerStore, useViewerStoreApi } from "./store/useViewerStore";
-export type { SelectedStore, UserDevice, ViewerGridAxesVisibility, ViewerGridAxisSide, ViewerModelPropsStore, ViewerModelStructureStore, ViewerStore, ViewerStoreApi, } from "./store/ViewerStore";
+export type { SelectedStore, UserDevice, ViewerGridAxesVisibility, ViewerGridAxisSide, ViewerModelNamesStore, ViewerModelPropsStore, ViewerModelStructureStore, ViewerStore, ViewerStoreApi, } from "./store/ViewerStore";