brepjs-bim 0.1.0

package/dist/model/bimModel.d.ts

@@ -0,0 +1,151 @@
+import { Result } from 'brepjs';
+import { LocalId } from '../identity/localId.js';
+import { BimError } from '../errors/bimError.js';
+import { AnyBimElement, BimElement } from '../types/bimTypes.js';
+import { BimRelationship } from '../types/relationships.js';
+import { ClassificationRef } from '../types/classificationTypes.js';
+import { WallSpec } from '../specs/wallSpec.js';
+import { SlabSpec } from '../specs/slabSpec.js';
+import { BeamSpec } from '../specs/beamSpec.js';
+import { ColumnSpec } from '../specs/columnSpec.js';
+import { DoorSpec, WindowSpec, SlabOpeningInput } from '../specs/openingSpec.js';
+import { ProxySpec } from '../specs/proxySpec.js';
+import { SpaceSpec } from '../specs/spaceSpec.js';
+import { RoofSpec } from '../specs/roofSpec.js';
+import { CurtainWallSpec } from '../specs/curtainWallSpec.js';
+import { FootingSpec, PileSpec } from '../specs/foundationSpec.js';
+import { StairSpec } from '../specs/stairSpec.js';
+import { RampSpec } from '../specs/rampSpec.js';
+import { RailingSpec } from '../specs/railingSpec.js';
+import { CoveringSpec } from '../specs/coveringSpec.js';
+import { ElementAssemblySpec } from '../specs/assemblySpec.js';
+import { ZoneSpec, SystemSpec } from '../specs/groupSpec.js';
+import { SurfaceStyleSpec } from '../ifc-writer/styleWriter.js';
+import { ProjectSpec, SiteSpec, BuildingSpec, StoreySpec } from '../specs/spatialSpec.js';
+export declare class BimModel {
+    #private;
+    init(spec: ProjectSpec): Result<LocalId, BimError>;
+    [Symbol.dispose](): void;
+    addSite(spec: SiteSpec): LocalId;
+    addBuilding(spec: BuildingSpec): LocalId;
+    addStorey(spec: StoreySpec): LocalId;
+    addWall(spec: WallSpec): Result<LocalId, BimError>;
+    addSlab(spec: SlabSpec): Result<LocalId, BimError>;
+    addBeam(spec: BeamSpec): Result<LocalId, BimError>;
+    addColumn(spec: ColumnSpec): Result<LocalId, BimError>;
+    addSpace(spec: SpaceSpec): Result<LocalId, BimError>;
+    addRoof(spec: RoofSpec): Result<LocalId, BimError>;
+    addCurtainWall(spec: CurtainWallSpec): Result<LocalId, BimError>;
+    addFooting(spec: FootingSpec): Result<LocalId, BimError>;
+    addPile(spec: PileSpec): Result<LocalId, BimError>;
+    /**
+     * Adds an IfcStair assembly. Geometry for each flight is built and written by
+     * the IFC layer from `spec.flights`; the STAIR element itself carries no solid
+     * (the assembly container's Representation is null, valid per IFC4).
+     */
+    addStair(spec: StairSpec): Result<LocalId, BimError>;
+    /**
+     * Adds an IfcRamp assembly. Geometry for each flight is built and written by the
+     * IFC layer from `spec.flights`; the RAMP element carries no solid of its own.
+     */
+    addRamp(spec: RampSpec): Result<LocalId, BimError>;
+    addRailing(spec: RailingSpec): Result<LocalId, BimError>;
+    /**
+     * Adds an IfcCovering. When `hostLocalId` is supplied, an
+     * IfcRelCoversBldgElements linking the covering to its host (e.g. a slab it
+     * finishes) is recorded for export.
+     */
+    addCovering(spec: CoveringSpec, hostLocalId?: LocalId): Result<LocalId, BimError>;
+    /**
+     * Adds an IfcElementAssembly grouping container. The assembly has no geometry;
+     * attach parts with {@link aggregate} (IfcRelAggregates) or {@link nest}
+     * (IfcRelNests, order-preserving). Returns the assembly's localId.
+     */
+    addElementAssembly(spec: ElementAssemblySpec): LocalId;
+    /**
+     * Adds an IfcZone grouping object (a thermal/fire/occupancy zone). The zone
+     * carries no geometry; attach members (spaces or other elements) with
+     * {@link assignToGroup}. Returns the zone's localId.
+     */
+    addZone(spec: ZoneSpec): LocalId;
+    /**
+     * Adds an IfcSystem grouping object (an HVAC/electrical/plumbing system). The
+     * system carries no geometry; attach members with {@link assignToGroup}.
+     * Returns the system's localId.
+     */
+    addSystem(spec: SystemSpec): LocalId;
+    /**
+     * Assigns members to a zone or system via IfcRelAssignsToGroup. Repeated calls
+     * for the same group extend the single relationship in call order. Returns the
+     * relationship's localId.
+     */
+    assignToGroup(groupId: LocalId, memberIds: readonly LocalId[]): LocalId;
+    /**
+     * Records an order-preserving IfcRelNests decomposing `parentId` into
+     * `childId`. Unlike {@link aggregate}, repeated calls extend the same nesting
+     * relationship in call order.
+     */
+    nest(parentId: LocalId, childId: LocalId): void;
+    /**
+     * Records an IfcRelConnectsElements logical connection between two elements.
+     * Returns the relationship's localId.
+     */
+    connectElements(relatingElementLocalId: LocalId, relatedElementLocalId: LocalId, description?: string): LocalId;
+    /**
+     * Records an IfcRelConnectsPathElements connection between two path-based
+     * elements at the given path ends. Returns the relationship's localId.
+     */
+    connectPathElements(relatingElementLocalId: LocalId, relatedElementLocalId: LocalId, relatingConnectionType: 'ATSTART' | 'ATEND' | 'ATPATH' | 'NOTDEFINED', relatedConnectionType: 'ATSTART' | 'ATEND' | 'ATPATH' | 'NOTDEFINED', description?: string): LocalId;
+    /**
+     * Assigns a surface style (colour + transparency) to an element. On export the
+     * style is emitted as IfcSurfaceStyle and linked to the element's body geometry
+     * via IfcStyledItem (currently honoured for railings and coverings, whose body
+     * representation item is surfaced by their geometry writers).
+     */
+    setSurfaceStyle(elementLocalId: LocalId, style: SurfaceStyleSpec): void;
+    getSurfaceStyle(elementLocalId: LocalId): SurfaceStyleSpec | null;
+    /**
+     * Records an IfcRelSpaceBoundary between a space and one of its bounding
+     * building elements. Returns the relationship's localId.
+     */
+    addSpaceBoundary(spaceLocalId: LocalId, elementLocalId: LocalId, connectionType?: 'PHYSICAL' | 'VIRTUAL' | 'NOTDEFINED'): LocalId;
+    /**
+     * Associates a classification reference with one or more elements, creating an
+     * IfcRelAssociatesClassification on export. Returns the relationship's localId.
+     */
+    addClassification(ref: ClassificationRef, elementLocalIds: readonly LocalId[]): LocalId;
+    /**
+     * Adds an IfcBuildingElementProxy. The model TAKES OWNERSHIP of `spec.solid`
+     * and disposes it on model disposal; the caller must not dispose it (see
+     * {@link ProxySpec.solid}).
+     */
+    addProxy(spec: ProxySpec): Result<LocalId, BimError>;
+    addDoor(spec: DoorSpec): Result<LocalId, BimError>;
+    addWindow(spec: WindowSpec): Result<LocalId, BimError>;
+    addSlabOpening(input: SlabOpeningInput): Result<LocalId, BimError>;
+    getDoors(): BimElement<'DOOR'>[];
+    getWindows(): BimElement<'WINDOW'>[];
+    aggregate(parentId: LocalId, childId: LocalId): void;
+    placeIn(elementId: LocalId, containerId: LocalId): void;
+    getProject(): BimElement<'PROJECT'> | null;
+    getElement(id: LocalId): AnyBimElement | null;
+    getWalls(): BimElement<'WALL'>[];
+    getSlabs(): BimElement<'SLAB'>[];
+    getBeams(): BimElement<'BEAM'>[];
+    getColumns(): BimElement<'COLUMN'>[];
+    getProxies(): BimElement<'PROXY'>[];
+    getSpaces(): BimElement<'SPACE'>[];
+    getRoofs(): BimElement<'ROOF'>[];
+    getCurtainWalls(): BimElement<'CURTAIN_WALL'>[];
+    getFootings(): BimElement<'FOOTING'>[];
+    getPiles(): BimElement<'PILE'>[];
+    getStairs(): BimElement<'STAIR'>[];
+    getRamps(): BimElement<'RAMP'>[];
+    getRailings(): BimElement<'RAILING'>[];
+    getCoverings(): BimElement<'COVERING'>[];
+    getElementAssemblies(): BimElement<'ELEMENT_ASSEMBLY'>[];
+    getZones(): BimElement<'ZONE'>[];
+    getSystems(): BimElement<'SYSTEM'>[];
+    getAllElements(): AnyBimElement[];
+    getAllRelationships(): BimRelationship[];
+}

package/dist/psets/psetTemplates.d.ts

@@ -0,0 +1,41 @@
+/**
+ * IFC measure types used by the standard Pset_*Common property sets.
+ * Each maps to a web-ifc defined-type constant via {@link webIfcConstantFor}.
+ */
+export type PsetMeasureType = 'IFCBOOLEAN' | 'IFCIDENTIFIER' | 'IFCLABEL' | 'IFCTEXT' | 'IFCREAL' | 'IFCINTEGER' | 'IFCLENGTHMEASURE' | 'IFCPOSITIVELENGTHMEASURE' | 'IFCAREAMEASURE' | 'IFCVOLUMEMEASURE' | 'IFCRATIOMEASURE' | 'IFCPOSITIVERATIOMEASURE' | 'IFCPLANEANGLEMEASURE' | 'IFCTHERMALTRANSMITTANCEMEASURE';
+/** The element categories that carry a standard Pset_*Common set. */
+export type PsetCategory = 'WALL' | 'SLAB' | 'BEAM' | 'COLUMN' | 'DOOR' | 'WINDOW' | 'SPACE' | 'ROOF' | 'CURTAIN_WALL' | 'FOOTING' | 'PILE' | 'STAIR' | 'RAMP' | 'RAILING' | 'COVERING';
+interface SingleValueTemplate {
+    readonly name: string;
+    readonly measureType: PsetMeasureType;
+    readonly kind: 'single';
+}
+interface EnumeratedValueTemplate {
+    readonly name: string;
+    readonly measureType: PsetMeasureType;
+    readonly kind: 'enumerated';
+    /** Legal values for the enumeration, in canonical IFC order. */
+    readonly enumValues: readonly string[];
+}
+export type PsetPropertyTemplate = SingleValueTemplate | EnumeratedValueTemplate;
+export interface PsetTemplate {
+    readonly psetName: string;
+    readonly properties: readonly PsetPropertyTemplate[];
+}
+/**
+ * Per-property IFC measure type for every property appearing in the standard
+ * Pset_*Common sets. The psetWriter consults this to emit the correct measure
+ * type instead of the legacy everything-is-IFCREAL heuristic. Properties absent
+ * from this table have no standard measure type and the writer falls back to its
+ * JS-type heuristic.
+ */
+export declare const PSET_PROPERTY_TYPE_TABLE: Readonly<Record<string, PsetMeasureType>>;
+/** Standard Pset_*Common template keyed by element category. */
+export declare const PSET_TEMPLATES: Readonly<Record<PsetCategory, PsetTemplate>>;
+/** Looks up the standard IFC measure type for a Pset property name. */
+export declare function measureTypeFor(propertyName: string): PsetMeasureType | undefined;
+/** Resolves a measure type to its web-ifc defined-type constant. */
+export declare function webIfcConstantFor(measureType: PsetMeasureType): number;
+/** Returns the standard Pset_*Common template for an element category. */
+export declare function templateFor(category: PsetCategory): PsetTemplate;
+export {};

package/dist/psets/qtoWeights.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Indicative material bulk densities in kg/m³, keyed by lowercase material name.
+ * These are nominal values for deriving an analytic IfcQuantityWeight from a
+ * solid volume; they are not authoritative engineering figures. Callers that
+ * need precise densities should pass an explicit value rather than relying on
+ * this lookup table.
+ */
+export declare const MATERIAL_DENSITY_KG_M3: Readonly<Record<string, number>>;
+/** The subset of the IfcWriter surface needed to emit a single quantity line. */
+export interface QtoWeightWriter {
+    nextId(): number;
+    mkType(type: number, value: unknown): Record<string, unknown>;
+    writeLine(entity: {
+        expressID: number;
+    } & Record<string, unknown>): number;
+}
+/**
+ * Resolves a nominal bulk density (kg/m³) for a material name, case-insensitive.
+ * Returns `undefined` when the name is not in {@link MATERIAL_DENSITY_KG_M3}.
+ */
+export declare function densityFor(materialName: string): number | undefined;
+/**
+ * Computes mass in kilograms from a solid volume (m³) and a bulk density
+ * (kg/m³). This is the analytic basis for the emitted IfcQuantityWeight value.
+ */
+export declare function computeWeightKg(volumeM3: number, densityKgM3: number): number;
+/**
+ * Emits an IfcQuantityWeight whose WeightValue is `volumeM3 * densityKgM3`
+ * expressed as an IfcMassMeasure (kg). Returns the express id of the written
+ * quantity; callers collect these into an IfcElementQuantity set.
+ */
+export declare function writeWeightQuantity(w: QtoWeightWriter, name: string, volumeM3: number, densityKgM3: number): number;

package/dist/serialize/toIfc.d.ts

@@ -0,0 +1,19 @@
+import { BimModel } from '../model/bimModel.js';
+import { BimModelMeta } from '../ifc-writer/headerWriter.js';
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+import { ValidationReport } from '../validation/severity.js';
+export declare function toIfc(model: BimModel, meta: BimModelMeta): Promise<Result<Uint8Array, BimError>>;
+export interface ValidatedIfcResult {
+    readonly bytes: Uint8Array;
+    readonly report: ValidationReport;
+}
+/**
+ * Serializes the model to IFC and runs the full validation suite: a
+ * pre-serialization referential-integrity gate, then the post-save EXPRESS/STEP
+ * schema gate and the write→read→re-write round-trip check. Returns both the
+ * bytes and a combined report. A model that fails the integrity gate returns an
+ * INTEGRITY_FAILURE BimError without serializing (unlike plain {@link toIfc},
+ * which serializes unconditionally).
+ */
+export declare function toIfcValidated(model: BimModel, meta: BimModelMeta): Promise<Result<ValidatedIfcResult, BimError>>;

package/dist/specs/assemblySpec.d.ts

@@ -0,0 +1,15 @@
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+export type AssemblyPredefinedType = 'ACCESSORY_ASSEMBLY' | 'ARCH' | 'BEAM_GRID' | 'BRACED_FRAME' | 'GIRDER' | 'REINFORCEMENT_UNIT' | 'RIGID_FRAME' | 'SLAB_FIELD' | 'TRUSS' | 'USERDEFINED' | 'NOTDEFINED';
+export type AssemblyPlace = 'SITE' | 'FACTORY' | 'NOTDEFINED';
+/**
+ * A grouping container (IfcElementAssembly). Carries no geometry of its own;
+ * parts are attached via {@link BimModel.aggregate} (IfcRelAggregates) or
+ * {@link BimModel.nest} (IfcRelNests, order-preserving).
+ */
+export interface ElementAssemblySpec {
+    readonly name?: string | undefined;
+    readonly predefinedType?: AssemblyPredefinedType | undefined;
+    readonly assemblyPlace?: AssemblyPlace | undefined;
+}
+export declare function parseElementAssemblySpec(input: unknown): Result<ElementAssemblySpec, BimError>;

package/dist/specs/beamSpec.d.ts

@@ -0,0 +1,34 @@
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+import { Profile } from './profile.js';
+import { MaterialLayer } from '../types/materialTypes.js';
+import { ClassificationRef } from '../types/classificationTypes.js';
+export type BeamPredefinedType = 'BEAM' | 'JOIST' | 'LINTEL' | 'HOLLOWCORE' | 'PURLIN' | 'RAFTER' | 'SPANDREL' | 'T_BEAM' | 'NOTDEFINED';
+export interface BeamSpec {
+    readonly length: number;
+    readonly profile: Profile;
+    readonly origin: [number, number, number];
+    readonly axisX: [number, number, number];
+    readonly axisZ: [number, number, number];
+    readonly predefinedType?: BeamPredefinedType | undefined;
+    readonly materialName: string;
+    readonly isExternal?: boolean | undefined;
+    readonly loadBearing?: boolean | undefined;
+    readonly fireRating?: string | undefined;
+    readonly acousticRating?: string | undefined;
+    readonly thermalTransmittance?: number | undefined;
+    readonly status?: string | undefined;
+    /**
+     * When present, the beam is associated via a layered IfcMaterialLayerSet built
+     * from these layers instead of the bare `materialName` IfcMaterial.
+     */
+    readonly materialLayers?: readonly MaterialLayer[] | undefined;
+    readonly layerSetName?: string | undefined;
+    /** When present, associates the beam with an external classification code. */
+    readonly classification?: ClassificationRef | undefined;
+    readonly manufacturerName?: string | undefined;
+    readonly manufacturerModel?: string | undefined;
+    readonly manufacturerProductionYear?: number | undefined;
+    readonly customProperties?: Readonly<Record<string, Readonly<Record<string, string | number | boolean>>>> | undefined;
+}
+export declare function parseBeamSpec(input: unknown): Result<BeamSpec, BimError>;

package/dist/specs/columnSpec.d.ts

@@ -0,0 +1,34 @@
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+import { Profile } from './profile.js';
+import { MaterialLayer } from '../types/materialTypes.js';
+import { ClassificationRef } from '../types/classificationTypes.js';
+export type ColumnPredefinedType = 'COLUMN' | 'PILASTER' | 'NOTDEFINED';
+export interface ColumnSpec {
+    readonly height: number;
+    readonly profile: Profile;
+    readonly origin: [number, number, number];
+    readonly axisX: [number, number, number];
+    readonly axisZ: [number, number, number];
+    readonly predefinedType?: ColumnPredefinedType | undefined;
+    readonly materialName: string;
+    readonly isExternal?: boolean | undefined;
+    readonly loadBearing?: boolean | undefined;
+    readonly fireRating?: string | undefined;
+    readonly acousticRating?: string | undefined;
+    readonly thermalTransmittance?: number | undefined;
+    readonly status?: string | undefined;
+    /**
+     * When present, the column is associated via a layered IfcMaterialLayerSet
+     * built from these layers instead of the bare `materialName` IfcMaterial.
+     */
+    readonly materialLayers?: readonly MaterialLayer[] | undefined;
+    readonly layerSetName?: string | undefined;
+    /** When present, associates the column with an external classification code. */
+    readonly classification?: ClassificationRef | undefined;
+    readonly manufacturerName?: string | undefined;
+    readonly manufacturerModel?: string | undefined;
+    readonly manufacturerProductionYear?: number | undefined;
+    readonly customProperties?: Readonly<Record<string, Readonly<Record<string, string | number | boolean>>>> | undefined;
+}
+export declare function parseColumnSpec(input: unknown): Result<ColumnSpec, BimError>;

package/dist/specs/coveringSpec.d.ts

@@ -0,0 +1,33 @@
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+import { MaterialLayer } from '../types/materialTypes.js';
+import { ClassificationRef } from '../types/classificationTypes.js';
+export type CoveringPredefinedType = 'CEILING' | 'FLOORING' | 'CLADDING' | 'ROOFING' | 'MOLDING' | 'SKIRTINGBOARD' | 'INSULATION' | 'MEMBRANE' | 'SLEEVING' | 'WRAPPING' | 'NOTDEFINED';
+/**
+ * A thin rectangular covering sheet (floor finish, ceiling, cladding panel).
+ * All dimensions in mm. The footprint rectangle (length × width) lies in the
+ * local XY plane and extrudes along local +Z by `thickness`.
+ * origin/axisX/axisZ position the covering in world space via IfcLocalPlacement.
+ */
+export interface CoveringSpec {
+    readonly length: number;
+    readonly width: number;
+    readonly thickness: number;
+    readonly origin: [number, number, number];
+    readonly axisX: [number, number, number];
+    readonly axisZ: [number, number, number];
+    readonly predefinedType?: CoveringPredefinedType | undefined;
+    readonly materialName: string;
+    readonly isExternal?: boolean | undefined;
+    readonly fireRating?: string | undefined;
+    readonly thermalTransmittance?: number | undefined;
+    readonly status?: string | undefined;
+    readonly materialLayers?: readonly MaterialLayer[] | undefined;
+    readonly layerSetName?: string | undefined;
+    readonly classification?: ClassificationRef | undefined;
+    readonly manufacturerName?: string | undefined;
+    readonly manufacturerModel?: string | undefined;
+    readonly manufacturerProductionYear?: number | undefined;
+    readonly customProperties?: Readonly<Record<string, Readonly<Record<string, string | number | boolean>>>> | undefined;
+}
+export declare function parseCoveringSpec(input: unknown): Result<CoveringSpec, BimError>;

package/dist/specs/curtainWallSpec.d.ts

@@ -0,0 +1,37 @@
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+import { ClassificationRef } from '../types/classificationTypes.js';
+export type CurtainWallPredefinedType = 'CURTAIN_WALL' | 'NOTDEFINED' | 'USERDEFINED';
+/**
+ * A planar curtain wall, modelled as a rectangular grid of glazing panels
+ * (IfcPlate) framed by mullions (IfcMember). The wall spans `width` (along the
+ * local X axis) by `height` (local Z), and is subdivided into `columns` × `rows`
+ * panels. Mullions run along every internal and boundary grid line.
+ *
+ * All dimensions in mm. Geometry is unplaced template geometry built in the
+ * local XY/XZ plane; origin/axisX/axisZ place the assembly in world space via
+ * IfcLocalPlacement.
+ */
+export interface CurtainWallSpec {
+    readonly width: number;
+    readonly height: number;
+    readonly columns: number;
+    readonly rows: number;
+    readonly panelThickness: number;
+    readonly mullionWidth: number;
+    readonly mullionDepth: number;
+    readonly origin: [number, number, number];
+    readonly axisX: [number, number, number];
+    readonly axisZ: [number, number, number];
+    readonly materialName: string;
+    readonly predefinedType?: CurtainWallPredefinedType | undefined;
+    readonly panelMaterialName?: string | undefined;
+    readonly mullionMaterialName?: string | undefined;
+    readonly isExternal?: boolean | undefined;
+    readonly fireRating?: string | undefined;
+    readonly thermalTransmittance?: number | undefined;
+    readonly status?: string | undefined;
+    readonly classification?: ClassificationRef | undefined;
+    readonly customProperties?: Readonly<Record<string, Readonly<Record<string, string | number | boolean>>>> | undefined;
+}
+export declare function parseCurtainWallSpec(input: unknown): Result<CurtainWallSpec, BimError>;

package/dist/specs/foundationSpec.d.ts

@@ -0,0 +1,50 @@
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+import { Profile } from './profile.js';
+import { MaterialLayer } from '../types/materialTypes.js';
+import { ClassificationRef } from '../types/classificationTypes.js';
+export type FootingPredefinedType = 'CAISSON_FOUNDATION' | 'FOOTING_BEAM' | 'PAD_FOOTING' | 'PILE_CAP' | 'STRIP_FOOTING' | 'NOTDEFINED';
+export type PilePredefinedType = 'BORED' | 'DRIVEN' | 'JETGROUTING' | 'NOTDEFINED';
+export type PileConstructionType = 'CAST_IN_PLACE' | 'COMPOSITE' | 'PRECAST_CONCRETE' | 'PREFAB_STEEL';
+export interface FootingSpec {
+    readonly length: number;
+    readonly width: number;
+    readonly thickness: number;
+    readonly origin: [number, number, number];
+    readonly axisX: [number, number, number];
+    readonly axisZ: [number, number, number];
+    readonly predefinedType?: FootingPredefinedType | undefined;
+    readonly materialName: string;
+    readonly isExternal?: boolean | undefined;
+    readonly loadBearing?: boolean | undefined;
+    readonly fireRating?: string | undefined;
+    readonly status?: string | undefined;
+    /**
+     * When present, the footing is associated via a layered IfcMaterialLayerSet
+     * built from these layers instead of the bare `materialName` IfcMaterial.
+     */
+    readonly materialLayers?: readonly MaterialLayer[] | undefined;
+    readonly layerSetName?: string | undefined;
+    /** When present, associates the footing with an external classification code. */
+    readonly classification?: ClassificationRef | undefined;
+    readonly customProperties?: Readonly<Record<string, Readonly<Record<string, string | number | boolean>>>> | undefined;
+}
+export interface PileSpec {
+    readonly length: number;
+    readonly profile: Profile;
+    readonly origin: [number, number, number];
+    readonly axisX: [number, number, number];
+    readonly axisZ: [number, number, number];
+    readonly predefinedType?: PilePredefinedType | undefined;
+    readonly constructionType?: PileConstructionType | undefined;
+    readonly materialName: string;
+    readonly loadBearing?: boolean | undefined;
+    readonly status?: string | undefined;
+    readonly materialLayers?: readonly MaterialLayer[] | undefined;
+    readonly layerSetName?: string | undefined;
+    /** When present, associates the pile with an external classification code. */
+    readonly classification?: ClassificationRef | undefined;
+    readonly customProperties?: Readonly<Record<string, Readonly<Record<string, string | number | boolean>>>> | undefined;
+}
+export declare function parseFootingSpec(input: unknown): Result<FootingSpec, BimError>;
+export declare function parsePileSpec(input: unknown): Result<PileSpec, BimError>;

package/dist/specs/groupSpec.d.ts

@@ -0,0 +1,27 @@
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+/**
+ * A spatial zone — an IfcZone grouping spaces (or other zones) that share a
+ * functional purpose such as a thermal, fire, or occupancy zone. Membership is
+ * established separately via an ASSIGNS_TO_GROUP relationship referencing the
+ * member localIds; the zone itself carries no geometry.
+ */
+export interface ZoneSpec {
+    readonly name: string;
+    readonly longName?: string | undefined;
+    readonly description?: string | undefined;
+    readonly objectType?: string | undefined;
+}
+/**
+ * A system — an IfcSystem grouping elements that together provide a service
+ * (HVAC supply, electrical circuit, plumbing run). Like a zone, the system is a
+ * pure grouping object; members are linked via an ASSIGNS_TO_GROUP relationship.
+ */
+export interface SystemSpec {
+    readonly name: string;
+    readonly longName?: string | undefined;
+    readonly description?: string | undefined;
+    readonly objectType?: string | undefined;
+}
+export declare function parseZoneSpec(input: unknown): Result<ZoneSpec, BimError>;
+export declare function parseSystemSpec(input: unknown): Result<SystemSpec, BimError>;

package/dist/specs/materialSpec.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+/**
+ * Shared Zod schemas for the optional material-layer and classification fields
+ * that element specs (wall/slab/beam/column) accept. Centralised here so every
+ * spec validates these fields identically.
+ */
+export declare const MaterialLayerSchema: z.ZodObject<{
+    name: z.ZodString;
+    thicknessMm: z.ZodNumber;
+    isVentilated: z.ZodOptional<z.ZodBoolean>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ClassificationRefSchema: z.ZodObject<{
+    system: z.ZodString;
+    edition: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodString>;
+    code: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/specs/openingSpec.d.ts

@@ -0,0 +1,42 @@
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+import { LocalId } from '../identity/localId.js';
+/** A door opening in a wall. All dimensions in mm. */
+export interface DoorSpec {
+    readonly width: number;
+    readonly height: number;
+    readonly offsetAlongWall: number;
+    readonly offsetFromFloor: number;
+    readonly wallLocalId: LocalId;
+    readonly materialName: string;
+    readonly isExternal?: boolean | undefined;
+    readonly fireRating?: string | undefined;
+    readonly acousticRating?: string | undefined;
+}
+/** A window opening in a wall. All dimensions in mm. */
+export interface WindowSpec {
+    readonly width: number;
+    readonly height: number;
+    readonly offsetAlongWall: number;
+    readonly offsetFromFloor: number;
+    readonly wallLocalId: LocalId;
+    readonly materialName: string;
+    readonly isExternal?: boolean | undefined;
+    readonly fireRating?: string | undefined;
+    readonly acousticRating?: string | undefined;
+    readonly thermalTransmittance?: number | undefined;
+}
+export declare function parseDoorSpec(input: unknown): Result<DoorSpec, BimError>;
+export declare function parseWindowSpec(input: unknown): Result<WindowSpec, BimError>;
+/**
+ * Input for BimModel.addSlabOpening — a vertical through-hole in a slab.
+ * All dimensions in mm, offsets in the slab's local XY frame.
+ */
+export interface SlabOpeningInput {
+    readonly sizeX: number;
+    readonly sizeY: number;
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly slabLocalId: LocalId;
+}
+export declare function parseSlabOpeningInput(input: unknown): Result<SlabOpeningInput, BimError>;

package/dist/specs/profile.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import { BimError } from '../errors/bimError.js';
+import { Result } from 'brepjs';
+import { ExtendedProfile, extendedProfileToFace } from './profilesExtended.js';
+export type RectangularProfile = {
+    readonly kind: 'RECTANGULAR';
+    readonly width: number;
+    readonly height: number;
+};
+export type CircularProfile = {
+    readonly kind: 'CIRCULAR';
+    readonly radius: number;
+};
+export type IShapeProfile = {
+    readonly kind: 'I_BEAM';
+    readonly overallWidth: number;
+    readonly overallDepth: number;
+    readonly flangeThickness: number;
+    readonly webThickness: number;
+};
+export type CoreProfile = RectangularProfile | CircularProfile | IShapeProfile;
+export type Profile = CoreProfile | ExtendedProfile;
+/** Narrows a profile to the extended (non-core) variants. */
+export declare function isExtendedProfile(profile: Profile): profile is ExtendedProfile;
+export declare const ProfileSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"RECTANGULAR">;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"CIRCULAR">;
+    radius: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"I_BEAM">;
+    overallWidth: z.ZodNumber;
+    overallDepth: z.ZodNumber;
+    flangeThickness: z.ZodNumber;
+    webThickness: z.ZodNumber;
+}, z.core.$strip>], "kind">, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"L_SHAPE">;
+    depth: z.ZodNumber;
+    width: z.ZodNumber;
+    legThickness: z.ZodNumber;
+    filletRadius: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"T_SHAPE">;
+    depth: z.ZodNumber;
+    flangeWidth: z.ZodNumber;
+    webThickness: z.ZodNumber;
+    flangeThickness: z.ZodNumber;
+    filletRadius: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"U_SHAPE">;
+    depth: z.ZodNumber;
+    flangeWidth: z.ZodNumber;
+    webThickness: z.ZodNumber;
+    flangeThickness: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"Z_SHAPE">;
+    depth: z.ZodNumber;
+    flangeWidth: z.ZodNumber;
+    webThickness: z.ZodNumber;
+    flangeThickness: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"C_SHAPE">;
+    depth: z.ZodNumber;
+    width: z.ZodNumber;
+    wallThickness: z.ZodNumber;
+    girth: z.ZodNumber;
+    internalFilletRadius: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ASYMMETRIC_I">;
+    overallDepth: z.ZodNumber;
+    webThickness: z.ZodNumber;
+    topFlangeWidth: z.ZodNumber;
+    topFlangeThickness: z.ZodNumber;
+    bottomFlangeWidth: z.ZodNumber;
+    bottomFlangeThickness: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ELLIPSE">;
+    semiAxis1: z.ZodNumber;
+    semiAxis2: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"TRAPEZIUM">;
+    bottomXDim: z.ZodNumber;
+    topXDim: z.ZodNumber;
+    yDim: z.ZodNumber;
+    topXOffset: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"RECTANGLE_HOLLOW">;
+    xDim: z.ZodNumber;
+    yDim: z.ZodNumber;
+    wallThickness: z.ZodNumber;
+    innerFilletRadius: z.ZodOptional<z.ZodNumber>;
+    outerFilletRadius: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"CIRCLE_HOLLOW">;
+    radius: z.ZodNumber;
+    wallThickness: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ARBITRARY_CLOSED">;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ARBITRARY_WITH_VOIDS">;
+    outerPoints: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    voids: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+}, z.core.$strip>], "kind">]>;
+export declare function parseProfile(input: unknown): Result<Profile, BimError>;
+export { extendedProfileToFace };