brepjs-bim 0.1.0

package/dist/import/dataRead.d.ts

@@ -0,0 +1,65 @@
+import { SpfReader } from './spfReader.js';
+type Primitive = string | number | boolean;
+/** A read-back property set or element-quantity set keyed by property name. */
+export interface ImportedPset {
+    readonly name: string;
+    /** `true` when sourced from an IfcElementQuantity rather than an IfcPropertySet. */
+    readonly isQuantity: boolean;
+    readonly properties: Readonly<Record<string, Primitive>>;
+    /** IFC measure/value type code (web-ifc `type`) per property, where known. */
+    readonly measureTypes: Readonly<Record<string, number>>;
+}
+export interface ImportedMaterial {
+    readonly kind: 'SIMPLE' | 'LAYER_SET';
+    readonly name: string;
+    readonly layers?: readonly {
+        readonly name: string;
+        readonly thicknessMm: number;
+    }[] | undefined;
+}
+export interface ImportedClassification {
+    readonly system: string;
+    readonly code: string;
+    readonly description?: string | undefined;
+}
+export interface VoidRelation {
+    readonly openingExpressId: number;
+    readonly fillerExpressId?: number | undefined;
+}
+export interface ImportedOwnerHistory {
+    readonly applicationName: string;
+    readonly creationDate?: number | undefined;
+}
+/**
+ * Reads every property/quantity set associated with an element via
+ * IfcRelDefinesByProperties. IfcPropertySet definitions yield
+ * `isQuantity: false`; IfcElementQuantity definitions yield `isQuantity: true`.
+ * Per-property measure-type codes are captured in {@link ImportedPset.measureTypes}.
+ */
+export declare function readPsets(reader: SpfReader, elementExpressId: number): ImportedPset[];
+/**
+ * Reads the material associated with an element via IfcRelAssociatesMaterial.
+ * Bare IfcMaterial yields `kind: 'SIMPLE'`; IfcMaterialLayerSet(Usage) yields
+ * `kind: 'LAYER_SET'` with the per-layer name and thickness (mm). Returns the
+ * first association found, or null.
+ */
+export declare function readMaterial(reader: SpfReader, elementExpressId: number, scale: number): ImportedMaterial | null;
+/**
+ * Reads the classification associated with an element via
+ * IfcRelAssociatesClassification. The reference's Identification is the code, its
+ * ReferencedSource's Name is the system, and its Name is the description.
+ * Returns the first association found, or null.
+ */
+export declare function readClassification(reader: SpfReader, elementExpressId: number): ImportedClassification | null;
+/**
+ * Reads the openings that void an element via IfcRelVoidsElement, pairing each
+ * with the filler element (door/window) supplied through IfcRelFillsElement when
+ * present.
+ */
+export declare function readVoids(reader: SpfReader, elementExpressId: number): VoidRelation[];
+/**
+ * Reads IfcOwnerHistory metadata: the owning application's full name and the
+ * creation timestamp. Returns null if the line or application cannot be read.
+ */
+export declare function readOwnerHistory(reader: SpfReader, ownerHistoryExpressId: number): ImportedOwnerHistory | null;
+export {};

package/dist/import/fromIfc.d.ts

@@ -0,0 +1,24 @@
+import { Result } from 'brepjs';
+import { BimError } from '../errors/bimError.js';
+import { ImportedModel } from './importedModel.js';
+export type { ImportedModel } from './importedModel.js';
+export interface FromIfcOptions {
+    /** Activate web-ifc's large-coordinate recentering on open. Default false. */
+    readonly coordinateToOrigin?: boolean | undefined;
+    /** Skip body-geometry reconstruction for fast metadata-only reads. Default false. */
+    readonly skipGeometry?: boolean | undefined;
+}
+/**
+ * Reads an IFC STEP-SPF byte buffer into an {@link ImportedModel}: schema, unit
+ * scale, spatial tree, and one {@link ImportedElement} per physical product
+ * (geometry + Psets + material + classification + void/fill relations).
+ *
+ * Robustness model: every per-element reconstruction is wrapped in try/catch; a
+ * failure pushes a diagnostic (severity `error` if the element could not be read
+ * at all, `warning`/`info` for partial geometry) and the import continues. Only
+ * fatal failures — bad bytes, unsupported schema, WASM open failure — return
+ * `err`. Inspect {@link ImportedModel.diagnostics} for per-element quality.
+ *
+ * The web-ifc model handle is always closed in a `finally` block.
+ */
+export declare function fromIfc(bytes: Uint8Array, options?: FromIfcOptions): Promise<Result<ImportedModel, BimError>>;

package/dist/import/geometryRead.d.ts

@@ -0,0 +1,41 @@
+import { Result, ValidSolid } from 'brepjs';
+import { BimError } from '../errors/bimError.js';
+import { Profile } from '../specs/profile.js';
+import { ValidationIssue } from '../validation/severity.js';
+import { SpfReader } from './spfReader.js';
+/**
+ * Outcome of reconstructing a single product's body geometry.
+ *
+ * - `SOLID` — a brepjs ValidSolid was rebuilt (parametrically from a swept
+ *   solid, or by a manifold STL round-trip of a tessellated mesh).
+ * - `MESH` — geometry exists but could not be turned into a closed solid;
+ *   raw triangle data is returned and flagged lossy via `diagnostic`.
+ * - `NONE` — the product carries no recognised body representation.
+ */
+export type GeometryResult = {
+    readonly kind: 'SOLID';
+    readonly solid: ValidSolid;
+    readonly lossy: boolean;
+} | {
+    readonly kind: 'MESH';
+    readonly vertices: Float32Array;
+    readonly indices: Uint32Array;
+    readonly diagnostic: string;
+} | {
+    readonly kind: 'NONE';
+};
+/**
+ * Reconstructs the `Body` (SweptSolid) representation of a product into a brepjs
+ * solid, falling back to tessellated mesh import when no parametric path exists.
+ *
+ * `scale` is metres-per-file-unit (1.0 for METRE files); all reconstructed
+ * dimensions are converted to mm via `scale * 1000`. Per-item failures push a
+ * diagnostic onto `diagnostics` and yield `NONE` rather than throwing, so a
+ * single bad element never aborts a model import.
+ */
+export declare function readBodyGeometry(reader: SpfReader, productExpressId: number, scale: number, diagnostics: ValidationIssue[]): GeometryResult;
+/**
+ * Reads an IfcProfileDef into a brepjs Profile (mm). Mirrors the writer's
+ * profile-def emission (geometryWriter.writeProfile / profileDefWriter).
+ */
+export declare function readProfileDef(reader: SpfReader, profileExpressId: number, scale: number): Result<Profile, BimError>;

package/dist/import/importedModel.d.ts

@@ -0,0 +1,95 @@
+import { ValidSolid } from 'brepjs';
+import { ValidationReport } from '../validation/severity.js';
+import { IfcGuid } from '../identity/ifcGuid.js';
+import { ImportedSchema } from './spfReader.js';
+export type { ImportedSchema } from './spfReader.js';
+/**
+ * How faithfully a product's body geometry was reconstructed:
+ * - `PARAMETRIC` — rebuilt losslessly from a swept solid (extrude/revolve).
+ * - `TESSELLATED_MANIFOLD` — a tessellated mesh was recovered as a closed solid
+ *   via an STL round-trip; geometrically faithful but topology was re-derived.
+ * - `TESSELLATED_LOSSY` — geometry exists only as raw triangles (mesh did not
+ *   close into a solid); `solid` is null, `meshVertices`/`meshIndices` carry it.
+ * - `NONE` — no recognised body representation was found.
+ */
+export type GeometryFidelity = 'PARAMETRIC' | 'TESSELLATED_MANIFOLD' | 'TESSELLATED_LOSSY' | 'NONE';
+export interface ImportedGeometry {
+    readonly fidelity: GeometryFidelity;
+    /** The reconstructed solid; null when fidelity is `NONE` or `TESSELLATED_LOSSY`. */
+    readonly solid: ValidSolid | null;
+    /** Raw triangle vertices (interleaved xyz), present only for `TESSELLATED_LOSSY`. */
+    readonly meshVertices?: Float32Array | undefined;
+    /** Raw triangle indices, present only for `TESSELLATED_LOSSY`. */
+    readonly meshIndices?: Uint32Array | undefined;
+}
+export interface ImportedPset {
+    readonly name: string;
+    /** `true` when sourced from an IfcElementQuantity rather than an IfcPropertySet. */
+    readonly isQuantity: boolean;
+    readonly properties: Readonly<Record<string, string | number | boolean>>;
+    /**
+     * Per-property IFC measure-type codes (web-ifc type constants), keyed by the
+     * same property name as `properties`. Lets callers distinguish e.g. an
+     * IfcThermalTransmittanceMeasure from a plain IfcReal. Absent entries fall back
+     * to the value's JS type.
+     */
+    readonly measureTypes: Readonly<Record<string, number>>;
+}
+export interface ImportedMaterial {
+    readonly kind: 'SIMPLE' | 'LAYER_SET';
+    readonly name: string;
+    readonly layers?: readonly {
+        readonly name: string;
+        readonly thicknessMm: number;
+    }[] | undefined;
+}
+export interface ImportedClassification {
+    readonly system: string;
+    readonly code: string;
+    readonly description?: string | undefined;
+}
+export type ImportedElementCategory = 'WALL' | 'SLAB' | 'BEAM' | 'COLUMN' | 'DOOR' | 'WINDOW' | 'OPENING' | 'SPACE' | 'ROOF' | 'CURTAIN_WALL' | 'FOOTING' | 'PILE' | 'STAIR' | 'RAMP' | 'RAILING' | 'COVERING' | 'ELEMENT_ASSEMBLY' | 'PROXY';
+export interface ImportedElement {
+    readonly expressId: number;
+    readonly guid: IfcGuid;
+    readonly name: string;
+    readonly category: ImportedElementCategory;
+    readonly predefinedType?: string | undefined;
+    readonly storeyExpressId?: number | undefined;
+    readonly geometry: ImportedGeometry;
+    readonly psets: readonly ImportedPset[];
+    readonly material: ImportedMaterial | null;
+    readonly classification: ImportedClassification | null;
+    /** Express ids of opening elements that void this element. */
+    readonly voidedBy: readonly number[];
+    /** Express id of the opening this element fills (doors/windows only). */
+    readonly fills?: number | undefined;
+}
+export interface ImportedSpatialNode {
+    readonly expressId: number;
+    readonly guid: IfcGuid;
+    readonly name: string;
+    readonly category: 'PROJECT' | 'SITE' | 'BUILDING' | 'STOREY';
+    readonly elevationMm?: number | undefined;
+    readonly children: readonly ImportedSpatialNode[];
+    readonly containedElements: readonly number[];
+}
+/**
+ * Frees every reconstructed solid handle held by an imported model. The
+ * geometry are live WASM handles, so callers MUST call this once they are done
+ * with the model (it is not reclaimed automatically when the model is GC'd).
+ */
+export declare function disposeImportedModel(model: ImportedModel): void;
+/**
+ * The reconstructed model. Holds live WASM solid handles in `elements[].geometry`;
+ * call {@link disposeImportedModel} when finished to avoid leaking them.
+ */
+export interface ImportedModel {
+    readonly schema: ImportedSchema;
+    readonly spatialTree: ImportedSpatialNode | null;
+    readonly elements: readonly ImportedElement[];
+    /** Express id → ImportedElement for fast lookup. */
+    readonly byExpressId: ReadonlyMap<number, ImportedElement>;
+    readonly diagnostics: ValidationReport;
+    readonly applicationName?: string | undefined;
+}

package/dist/import/placement.d.ts

@@ -0,0 +1,89 @@
+import { SpfReader } from './spfReader.js';
+/**
+ * Column-major 4x4 transform, matching the layout web-ifc and OCCT use:
+ * column c, row r lives at index c*4 + r. Columns 0-2 are the basis vectors
+ * (axisX, axisY, axisZ); column 3 is the translation; the bottom row is
+ * [0,0,0,1].
+ */
+export type Mat4x4 = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export type Vec3 = readonly [number, number, number];
+/** A placement decomposed into origin + the two stored IFC axes (Z, X). */
+export interface WorldPlacement {
+    /** Translation in millimetres (file units scaled to mm). */
+    readonly origin: Vec3;
+    /** Local X direction in world space (IFC RefDirection), unit length. */
+    readonly axisX: Vec3;
+    /** Local Z direction in world space (IFC Axis), unit length. */
+    readonly axisZ: Vec3;
+}
+/** Georeferencing offset recovered from IfcMapConversion, in millimetres. */
+export interface Georef {
+    readonly eastings: number;
+    readonly northings: number;
+    readonly orthogonalHeight: number;
+    /** Rotation of true north relative to model +X, in radians. */
+    readonly rotation: number;
+}
+/**
+ * Metres-per-file-unit length scale read from the IfcUnitAssignment's
+ * LENGTHUNIT. Multiply a file-unit length by this to get metres, then by 1000
+ * for brepjs millimetres. Returns 1.0 (assume metres) when no length unit is
+ * declared.
+ */
+export declare function readLengthScale(reader: SpfReader): number;
+/**
+ * Radians-per-file-unit plane-angle scale read from the IfcUnitAssignment's
+ * PLANEANGLEUNIT (1 for RADIAN, ~0.0174533 for DEGREE). Defaults to 1 (the IFC
+ * default plane-angle unit is the radian).
+ */
+export declare function readPlaneAngleScale(reader: SpfReader): number;
+/**
+ * Composes the full IfcLocalPlacement chain rooted at `placementExpressId` into
+ * a column-major world matrix, scaling translations to millimetres via `scale`
+ * (metres-per-file-unit). Returns null if the placement cannot be resolved.
+ *
+ * Walks `PlacementRelTo` recursively and pre-multiplies each parent transform,
+ * mirroring how the writer nests element → storey → building → site → project.
+ * This is independent of the geometry engine, so it is unaffected by the
+ * COORDINATE_TO_ORIGIN recenter flag.
+ */
+export declare function composeWorldMatrix(reader: SpfReader, placementExpressId: number, scale: number): Mat4x4 | null;
+/**
+ * Composes the placement chain and returns it decomposed into origin + axes,
+ * the form spec reconstruction consumes. Returns null on failure.
+ */
+export declare function composeWorldPlacement(reader: SpfReader, placementExpressId: number, scale: number): WorldPlacement | null;
+/**
+ * Reads a single IfcAxis2Placement3D into a column-major matrix. Location is
+ * scaled to mm; Axis (local Z) and RefDirection (local X) default to +Z/+X and
+ * are orthonormalised (local Y = Z × X, local X = Y × Z) so the basis is
+ * always a proper rotation.
+ */
+export declare function readAxis2Placement3D(reader: SpfReader, placementExpressId: number, scale: number): Mat4x4 | null;
+/** Decomposes a column-major matrix into origin (mm) + IFC axes (Z, X). */
+export declare function decomposePlacement(m: Mat4x4): WorldPlacement;
+export declare function identityMatrix(): Mat4x4;
+/**
+ * Reads the IfcMapConversion georeferencing offset (Eastings/Northings/
+ * OrthogonalHeight, scaled to mm) and true-north rotation. Returns null when
+ * the model carries no IfcMapConversion. Use this to recenter far-from-origin
+ * coordinates: subtract the offset to bring geometry near the origin.
+ */
+export declare function readGeoref(reader: SpfReader, scale: number): Georef | null;

package/dist/import/spatialTree.d.ts

@@ -0,0 +1,35 @@
+import { SpfReader } from './spfReader.js';
+/**
+ * A reconstructed spatial-structure node. The tree mirrors the IFC spatial
+ * containment hierarchy (`IfcProject → IfcSite → IfcBuilding → IfcBuildingStorey`)
+ * rebuilt from `IfcRelAggregates`, with physical elements attached to their
+ * storey via `IfcRelContainedInSpatialStructure`.
+ *
+ * Nodes are addressable by {@link SpatialNode.guid} (the IFC `GlobalId`).
+ */
+export interface SpatialNode {
+    readonly expressId: number;
+    readonly guid: string;
+    readonly name: string;
+    readonly category: 'PROJECT' | 'SITE' | 'BUILDING' | 'STOREY';
+    /** Storey elevation in mm; present on `STOREY` nodes only. */
+    readonly elevation?: number | undefined;
+    readonly children: readonly SpatialNode[];
+    /** Express ids of elements contained directly in this node. */
+    readonly containedElements: readonly number[];
+}
+/**
+ * Reconstructs the spatial-structure tree from `IfcRelAggregates` and attaches
+ * contained elements via `IfcRelContainedInSpatialStructure`. Walks top-down
+ * from the single `IfcProject`. Returns `null` when no `IfcProject` is present.
+ *
+ * @param scale metres-per-file-unit; storey elevations are scaled to mm as
+ *   `Elevation × scale × 1000` to match the `BimModel` input contract.
+ */
+export declare function buildSpatialTree(reader: SpfReader, scale: number): SpatialNode | null;
+/**
+ * Returns a flat map of element express id → containing spatial-structure
+ * express id, built from every `IfcRelContainedInSpatialStructure` line. When
+ * an element appears in multiple containment relations, the last one wins.
+ */
+export declare function buildElementContainmentMap(reader: SpfReader): Map<number, number>;

package/dist/import/spfReader.d.ts

@@ -0,0 +1,55 @@
+import { FlatMesh, IfcGeometry } from 'web-ifc';
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+/** Schema strings web-ifc reports and this reader supports. */
+export type ImportedSchema = 'IFC2X3' | 'IFC4' | 'IFC4X3';
+export interface SpfReaderSettings {
+    /**
+     * Activate web-ifc's built-in large-coordinate recentering on open. Defaults
+     * to false; set true for georeferenced models with far-from-origin geometry.
+     */
+    readonly coordinateToOrigin?: boolean;
+}
+export declare class SpfReader {
+    #private;
+    readonly schema: ImportedSchema;
+    readonly modelId: number;
+    private constructor();
+    static create(bytes: Uint8Array, settings?: SpfReaderSettings): Promise<Result<SpfReader, BimError>>;
+    /** Always issues CloseModel; safe to call more than once. */
+    close(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Raw line object for an express id. With `flatten=false` (default) references
+     * appear as `{ type, value }` wrappers and nested entities are not resolved;
+     * pass `flatten=true` to recursively inline referenced lines.
+     */
+    getLine<T = unknown>(expressId: number, flatten?: boolean): T | null;
+    /** Express ids of every line whose type equals `type` (no inherited types). */
+    getLinesOfType(type: number): number[];
+    /** Express ids of every line in the model. */
+    getAllLines(): number[];
+    /** IFC type code for an express id. */
+    getLineType(expressId: number): number;
+    /** Builds web-ifc's internal GUID→expressId index; call before guid lookups. */
+    buildGuidMap(): void;
+    /** expressId for a GlobalId, or undefined. Requires {@link buildGuidMap} first. */
+    expressIdFromGuid(guid: string): number | undefined;
+    /** GlobalId for an express id, or undefined. Requires {@link buildGuidMap} first. */
+    guidFromExpressId(expressId: number): string | undefined;
+    /**
+     * Composed world transform (column-major 16-float matrix) for a placement
+     * express id, resolving the full IfcLocalPlacement chain.
+     */
+    getWorldTransform(placementExpressId: number): number[];
+    /** Streams placed meshes for the given product express ids. */
+    streamMeshes(expressIds: number[], cb: (mesh: FlatMesh, index: number, total: number) => void): void;
+    /** Geometry buffers for a geometry express id; caller MUST call `.delete()`. */
+    getGeometry(geometryExpressId: number): IfcGeometry;
+    /** Reads a Float32Array view of vertex data from a WASM pointer. */
+    getVertexArray(ptr: number, size: number): Float32Array;
+    /** Reads a Uint32Array view of index data from a WASM pointer. */
+    getIndexArray(ptr: number, size: number): Uint32Array;
+    /** Decodes IFC STEP string escapes (`\X2\`, `\S\`, `\X\`) in a raw value. */
+    decodeText(s: string): string;
+}

package/dist/index.d.ts

@@ -0,0 +1,95 @@
+export { BimModel } from './model/bimModel.js';
+export { toIfc, toIfcValidated } from './serialize/toIfc.js';
+export type { ValidatedIfcResult } from './serialize/toIfc.js';
+export { fromIfc } from './import/fromIfc.js';
+export { disposeImportedModel } from './import/importedModel.js';
+export type { FromIfcOptions } from './import/fromIfc.js';
+export { SpfReader } from './import/spfReader.js';
+export type { SpfReaderSettings } from './import/spfReader.js';
+export { parseWallSpec } from './specs/wallSpec.js';
+export { parseSlabSpec } from './specs/slabSpec.js';
+export { parseBeamSpec } from './specs/beamSpec.js';
+export { parseColumnSpec } from './specs/columnSpec.js';
+export { parseProfile, isExtendedProfile } from './specs/profile.js';
+export { extendedProfileToFace, extendedProfileArea } from './specs/profilesExtended.js';
+export { parseSpaceSpec } from './specs/spaceSpec.js';
+export { parseRoofSpec } from './specs/roofSpec.js';
+export { parseCurtainWallSpec } from './specs/curtainWallSpec.js';
+export { parseFootingSpec, parsePileSpec } from './specs/foundationSpec.js';
+export { parseStairSpec, parseStairFlightSpec } from './specs/stairSpec.js';
+export { parseRampSpec, parseRampFlightSpec } from './specs/rampSpec.js';
+export { parseRailingSpec } from './specs/railingSpec.js';
+export { parseCoveringSpec } from './specs/coveringSpec.js';
+export { parseElementAssemblySpec } from './specs/assemblySpec.js';
+export { parseZoneSpec, parseSystemSpec } from './specs/groupSpec.js';
+export { parseSurfaceStyleSpec } from './specs/styleSpec.js';
+export { parseDoorSpec, parseWindowSpec, parseSlabOpeningInput } from './specs/openingSpec.js';
+export { newIfcGuid, isValidIfcGuid } from './identity/ifcGuid.js';
+export { deriveIfcGuid, deriveIfcGuidSync } from './identity/guidDerivation.js';
+export { makeLocalIdCounter } from './identity/localId.js';
+export { checkReferentialIntegrity } from './validation/referentialIntegrity.js';
+export { checkSchema } from './validation/schemaCheck.js';
+export { checkRoundTrip } from './validation/roundTrip.js';
+export { checkGeometryValidity } from './validation/geometryValidity.js';
+export { issue, emptyReport, hasErrors, countBySeverity, } from './validation/severity.js';
+export { writeIfcType } from './ifc-writer/typeWriter.js';
+export { writeZoneEntity, writeSystemEntity, writeRelAssignsToGroup, } from './ifc-writer/groupWriter.js';
+export { IFC_SCHEMAS, DEFAULT_IFC_SCHEMA, fileSchemaString, isIfcSchema, schemaSupports, } from './ifc-writer/schemaVersion.js';
+export { writeElementAssemblyEntity, writeRelAggregatesElements, writeRelNests, } from './ifc-writer/assemblyWriter.js';
+export { writeSurfaceStyle, writeStyledItem, writePresentationLayer, } from './ifc-writer/styleWriter.js';
+export { writeRelConnectsElements, writeRelConnectsPathElements, } from './ifc-writer/connectivityWriter.js';
+export { writeMaterialLayerSet, writeMaterialProfileSet, writeMaterialSimple, } from './ifc-writer/materialWriter.js';
+export { writeClassificationRefs } from './ifc-writer/classificationWriter.js';
+export { PSET_TEMPLATES, PSET_PROPERTY_TYPE_TABLE, measureTypeFor, templateFor, } from './psets/psetTemplates.js';
+export { DEFAULT_UNITS, toLengthMm, toIfcLengthM } from './units/units.js';
+export { specError, ifcError, geometryError, fromBrepError } from './errors/bimError.js';
+export type { WallSpec } from './specs/wallSpec.js';
+export type { SlabSpec, SlabPredefinedType } from './specs/slabSpec.js';
+export type { BeamSpec, BeamPredefinedType } from './specs/beamSpec.js';
+export type { ColumnSpec, ColumnPredefinedType } from './specs/columnSpec.js';
+export type { Profile, CoreProfile, RectangularProfile, CircularProfile, IShapeProfile, } from './specs/profile.js';
+export type { ExtendedProfile, LShapeProfile, TShapeProfile, UShapeProfile, ZShapeProfile, CShapeProfile, AsymmetricIShapeProfile, EllipseProfile, TrapeziumProfile, RectangleHollowProfile, CircleHollowProfile, ArbitraryClosedProfile, ArbitraryProfileWithVoids, } from './specs/profilesExtended.js';
+export type { SpaceSpec, SpacePredefinedType } from './specs/spaceSpec.js';
+export type { RoofSpec, RoofPredefinedType } from './specs/roofSpec.js';
+export type { CurtainWallSpec, CurtainWallPredefinedType } from './specs/curtainWallSpec.js';
+export type { CurtainWallGrid, CurtainWallComponent } from './elementFns/curtainWallFns.js';
+export type { FootingSpec, PileSpec, FootingPredefinedType, PilePredefinedType, PileConstructionType, } from './specs/foundationSpec.js';
+export type { StairSpec, StairFlightSpec, StairPredefinedType, } from './specs/stairSpec.js';
+export type { RampSpec, RampFlightSpec, RampPredefinedType, RampFlightPredefinedType, } from './specs/rampSpec.js';
+export type { RailingSpec, RailingPredefinedType } from './specs/railingSpec.js';
+export type { CoveringSpec, CoveringPredefinedType } from './specs/coveringSpec.js';
+export type { ElementAssemblySpec, AssemblyPredefinedType, AssemblyPlace, } from './specs/assemblySpec.js';
+export type { ZoneSpec, SystemSpec } from './specs/groupSpec.js';
+export type { SurfaceStyleSpec } from './specs/styleSpec.js';
+export type { AssemblyPlaceIfc, ElementAssemblyPredefinedTypeIfc, } from './ifc-writer/assemblyWriter.js';
+export type { PathConnectionTypeIfc } from './ifc-writer/connectivityWriter.js';
+export type { DoorSpec, WindowSpec, SlabOpeningInput } from './specs/openingSpec.js';
+export type { ProxySpec } from './specs/proxySpec.js';
+export type { ProjectSpec, SiteSpec, BuildingSpec, StoreySpec } from './specs/spatialSpec.js';
+export type { BimCategory, BimElement, AnyBimElement, OpeningSpec, WallOpeningSpec, SlabOpeningSpec } from './types/bimTypes.js';
+export { isWallOpening, isSlabOpening } from './types/bimTypes.js';
+export type { BimRelationship, AssociatesMaterialRel, AssociatesClassificationRel, VoidsWallRel, VoidsSlabRel, FillsOpeningRel, SpaceBoundaryRel, NestsRel, ConnectsElementsRel, ConnectsPathElementsRel, CoversElementRel, AssignsToGroupRel, } from './types/relationships.js';
+export type { MaterialLayer } from './types/materialTypes.js';
+export type { MaterialLayerSetSpec, MaterialProfileSpec, MaterialSpec, } from './ifc-writer/materialWriter.js';
+export type { ClassificationRef } from './types/classificationTypes.js';
+export type { PsetCategory, PsetMeasureType, PsetTemplate, PsetPropertyTemplate, } from './psets/psetTemplates.js';
+export { importError } from './errors/bimError.js';
+export type { BimError, BimErrorKind } from './errors/bimError.js';
+export type { ImportedModel, ImportedSchema, ImportedElement, ImportedElementCategory, ImportedGeometry, GeometryFidelity, ImportedPset, ImportedMaterial, ImportedClassification, ImportedSpatialNode, } from './import/importedModel.js';
+export type { IfcGuid } from './identity/ifcGuid.js';
+export type { LocalId, LocalIdCounter } from './identity/localId.js';
+export type { UnitSystem, LengthUnit } from './units/units.js';
+export type { BimModelMeta } from './ifc-writer/headerWriter.js';
+export type { ValidationSeverity, ValidationIssue, ValidationReport, SeverityCounts, } from './validation/severity.js';
+export type { ModelGraph, IntegrityInput } from './validation/referentialIntegrity.js';
+export type { RoundTripReport, EntityCounts } from './validation/roundTrip.js';
+export type { IfcTypeName, TypeWriteResult } from './ifc-writer/typeWriter.js';
+export type { IfcSchema } from './ifc-writer/schemaVersion.js';
+export type { OwnerHistoryAuthor, OwnerHistoryMeta } from './ifc-writer/ownerHistoryWriter.js';
+export { deriveCobieModel, deriveCobieModel as exportCobie, serializeCobieToCsv, serializeCobieToJson, } from './cobie/index.js';
+export type { CobieModel, CobieJson, CobieExportMeta, CobieContactMeta, CobieContactRow, CobieFacilityRow, CobieFloorRow, CobieSpaceRow, CobieZoneRow, CobieTypeRow, CobieComponentRow, CobieSystemRow, CobieAttributeRow, } from './cobie/index.js';
+export { parseIdsXml, checkModelAgainstIds, checkModelAgainstIds as checkIds, } from './ids/index.js';
+export type { IdsDocument, IdsSpecification, IdsFacet, IdsRestriction, IdsCardinality, IdsCheckReport, IdsCheckResult, } from './ids/index.js';
+export { serializeBcfFiles, parseBcfFiles } from './bcf/index.js';
+export type { BcfColoring, BcfComment, BcfComponent, BcfComponents, BcfContainerData, BcfFiles, BcfProject, BcfTopic, BcfVersion, BcfViewpoint, BcfVisibility, } from './bcf/index.js';
+export { bcfError, idsError } from './errors/bimError.js';