brepjs-bim 0.1.0

package/dist/cobie/cobieExport.d.ts

@@ -0,0 +1,20 @@
+import { BimModel } from '../model/bimModel.js';
+import { CobieModel, CobieExportMeta, CobieJson } from './cobieTypes.js';
+/**
+ * Derives a {@link CobieModel} from an in-memory {@link BimModel}, reading only
+ * its public getters. The derivation is a single O(N) pass that mirrors the
+ * spatial-tree and type-layer conventions of {@link toIfc} so that COBie
+ * Component/Type names line up with the exported IFC.
+ *
+ * Optional element categories from later phases (ZONE, SYSTEM) are picked up
+ * generically when present; their absence is not an error.
+ */
+export declare function deriveCobieModel(model: BimModel, meta?: CobieExportMeta): CobieModel;
+/**
+ * Serializes a {@link CobieModel} to CSV — one sheet per COBie table, keyed by
+ * sheet name. Each sheet is a CRLF-delimited RFC 4180 document with a header row
+ * followed by one row per record.
+ */
+export declare function serializeCobieToCsv(model: CobieModel): Map<string, string>;
+/** Serializes a {@link CobieModel} to a JSON object — one array per sheet. */
+export declare function serializeCobieToJson(model: CobieModel): CobieJson;

package/dist/cobie/cobieTypes.d.ts

@@ -0,0 +1,130 @@
+/**
+ * COBie (Construction-Operations Building information exchange) table row types.
+ *
+ * Each interface models one COBie sheet. Column names follow the COBie 2.4
+ * spreadsheet schema (camelCased). Rows are derived from a {@link BimModel} by
+ * {@link deriveCobieModel}; the resulting {@link CobieModel} is a pure value
+ * object that can be serialized to CSV or JSON.
+ *
+ * Several required-but-not-yet-modelled COBie columns (CreatedBy, CreatedOn,
+ * Category) are emitted as empty strings rather than omitted, because COBie
+ * validators expect the columns to be present. The fields that brepjs-bim can
+ * populate from a {@link BimModel} carry real data.
+ */
+/** Minimal contact metadata used to populate the COBie Contact sheet. */
+export interface CobieContactMeta {
+    readonly email?: string | undefined;
+    readonly givenName?: string | undefined;
+    readonly familyName?: string | undefined;
+    readonly organizationName?: string | undefined;
+    readonly company?: string | undefined;
+    readonly phone?: string | undefined;
+}
+/** Optional metadata consumed by {@link deriveCobieModel}. */
+export interface CobieExportMeta {
+    readonly contact?: CobieContactMeta | undefined;
+}
+export interface CobieContactRow {
+    /** COBie Contact key — the contact's email address. */
+    readonly email: string;
+    readonly givenName: string;
+    readonly familyName: string;
+    readonly company: string;
+    readonly phone: string;
+}
+export interface CobieFacilityRow {
+    readonly name: string;
+    readonly createdBy: string;
+    readonly category: string;
+    readonly projectName: string;
+    readonly siteName: string;
+    readonly description: string;
+    /** IfcProject GlobalId. */
+    readonly externalIdentifier: string;
+}
+export interface CobieFloorRow {
+    readonly name: string;
+    readonly createdBy: string;
+    readonly category: string;
+    readonly description: string;
+    readonly elevation: number;
+    /** IfcBuildingStorey GlobalId. */
+    readonly externalIdentifier: string;
+}
+export interface CobieSpaceRow {
+    readonly name: string;
+    readonly createdBy: string;
+    readonly category: string;
+    /** Name of the Floor this space sits on (resolved via the spatial tree). */
+    readonly floorName: string;
+    readonly description: string;
+    readonly roomTag: string;
+    /** IfcSpace GlobalId. */
+    readonly externalIdentifier: string;
+}
+export interface CobieZoneRow {
+    readonly name: string;
+    readonly createdBy: string;
+    readonly category: string;
+    /** Name of a space that is a member of this zone. */
+    readonly spaceName: string;
+    readonly externalIdentifier: string;
+}
+export interface CobieTypeRow {
+    readonly name: string;
+    readonly createdBy: string;
+    readonly category: string;
+    readonly description: string;
+    readonly assetType: string;
+}
+export interface CobieComponentRow {
+    readonly name: string;
+    readonly createdBy: string;
+    /** Name of the Type row this component is an occurrence of. */
+    readonly typeName: string;
+    /** Name of the Space this component is contained in, when resolvable. */
+    readonly space: string;
+    readonly description: string;
+    /** Element GlobalId. */
+    readonly externalIdentifier: string;
+}
+export interface CobieSystemRow {
+    readonly name: string;
+    readonly createdBy: string;
+    readonly category: string;
+    /** Name of a component that is a member of this system. */
+    readonly componentNames: string;
+    readonly externalIdentifier: string;
+}
+export interface CobieAttributeRow {
+    readonly name: string;
+    readonly createdBy: string;
+    /** Name of the sheet row this attribute belongs to (e.g. a component name). */
+    readonly sheetName: string;
+    readonly rowName: string;
+    readonly value: string;
+}
+/** All populated COBie sheets derived from a model. */
+export interface CobieModel {
+    readonly contact: readonly CobieContactRow[];
+    readonly facility: readonly CobieFacilityRow[];
+    readonly floor: readonly CobieFloorRow[];
+    readonly space: readonly CobieSpaceRow[];
+    readonly zone: readonly CobieZoneRow[];
+    readonly type: readonly CobieTypeRow[];
+    readonly component: readonly CobieComponentRow[];
+    readonly system: readonly CobieSystemRow[];
+    readonly attribute: readonly CobieAttributeRow[];
+}
+/** JSON serialization of a {@link CobieModel} — one array per sheet name. */
+export interface CobieJson {
+    readonly Contact: readonly CobieContactRow[];
+    readonly Facility: readonly CobieFacilityRow[];
+    readonly Floor: readonly CobieFloorRow[];
+    readonly Space: readonly CobieSpaceRow[];
+    readonly Zone: readonly CobieZoneRow[];
+    readonly Type: readonly CobieTypeRow[];
+    readonly Component: readonly CobieComponentRow[];
+    readonly System: readonly CobieSystemRow[];
+    readonly Attribute: readonly CobieAttributeRow[];
+}

package/dist/cobie/index.d.ts

@@ -0,0 +1,2 @@
+export { deriveCobieModel, serializeCobieToCsv, serializeCobieToJson } from './cobieExport.js';
+export type { CobieModel, CobieJson, CobieExportMeta, CobieContactMeta, CobieContactRow, CobieFacilityRow, CobieFloorRow, CobieSpaceRow, CobieZoneRow, CobieTypeRow, CobieComponentRow, CobieSystemRow, CobieAttributeRow, } from './cobieTypes.js';

package/dist/elementFns/beamFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { BeamSpec } from '../specs/beamSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function beamToSolid(spec: BeamSpec): Result<ValidSolid, BimError>;

package/dist/elementFns/columnFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { ColumnSpec } from '../specs/columnSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function columnToSolid(spec: ColumnSpec): Result<ValidSolid, BimError>;

package/dist/elementFns/coveringFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { CoveringSpec } from '../specs/coveringSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function coveringToSolid(spec: CoveringSpec): Result<ValidSolid, BimError>;

package/dist/elementFns/curtainWallFns.d.ts

@@ -0,0 +1,32 @@
+import { ValidSolid, Result } from 'brepjs';
+import { CurtainWallSpec } from '../specs/curtainWallSpec.js';
+import { BimError } from '../errors/bimError.js';
+/**
+ * A placed box component of the curtain wall. `origin` is the corner of the box
+ * in the wall's local frame (X across the wall, Y through its depth, Z up);
+ * `size` is its extent along each local axis (all mm). The owning IfcPlate /
+ * IfcMember placement carries `origin`; `solid` is the local-origin template
+ * geometry (corner at 0,0,0).
+ */
+export interface CurtainWallComponent {
+    readonly origin: [number, number, number];
+    readonly size: [number, number, number];
+    readonly solid: ValidSolid;
+}
+/** A curtain wall decomposed into glazing panels (plates) and mullions (members). */
+export interface CurtainWallGrid {
+    readonly panels: readonly CurtainWallComponent[];
+    readonly mullions: readonly CurtainWallComponent[];
+}
+/**
+ * Decomposes a curtain wall spec into its panel (plate) and mullion (member)
+ * geometry. Mullions run along every vertical grid line (columns + 1 of them)
+ * and every horizontal grid line (rows + 1); panels fill the cells between
+ * adjacent mullions. The mullion section is centred on each grid line.
+ *
+ * Geometry is laid out in the wall's local frame: X across the wall, Z up, Y
+ * through the depth. Each component's local-origin solid is returned alongside
+ * its placement origin so the IFC writer can emit one IfcLocalPlacement per
+ * component.
+ */
+export declare function curtainWallToGrid(spec: CurtainWallSpec): Result<CurtainWallGrid, BimError>;

package/dist/elementFns/foundationFns.d.ts

@@ -0,0 +1,5 @@
+import { ValidSolid, Result } from 'brepjs';
+import { FootingSpec, PileSpec } from '../specs/foundationSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function footingToSolid(spec: FootingSpec): Result<ValidSolid, BimError>;
+export declare function pileToSolid(spec: PileSpec): Result<ValidSolid, BimError>;

package/dist/elementFns/openingFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { WallOpeningSpec } from '../types/bimTypes.js';
+import { BimError } from '../errors/bimError.js';
+export declare function openingToSolid(spec: WallOpeningSpec, wallThickness: number): Result<ValidSolid, BimError>;

package/dist/elementFns/profileFns.d.ts

@@ -0,0 +1,5 @@
+import { Result } from 'brepjs';
+import { Profile } from '../specs/profile.js';
+import { BimError } from '../errors/bimError.js';
+export declare function profileCrossSectionArea(profile: Profile): number;
+export declare function profileToPolygon(profile: Profile, circleSegments?: number): Result<Array<[number, number, number]>, BimError>;

package/dist/elementFns/railingFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { RailingSpec } from '../specs/railingSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function railingToSolid(spec: RailingSpec): Result<ValidSolid, BimError>;

package/dist/elementFns/rampFns.d.ts

@@ -0,0 +1,14 @@
+import { ValidSolid, Result } from 'brepjs';
+import { RampFlightSpec } from '../specs/rampSpec.js';
+import { BimError } from '../errors/bimError.js';
+export interface RampFlightSolid {
+    readonly solid: ValidSolid;
+    /**
+     * True — the ramp flight is a simplified inclined-slab solid (a sloped prism),
+     * not a fully detailed ramp with landings/nosings/edge details. Callers should
+     * surface a SIMPLIFIED_GEOMETRY note. The solid is valid and non-degenerate.
+     */
+    readonly geometrySimplified: true;
+}
+export declare function rampFlightToSolid(spec: RampFlightSpec): Result<RampFlightSolid, BimError>;
+export declare function rampFlightVolume(spec: RampFlightSpec): number;

package/dist/elementFns/roofFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { RoofSpec } from '../specs/roofSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function roofToSolid(spec: RoofSpec): Result<ValidSolid, BimError>;

package/dist/elementFns/slabFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { SlabSpec } from '../specs/slabSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function slabToSolid(spec: SlabSpec): Result<ValidSolid, BimError>;

package/dist/elementFns/slabOpeningFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { SlabOpeningSpec } from '../types/bimTypes.js';
+import { BimError } from '../errors/bimError.js';
+export declare function slabOpeningToSolid(spec: SlabOpeningSpec, slabThickness: number): Result<ValidSolid, BimError>;

package/dist/elementFns/spaceFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { SpaceSpec } from '../specs/spaceSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function spaceToSolid(spec: SpaceSpec): Result<ValidSolid, BimError>;

package/dist/elementFns/stairFns.d.ts

@@ -0,0 +1,15 @@
+import { ValidSolid, Result } from 'brepjs';
+import { StairFlightSpec } from '../specs/stairSpec.js';
+import { BimError } from '../errors/bimError.js';
+export interface StairFlightSolid {
+    readonly solid: ValidSolid;
+    /**
+     * False — stair flights are built as real stepped solids (tread/riser
+     * sawtooth swept across the width), not a simplified bounding box. Present so
+     * callers can surface a SIMPLIFIED_GEOMETRY note uniformly across element
+     * kinds; the ramp builder sets this true.
+     */
+    readonly geometrySimplified: false;
+}
+export declare function stairFlightToSolid(spec: StairFlightSpec): Result<StairFlightSolid, BimError>;
+export declare function stairFlightVolume(spec: StairFlightSpec): number;

package/dist/elementFns/wallFns.d.ts

@@ -0,0 +1,4 @@
+import { ValidSolid, Result } from 'brepjs';
+import { WallSpec } from '../specs/wallSpec.js';
+import { BimError } from '../errors/bimError.js';
+export declare function wallToSolid(spec: WallSpec): Result<ValidSolid, BimError>;

package/dist/errors/bimError.d.ts

@@ -0,0 +1,39 @@
+import { BrepError } from 'brepjs';
+export type BimErrorKind = 'BIM_SPEC' | 'BIM_IFC' | 'BIM_GEOMETRY' | 'BIM_IMPORT' | 'BIM_BCF' | 'BIM_IDS';
+export interface BimError {
+    readonly kind: BimErrorKind;
+    readonly code: string;
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export declare function specError(code: string, message: string, cause?: unknown): BimError;
+export declare function ifcError(code: string, message: string, cause?: unknown): BimError;
+export declare function geometryError(code: string, message: string, cause?: unknown): BimError;
+/**
+ * IFC-import error factory. Codes used by the reader subsystem:
+ * - `OPEN_MODEL_FAILED` — web-ifc returned an invalid model id on OpenModel
+ * - `SCHEMA_UNSUPPORTED` — schema string not in `['IFC2X3', 'IFC4', 'IFC4X3']`
+ * - `UNSUPPORTED_PROFILE` — profile entity type not in the supported set
+ * - `GEOMETRY_RECONSTRUCTION_FAILED` — parametric reconstruction threw
+ * - `TESSELLATION_NOT_MANIFOLD` — STL round-trip did not produce a closed solid
+ * - `PLACEMENT_READ_FAILED` — placement chain produced a degenerate matrix
+ * - `UNIT_ASSIGNMENT_MISSING` — no IfcUnitAssignment found (assume metres, warn)
+ */
+export declare function importError(code: string, message: string, cause?: unknown): BimError;
+/**
+ * BCF (BIM Collaboration Format) error factory. Codes used by the BCF subsystem:
+ * - `BCF_PARSE_FAILED` — an XML file could not be parsed into the BCF data model
+ * - `BCF_VERSION_UNSUPPORTED` — `bcf.version` declares a version other than 3.0
+ * - `BCF_MISSING_FILE` — a required container file (`bcf.version`, `project.bcfp`) is absent
+ */
+export declare function bcfError(code: string, message: string, cause?: unknown): BimError;
+/**
+ * IDS (Information Delivery Specification) error factory. Codes used by the IDS
+ * subsystem:
+ * - `IDS_PARSE_FAILED` — the IDS XML could not be parsed into a document tree
+ * - `IDS_INVALID_SCHEMA` — the root element is not `<ids>` or has no specifications
+ * - `IDS_UNSUPPORTED_VERSION` — the document declares an IDS version this subset rejects
+ */
+export declare function idsError(code: string, message: string, cause?: unknown): BimError;
+export declare function fromBrepError(inner: BrepError, code: string, message: string): BimError;

package/dist/identity/guidDerivation.d.ts

@@ -0,0 +1,25 @@
+import { IfcGuid } from './ifcGuid.js';
+/**
+ * Synchronously derives a stable IFC GlobalId from an arbitrary stable key.
+ * Re-running with the same key always yields the same GUID, so serializing an
+ * identical model twice produces byte-for-byte identical GlobalIds. Distinct
+ * keys yield distinct, format-valid (22-char) GlobalIds.
+ */
+export declare function deriveIfcGuidSync(stableKey: string): IfcGuid;
+/**
+ * Async wrapper over {@link deriveIfcGuidSync} for callers that prefer a Promise
+ * surface. The derivation itself is synchronous and deterministic.
+ */
+export declare function deriveIfcGuid(stableKey: string): Promise<IfcGuid>;
+/**
+ * `"elem:{modelScope}:{category}:{localId}"` — stable key for a model element
+ * occurrence. `modelScope` is a per-model identifier (the project GlobalId/id) so
+ * two distinct models that add elements in the same order do NOT produce colliding
+ * GlobalIds, as required for COBie/BCF/federation (global uniqueness, not merely
+ * re-export stability within one model).
+ */
+export declare function makeElementKey(modelScope: string, category: string, localId: number): string;
+/** `"rel:{modelScope}:{kind}:{localId}"` — model-scoped stable key for a relationship. */
+export declare function makeRelKey(modelScope: string, kind: string, localId: number): string;
+/** `"line:{modelScope}:{expressId}"` — model-scoped stable key for a writer-minted line. */
+export declare function makeLineKey(modelScope: string, expressId: number): string;

package/dist/identity/ifcGuid.d.ts

@@ -0,0 +1,7 @@
+declare const __ifcGuidBrand: unique symbol;
+export type IfcGuid = string & {
+    readonly [__ifcGuidBrand]: true;
+};
+export declare function newIfcGuid(): IfcGuid;
+export declare function isValidIfcGuid(s: string): s is IfcGuid;
+export {};

package/dist/identity/localId.d.ts

@@ -0,0 +1,10 @@
+declare const __localIdBrand: unique symbol;
+export type LocalId = number & {
+    readonly [__localIdBrand]: true;
+};
+export interface LocalIdCounter {
+    next(): LocalId;
+    current(): LocalId;
+}
+export declare function makeLocalIdCounter(start?: number): LocalIdCounter;
+export {};

package/dist/ids/idsCheck.d.ts

@@ -0,0 +1,22 @@
+import { ImportedModel } from '../import/importedModel.js';
+import { IdsCheckReport, IdsDocument } from './idsTypes.js';
+/**
+ * Checks an imported model against an IDS document, returning a per-specification
+ * pass/fail report keyed by the specification name. The check is synchronous,
+ * never throws, and surfaces all problems as {@link ValidationIssue}s.
+ *
+ * For each specification the applicability facets select the matching elements,
+ * then the requirement facets are evaluated against each applicable element per
+ * the spec's cardinality:
+ * - `required` — every applicable element must satisfy all requirements
+ *   (a failure is an `error`).
+ * - `optional` — requirement failures are reported as `info` and never fail.
+ * - `prohibited` — an applicable element that *does* satisfy the requirements is
+ *   a violation (`error`).
+ *
+ * Unsupported facet features (the `PartOf` facet, numeric-bound restrictions,
+ * and invalid `xs:pattern` dialects) are recorded in
+ * {@link IdsCheckReport.unsupportedFacets} and the affected requirement is
+ * skipped rather than failing the element.
+ */
+export declare function checkModelAgainstIds(model: ImportedModel, ids: IdsDocument): IdsCheckReport;

package/dist/ids/idsFacets.d.ts

@@ -0,0 +1,21 @@
+import { ImportedElement, ImportedElementCategory } from '../import/importedModel.js';
+import { IdsRestriction } from './idsTypes.js';
+/** Returns the categories an entity-name restriction can resolve to. */
+export declare function categoriesForRestriction(name: IdsRestriction): ReadonlySet<ImportedElementCategory>;
+/** Tests whether a candidate string satisfies an IDS value restriction. */
+export declare function matchesRestriction(candidate: string, restriction: IdsRestriction): boolean;
+export declare function isValidPattern(pattern: string): boolean;
+/** True when the element's category matches the entity name (and predefined type). */
+export declare function evalEntityFacet(element: ImportedElement, name: IdsRestriction, predefinedType: IdsRestriction | undefined): boolean;
+/**
+ * True when the element exposes the named property in the named pset, optionally
+ * with a value matching `value`. Reads from both IfcPropertySet-derived psets and
+ * IfcElementQuantity-derived ones.
+ */
+export declare function evalPropertyFacet(element: ImportedElement, psetName: IdsRestriction, baseName: IdsRestriction, value: IdsRestriction | undefined): boolean;
+/** True when an element attribute (Name/PredefinedType) matches the facet. */
+export declare function evalAttributeFacet(element: ImportedElement, name: IdsRestriction, value: IdsRestriction | undefined): boolean;
+/** True when the element's classification system/value match the facet. */
+export declare function evalClassificationFacet(element: ImportedElement, system: IdsRestriction | undefined, value: IdsRestriction | undefined): boolean;
+/** True when the element's material name matches the facet value. */
+export declare function evalMaterialFacet(element: ImportedElement, value: IdsRestriction | undefined): boolean;

package/dist/ids/idsParser.d.ts

@@ -0,0 +1,20 @@
+import { Result } from 'brepjs';
+import { BimError } from '../errors/bimError.js';
+import { IdsDocument } from './idsTypes.js';
+/**
+ * Parses an IDS 1.0 XML document string into a typed {@link IdsDocument}.
+ *
+ * Supported structure: `<ids><info><title/></info><specifications>` with one or
+ * more `<specification>` carrying `<applicability>` and `<requirements>`. Inside
+ * those, the facets `entity`, `attribute`, `property`, `classification`,
+ * `material`, and `partOf` are recognised. Each value field accepts either a
+ * `<simpleValue>` or an `<xs:restriction>` with `<xs:enumeration>` or
+ * `<xs:pattern>` children.
+ *
+ * Cardinality is read from the specification's `minOccurs`/`maxOccurs` (or the
+ * `cardinality` attribute when present): `prohibited` when `maxOccurs="0"`,
+ * `optional` when `minOccurs="0"`, otherwise `required`.
+ *
+ * Never throws — malformed XML or a missing root returns `err(idsError(...))`.
+ */
+export declare function parseIdsXml(xml: string): Result<IdsDocument, BimError>;

package/dist/ids/idsTypes.d.ts

@@ -0,0 +1,87 @@
+import { ValidationIssue } from '../validation/severity.js';
+/**
+ * A value constraint on an IDS facet field. IDS expresses these either as a
+ * literal `<simpleValue>` or as an `<xs:restriction>` carrying an enumeration or
+ * a pattern. The numeric bound dialect (`xs:minInclusive` etc.) is intentionally
+ * not modelled — facets that use it fall through to a `pattern`-less restriction
+ * and are reported as unsupported by the checker.
+ */
+export type IdsRestriction = {
+    readonly kind: 'simple';
+    readonly value: string;
+} | {
+    readonly kind: 'enumeration';
+    readonly values: readonly string[];
+} | {
+    readonly kind: 'pattern';
+    readonly pattern: string;
+};
+/**
+ * The IDS facet kinds this subset understands. `PartOf` is parsed but always
+ * reported as unsupported by the checker (spatial-tree resolution is out of
+ * scope); every other kind is fully evaluated.
+ */
+export type IdsFacet = {
+    readonly kind: 'Entity';
+    readonly name: IdsRestriction;
+    readonly predefinedType?: IdsRestriction | undefined;
+} | {
+    readonly kind: 'Attribute';
+    readonly name: IdsRestriction;
+    readonly value?: IdsRestriction | undefined;
+} | {
+    readonly kind: 'Property';
+    readonly psetName: IdsRestriction;
+    readonly baseName: IdsRestriction;
+    readonly value?: IdsRestriction | undefined;
+} | {
+    readonly kind: 'Classification';
+    readonly system?: IdsRestriction | undefined;
+    readonly value?: IdsRestriction | undefined;
+} | {
+    readonly kind: 'Material';
+    readonly value?: IdsRestriction | undefined;
+} | {
+    readonly kind: 'PartOf';
+    readonly relation?: string | undefined;
+};
+export type IdsCardinality = 'required' | 'optional' | 'prohibited';
+export interface IdsSpecification {
+    readonly name: string;
+    readonly ifcVersion: readonly string[];
+    /**
+     * Cardinality of the *requirements* against applicable elements:
+     * - `required` — every applicable element must satisfy all requirement facets.
+     * - `optional` — requirements are informational; failures are reported as
+     *   warnings and do not fail the spec.
+     * - `prohibited` — applicable elements must *not* satisfy the requirements.
+     */
+    readonly cardinality: IdsCardinality;
+    readonly applicability: readonly IdsFacet[];
+    readonly requirements: readonly IdsFacet[];
+}
+export interface IdsDocument {
+    readonly title: string;
+    readonly specifications: readonly IdsSpecification[];
+}
+export interface IdsCheckResult {
+    readonly specificationName: string;
+    readonly pass: boolean;
+    /** Number of model elements matched by the applicability facets. */
+    readonly applicableCount: number;
+    /** Applicable elements that satisfied the cardinality contract. */
+    readonly passedCount: number;
+    /** Applicable elements that violated the cardinality contract. */
+    readonly failedCount: number;
+    readonly issues: readonly ValidationIssue[];
+}
+export interface IdsCheckReport {
+    readonly pass: boolean;
+    readonly results: readonly IdsCheckResult[];
+    /**
+     * Human-readable identifiers of facet features that were encountered but not
+     * evaluated (e.g. `PartOf in 'spec name'`). Their presence never aborts the
+     * check; the affected requirement is skipped with a warning.
+     */
+    readonly unsupportedFacets: readonly string[];
+}

package/dist/ids/idsXml.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A zero-dependency XML element tree, sufficient for the IDS 1.0 subset this
+ * module parses. Node 24's build does not expose a global `DOMParser`, and the
+ * workspace ships no XML dependency, so a small hand-written tokenizer is used.
+ *
+ * Scope of support: elements, attributes (single/double quoted), text content,
+ * self-closing tags, comments, the XML declaration, and CDATA. Namespace
+ * prefixes are stripped from tag names (`ids:specification` → `specification`)
+ * so namespaced and default-namespace IDS files parse identically. DOCTYPE and
+ * external entities are not processed — there is no entity expansion, so XXE is
+ * not reachable.
+ */
+export interface XmlElement {
+    readonly tag: string;
+    readonly attributes: Readonly<Record<string, string>>;
+    readonly children: readonly XmlElement[];
+    /** Concatenated direct text content with entities decoded and trimmed. */
+    readonly text: string;
+}
+export declare function parseXml(input: string): XmlElement;
+/** Returns the message of an {@link XmlParseError}, or rethrows other errors. */
+export declare function isXmlParseError(e: unknown): e is Error;
+export declare function childrenNamed(el: XmlElement, tag: string): readonly XmlElement[];
+export declare function firstChild(el: XmlElement, tag: string): XmlElement | undefined;

package/dist/ids/index.d.ts

@@ -0,0 +1,3 @@
+export { parseIdsXml } from './idsParser.js';
+export { checkModelAgainstIds } from './idsCheck.js';
+export type { IdsDocument, IdsSpecification, IdsFacet, IdsRestriction, IdsCardinality, IdsCheckReport, IdsCheckResult, } from './idsTypes.js';

package/dist/ifc-writer/assemblyWriter.d.ts

@@ -0,0 +1,26 @@
+import { IfcWriter } from './ifcWriter.js';
+import { IfcGuid } from '../identity/ifcGuid.js';
+/** IfcAssemblyPlaceEnum values; SITE for in-place assemblies, FACTORY for prefabricated. */
+export type AssemblyPlaceIfc = 'SITE' | 'FACTORY' | 'NOTDEFINED';
+/** IfcElementAssemblyTypeEnum values (IFC4). */
+export type ElementAssemblyPredefinedTypeIfc = 'ACCESSORY_ASSEMBLY' | 'ARCH' | 'BEAM_GRID' | 'BRACED_FRAME' | 'GIRDER' | 'REINFORCEMENT_UNIT' | 'RIGID_FRAME' | 'SLAB_FIELD' | 'TRUSS' | 'USERDEFINED' | 'NOTDEFINED';
+/**
+ * Emits an IfcElementAssembly grouping container. The assembly itself carries no
+ * own geometry by default — parts contribute geometry and are linked via
+ * {@link writeRelAggregatesElements} (or {@link writeRelNests} for ordered nesting).
+ * Pass `productDefinitionShapeId` only when the assembly has an explicit envelope.
+ */
+export declare function writeElementAssemblyEntity(w: IfcWriter, guid: IfcGuid, name: string, predefinedType: ElementAssemblyPredefinedTypeIfc, ownerHistoryId: number, localPlacementId: number | null, productDefinitionShapeId: number | null, assemblyPlace?: AssemblyPlaceIfc): number;
+/**
+ * Links child elements to an assembly via IfcRelAggregates. Use this for the
+ * element-level (non-spatial) decomposition of an IfcElementAssembly into parts.
+ * `relatedObjectIds` must be non-empty; an empty set is a no-op.
+ */
+export declare function writeRelAggregatesElements(w: IfcWriter, guid: IfcGuid, ownerHistoryId: number, relatingObjectId: number, relatedObjectIds: readonly number[]): void;
+/**
+ * Links ordered child elements to a parent via IfcRelNests. Unlike
+ * IfcRelAggregates, IfcRelNests preserves the order of `relatedObjectIds`,
+ * which is the correct relationship for ordered members (e.g. stair/ramp
+ * flights within their assembly). An empty set is a no-op.
+ */
+export declare function writeRelNests(w: IfcWriter, guid: IfcGuid, ownerHistoryId: number, relatingObjectId: number, relatedObjectIds: readonly number[]): void;

package/dist/ifc-writer/classificationWriter.d.ts

@@ -0,0 +1,18 @@
+import { IfcWriter } from './ifcWriter.js';
+import { ClassificationRef } from '../types/classificationTypes.js';
+export type { ClassificationRef } from '../types/classificationTypes.js';
+/**
+ * Writes the IFC classification entities for a set of references and associates
+ * each to its elements.
+ *
+ * For every distinct classification system a single `IfcClassification` is
+ * emitted (deduplicated by system name within this call). Each reference yields
+ * one `IfcClassificationReference` pointing at that system, plus one
+ * `IfcRelAssociatesClassification` linking the reference to its related objects.
+ * The rel's GlobalId is derived deterministically from the reference's
+ * system/code so re-exports stay byte-stable.
+ *
+ * @param refs maps each classification reference to the express IDs of the IFC
+ *   elements it classifies.
+ */
+export declare function writeClassificationRefs(w: IfcWriter, ownerHistoryId: number, refs: ReadonlyMap<ClassificationRef, readonly number[]>): void;

package/dist/ifc-writer/connectivityWriter.d.ts

@@ -0,0 +1,16 @@
+import { IfcWriter } from './ifcWriter.js';
+import { IfcGuid } from '../identity/ifcGuid.js';
+/** IfcConnectionTypeEnum values used by IfcRelConnectsPathElements path ends. */
+export type PathConnectionTypeIfc = 'ATSTART' | 'ATEND' | 'ATPATH' | 'NOTDEFINED';
+/**
+ * Emits an IfcRelConnectsElements recording a physical connection between two
+ * elements. `description` optionally annotates the connection; geometry of the
+ * connection is left null (logical connectivity only).
+ */
+export declare function writeRelConnectsElements(w: IfcWriter, guid: IfcGuid, ownerHistoryId: number, relatingElementId: number, relatedElementId: number, description?: string | null): void;
+/**
+ * Emits an IfcRelConnectsPathElements recording a connection between two
+ * path-based elements (e.g. walls, beams) at specified path ends. Priority
+ * arrays are emitted empty; connection geometry is left null.
+ */
+export declare function writeRelConnectsPathElements(w: IfcWriter, guid: IfcGuid, ownerHistoryId: number, relatingElementId: number, relatedElementId: number, relatingConnectionType: PathConnectionTypeIfc, relatedConnectionType: PathConnectionTypeIfc, description?: string | null): void;