@bitbybit-dev/ifc 0.0.0-stage → 1.5.0-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bit by bit developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,42 @@
+NOTICE - third-party material in @bitbybit-dev/ifc
+==================================================
+
+The TypeScript and JavaScript in this package are MIT-licensed (see LICENSE), with two exceptions
+described below: the generated schema tables.
+
+1. The IFC4 ADD2 TC1 schema
+   Author:  buildingSMART International Limited
+   Source:  the EXPRESS schema IFC4_ADD2_TC1.exp, published by buildingSMART International
+            (https://github.com/buildingSMART/IFC4.x-development, reference_schemas/)
+   Usage:   translated into a TypeScript table (lib/schema/generated/ifc4.js) that names every
+            type and entity of the schema with its attributes. The translation is generated, and
+            the schema itself is not changed.
+   Notice:  "Any technical documentation made available by buildingSMART International Limited
+            is the copyrighted work of buildingSMART International Limited and is owned by the
+            buildingSMART International Limited. It may be photocopied, used in software
+            development, or translated into another computer language without prior written
+            consent from buildingSMART International Limited provided that full attribution is
+            given. Prior written consent is required if changes are made to the technical
+            specification."
+
+2. The IFC4X3 ADD2 schema (IFC 4.3.2.0)
+   Author:  buildingSMART International Limited
+   Source:  the EXPRESS schema IFC4X3_ADD2.exp of the official IFC 4.3.2.0 publication
+            (https://standards.buildingsmart.org/IFC/RELEASE/IFC4_3/), kept unchanged in the
+            repository's packages/dev/ifc/schema/
+   Licence: Creative Commons Attribution-NoDerivatives 4.0 International (CC BY-ND 4.0),
+            https://creativecommons.org/licenses/by-nd/4.0/
+   Usage:   translated into a TypeScript table (lib/schema/generated/ifc4x3.js) that names every
+            type and entity of the schema with its attributes. buildingSMART's copyright notice
+            (https://github.com/buildingSMART/IFC4.x-development/blob/ifc4.3-main/LICENSE.md)
+            lets its technical documentation be "translated into another computer language
+            without prior written consent from buildingSMART International Limited provided that
+            full attribution is given". The schema itself is not changed.
+   Notice:  "Copyright © 1996-2023 buildingSMART International Limited. Some rights reserved. Any
+            technical documentation made available by buildingSMART International Limited is the
+            copyrighted work of buildingSMART International Limited and is owned by
+            buildingSMART International Limited. The Industry Foundation Classes are published
+            under Creative Commons Attribution-NoDerivatives 4.0 International (CC BY-ND 4.0)."
+
+   IFC and Industry Foundation Classes are names of buildingSMART International. This package is
+   not certified by, endorsed by or affiliated with buildingSMART International.

package/README.md

@@ -1,3 +1,93 @@
-# Temporary Holding Version
+# @bitbybit-dev/ifc
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Write, read and author [IFC](https://technical.buildingsmart.org/standards/ifc/) building models in TypeScript, with no WebAssembly and no geometry kernel: walls joined at their corners, slabs, openings, doors and windows from types, columns, beams, materials, layer sets and property sets, written as IFC4 files that BIM tools open and edit.
+
+<img src="https://bitbybit.dev/files/site/git-cover.png" alt="Picture showing bitbybit.dev platform">
+
+> **Beta.** The API's names and inputs may still change before the first stable version.
+
+## Overview
+
+IFC (Industry Foundation Classes, ISO 16739) is the open exchange format for building information models. This package reads and writes IFC's text encoding (ISO 10303-21) itself, against a table generated from buildingSMART's IFC4 ADD2 TC1 schema, and builds standard elements the way IFC defines them: a wall is an axis, a material layer set and a height, written as a parametric extrusion; a door cuts its own opening and shares its type's geometry.
+
+Works in **Node.js** and in the **browser**. It depends only on [@bitbybit-dev/base](https://www.npmjs.com/package/@bitbybit-dev/base).
+
+See it build a whole two-storey family house, drawn live in the browser with its source to read: **[A Family House in IFC](https://learn.bitbybit.dev/learn/code/common/ifc/family-house)**.
+
+## Quick start
+
+```bash
+npm install @bitbybit-dev/ifc
+```
+
+```typescript
+import { writeFileSync } from "node:fs";
+import { Base, IFC, IFCService } from "@bitbybit-dev/ifc";
+
+const ifc = new IFCService();
+let model = ifc.model.create({ name: "House", seed: "house-1" });
+model = ifc.spatial.addStorey({ model, id: "ground", name: "Ground floor", elevation: 0 });
+
+const corners: Base.Point2[] = [[0, 0], [10000, 0], [10000, 8000], [0, 8000]];
+for (let i = 0; i < 4; i++) {
+    model = ifc.walls.add({
+        model, storey: "ground", id: `wall-${i}`,
+        start: corners[i], end: corners[(i + 1) % 4],
+        height: 3000, thickness: 250, alignment: IFC.wallAlignmentEnum.right,
+    });
+}
+for (let i = 0; i < 4; i++) {
+    model = ifc.walls.connect({ model, wall: `wall-${i}`, other: `wall-${(i + 1) % 4}` });
+}
+
+model = ifc.doors.addType({ model, id: "door-90", name: "Door 900", width: 900, height: 2100 });
+model = ifc.doors.add({ model, wall: "wall-0", doorType: "door-90", offset: 2000 });
+model = ifc.slabs.add({ model, storey: "ground", outline: corners, thickness: 250 });
+
+writeFileSync("house.ifc", ifc.model.writeBytes({ model, fileName: "house.ifc" }));
+```
+
+Run it with `npx tsx house.ts`. Compiled to JavaScript, run it as `node --import=extensionless/register house.js` with the [extensionless](https://www.npmjs.com/package/extensionless) package installed: the package's own imports leave out file extensions, which plain `node` does not resolve.
+
+## How it works
+
+- **A model is a value.** Every method that changes a model returns a new one and leaves the one it was given as it was, so keep the result and pass it on. Earlier models stay valid, which is undo for free.
+- **Ids of your own.** Give an element an `id` such as `"north-wall"` and refer to it by that id later; the model derives the element's GlobalId from it and the project's GlobalId, so it is unique to the model. Wherever an existing object is named, its 22-character GlobalId works as well as its id. With a `seed` on `model.create` and a fixed `timeStamp` on `model.write`, the same calls always write the same file.
+- **Units and axes.** Lengths are in the model's unit: millimetres unless the model was created with another `lengthUnit`. A length left out takes its default in that unit, so a wall is 3000 mm high in a model in millimetres and 3 m high in one in metres. Positions on a storey are given in its plan, `[x, y]`, with Z up from the storey's floor, as IFC has it.
+- **Standard elements.** Walls keep their axis (`Plan/Axis`), layer set usage and a swept-solid body, and joins are recorded as `IfcRelConnectsPathElements`, so tools that edit IFC walls edit them as walls. Joins and roof clippings are worked out again from those whenever a wall changes.
+- **Reading and writing.** `model.read` takes the file's text, a `Uint8Array` or an `ArrayBuffer`, indexes it without decoding it and decodes an entity only when asked, so a file of hundreds of megabytes opens in seconds. Entities left unchanged are written back as they were, with the line breaks and comments between them: `model.writeBytes` copies them byte for byte at any size, and `model.write` gives the same file as text, up to the length one JavaScript string holds. A file that breaks the encoding, holds an entity id twice or names a type or schema this library does not read fails with a `StepSyntaxError` naming the byte offset, when the broken part is first read. A value given to a model that its schema does not accept fails at once with an `IfcValueError` naming the entity and the attribute.
+- **Geometry as data.** `geometry.recipe` describes the elements' solids as a recipe (`Base.Recipe`): polygons, extrusions, cuts by planes, openings and shared type geometry, every number resolved. `manifold.recipes.build` in [@bitbybit-dev/manifold](https://www.npmjs.com/package/@bitbybit-dev/manifold) builds it into one solid per element, which the renderer packages draw, and `occt.recipes.build` in [@bitbybit-dev/occt](https://www.npmjs.com/package/@bitbybit-dev/occt) builds it exactly, to measure or export to STEP; `geometry.unsupported` says which elements it could not describe, and why. In a browser, [@bitbybit-dev/ifc-worker](https://www.npmjs.com/package/@bitbybit-dev/ifc-worker) runs this library in a web worker.
+
+## What version 1 covers
+
+| Area | Supported |
+|---|---|
+| Schema | IFC4 ADD2 TC1, read and written; IFC2X3 files read through IFC4 to show and query, and upgraded to IFC4 to edit |
+| Spatial structure | project, site, one building, storeys raised or lowered with everything on them, spaces with their areas |
+| Site | terrain with holes where the building and paving meet it, and trees with a trunk and crown in their own materials, as geographic elements of the site |
+| Walls | straight walls from an axis, by thickness, layer set or wall type; centred, left or right aligned; L joins (mitred) and T joins (butt); clipping by planes and under roofs; read back as parameters and edited, also when another tool wrote them |
+| Openings, doors, windows | rectangular openings in walls, moved or resized; any outline through a slab; door and window types with a lining or frame and one panel or pane, each part in its own material, doors with lever or pull-bar handles, placed many times through mapped geometry |
+| Slabs and roofs | outlines with holes, by thickness or layer set; flat, mono-pitch, gable and hip roofs over a rectangle |
+| Columns, beams and members | rectangle, circle and I sections; braces, rafters, studs, mullions and other members |
+| Editing | removing elements with what only they use, moving and turning them |
+| Data | materials with colours, layer sets, property sets on elements and types set and removed value by value, any attribute read and any simple one set |
+| Quantities | the base quantity sets of walls, slabs, columns, beams, members, doors, windows, openings, spaces and roofs, measured from their geometry |
+| Geometry recipes | extrusions of arbitrary, rectangle, circle and I profiles, outlines of polylines, arcs and composite curves, half-space clippings (polygonal bounded ones too), boolean differences, mapped items (mirrored and scaled too), triangulated and polygonal face sets, faceted breps, surface models, openings |
+
+## Use It With an AI Agent
+
+The free **[Bitbybit CAD MCP](https://learn.bitbybit.dev/learn/using-ai-with-bitbybit/mcp/bitbybit-mcp)** server lets your agent look up the exact signatures, defaults and examples of this package for the version you have installed.
+
+## Licence
+
+The package is MIT-licensed. Its schema table is a translation of buildingSMART International's IFC4 ADD2 TC1 EXPRESS schema, used with attribution under the notice the schema carries; see `NOTICE`. IFC and Industry Foundation Classes are names of buildingSMART International; this package is not certified by or affiliated with it.
+
+## Links
+
+| Resource | URL |
+|----------|-----|
+| **GitHub** | https://github.com/bitbybit-dev/bitbybit/tree/master/packages/dev/ifc |
+| **Monorepo** | https://github.com/bitbybit-dev/bitbybit |
+| **NPM** | https://www.npmjs.com/package/@bitbybit-dev/ifc |
+| **Documentation** | https://learn.bitbybit.dev/learn/npm-packages/ifc |
+| **Example** | https://learn.bitbybit.dev/learn/code/common/ifc/family-house |

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./lib";

package/index.js

@@ -0,0 +1 @@
+export * from "./lib";

package/lib/api/dto-registry.d.ts

@@ -0,0 +1,8 @@
+import { DtoRegistry } from "@bitbybit-dev/base";
+/**
+ * Every public operation of the IFC kernel by its dotted path, the inputs DTO it
+ * takes, and what each property of that DTO accepts. `resolveInputs` from the base package reads
+ * it to lay a caller's properties over that DTO's defaults before the kernel runs, and
+ * `validateInputs` to check what the call was given.
+ */
+export declare const ifcDtoRegistry: DtoRegistry;

package/lib/api/dto-registry.js

@@ -0,0 +1,109 @@
+// GENERATED by scripts/gen-dto-meta.mjs from the IFCService surface - do not edit; regenerate with `npm run gen:dto-meta`.
+import { constraintKinds as k } from "@bitbybit-dev/base";
+import * as Inputs from "./inputs";
+const IFC_AddAssemblyDto = { model: k.required(k.opaque), parts: k.required(k.list(k.string)), id: k.string, name: k.string, predefinedType: k.oneOf(["ACCESSORY_ASSEMBLY", "ARCH", "BEAM_GRID", "BRACED_FRAME", "GIRDER", "REINFORCEMENT_UNIT", "RIGID_FRAME", "SLAB_FIELD", "TRUSS", "USERDEFINED", "NOTDEFINED"]), objectType: k.string };
+const IFC_AddBeamDto = { start: k.required(k.point3), end: k.required(k.point3), model: k.required(k.opaque), storey: k.required(k.string), id: k.string, name: k.string, profile: k.oneOf(["rectangle", "circle", "iShape"]), width: k.between(k.number, { min: 0, exclusiveMin: true }), depth: k.between(k.number, { min: 0, exclusiveMin: true }), radius: k.between(k.number, { min: 0, exclusiveMin: true }), webThickness: k.between(k.number, { min: 0, exclusiveMin: true }), flangeThickness: k.between(k.number, { min: 0, exclusiveMin: true }), rotation: k.number, material: k.string };
+const IFC_AddColumnDto = { position: k.point2, height: k.between(k.number, { min: 0, exclusiveMin: true }), baseOffset: k.number, model: k.required(k.opaque), storey: k.required(k.string), id: k.string, name: k.string, profile: k.oneOf(["rectangle", "circle", "iShape"]), width: k.between(k.number, { min: 0, exclusiveMin: true }), depth: k.between(k.number, { min: 0, exclusiveMin: true }), radius: k.between(k.number, { min: 0, exclusiveMin: true }), webThickness: k.between(k.number, { min: 0, exclusiveMin: true }), flangeThickness: k.between(k.number, { min: 0, exclusiveMin: true }), rotation: k.number, material: k.string };
+const IFC_AddDoorDto = { model: k.required(k.opaque), wall: k.required(k.string), doorType: k.required(k.string), id: k.string, name: k.string, offset: k.between(k.number, { min: 0 }), sill: k.number };
+const IFC_AddDoorTypeDto = { model: k.required(k.opaque), id: k.string, name: k.string, width: k.between(k.number, { min: 0, exclusiveMin: true }), height: k.between(k.number, { min: 0, exclusiveMin: true }), liningThickness: k.between(k.number, { min: 0, exclusiveMin: true }), liningDepth: k.between(k.number, { min: 0, exclusiveMin: true }), panelThickness: k.between(k.number, { min: 0, exclusiveMin: true }), operation: k.oneOf(["SINGLE_SWING_LEFT", "SINGLE_SWING_RIGHT", "DOUBLE_SWING_LEFT", "DOUBLE_SWING_RIGHT", "SLIDING_TO_LEFT", "SLIDING_TO_RIGHT", "FOLDING_TO_LEFT", "FOLDING_TO_RIGHT", "REVOLVING", "ROLLINGUP", "NOTDEFINED"]), liningMaterial: k.string, panelMaterial: k.string, handle: k.oneOf(["none", "lever", "pullBar"]), handleMaterial: k.string };
+const IFC_AddLayerSetDto = { model: k.required(k.opaque), name: k.string, layers: k.required(k.list(k.opaque)) };
+const IFC_AddMaterialDto = { model: k.required(k.opaque), name: k.string, category: k.string, color: k.string, transparency: k.between(k.number, { min: 0, max: 1 }) };
+const IFC_AddMemberDto = { start: k.required(k.point3), end: k.required(k.point3), predefinedType: k.oneOf(["BRACE", "CHORD", "COLLAR", "MEMBER", "MULLION", "PLATE", "POST", "PURLIN", "RAFTER", "STRINGER", "STRUT", "STUD", "NOTDEFINED"]), model: k.required(k.opaque), storey: k.required(k.string), id: k.string, name: k.string, profile: k.oneOf(["rectangle", "circle", "iShape"]), width: k.between(k.number, { min: 0, exclusiveMin: true }), depth: k.between(k.number, { min: 0, exclusiveMin: true }), radius: k.between(k.number, { min: 0, exclusiveMin: true }), webThickness: k.between(k.number, { min: 0, exclusiveMin: true }), flangeThickness: k.between(k.number, { min: 0, exclusiveMin: true }), rotation: k.number, material: k.string };
+const IFC_AddOpeningDto = { model: k.required(k.opaque), wall: k.required(k.string), id: k.string, name: k.string, offset: k.between(k.number, { min: 0 }), sill: k.number, width: k.between(k.number, { min: 0, exclusiveMin: true }), height: k.between(k.number, { min: 0, exclusiveMin: true }) };
+const IFC_AddPropertySetDto = { model: k.required(k.opaque), elements: k.required(k.list(k.string)), name: k.string, properties: k.required(k.list(k.opaque)) };
+const IFC_AddRoofDto = { model: k.required(k.opaque), storey: k.required(k.string), id: k.string, name: k.string, outline: k.required(k.list(k.point2)), kind: k.oneOf(["flat", "monoPitch", "gable", "hip"]), pitch: k.between(k.number, { min: 0, max: 89 }), thickness: k.between(k.number, { min: 0, exclusiveMin: true }), layerSet: k.string, overhang: k.between(k.number, { min: 0 }), baseOffset: k.number };
+const IFC_AddSlabDto = { model: k.required(k.opaque), storey: k.required(k.string), id: k.string, name: k.string, outline: k.required(k.list(k.point2)), holes: k.list(k.list(k.point2)), thickness: k.between(k.number, { min: 0, exclusiveMin: true }), layerSet: k.string, topOffset: k.number, predefinedType: k.oneOf(["FLOOR", "ROOF", "LANDING", "BASESLAB", "NOTDEFINED"]) };
+const IFC_AddSlabOpeningDto = { model: k.required(k.opaque), slab: k.required(k.string), id: k.string, name: k.string, outline: k.required(k.list(k.point2)) };
+const IFC_AddSpaceDto = { model: k.required(k.opaque), storey: k.required(k.string), id: k.string, name: k.string, longName: k.string, outline: k.required(k.list(k.point2)), height: k.between(k.number, { min: 0, exclusiveMin: true }), baseOffset: k.number, predefinedType: k.oneOf(["SPACE", "PARKING", "GFA", "INTERNAL", "EXTERNAL", "NOTDEFINED"]) };
+const IFC_AddStoreyDto = { model: k.required(k.opaque), id: k.string, name: k.string, elevation: k.number };
+const IFC_AddTerrainDto = { model: k.required(k.opaque), id: k.string, name: k.string, outline: k.required(k.list(k.point2)), holes: k.list(k.list(k.point2)), depth: k.between(k.number, { min: 0, exclusiveMin: true }), elevation: k.number, material: k.string };
+const IFC_AddTreeDto = { model: k.required(k.opaque), id: k.string, name: k.string, species: k.string, position: k.point2, elevation: k.number, height: k.between(k.number, { min: 0, exclusiveMin: true }), crownRadius: k.between(k.number, { min: 0, exclusiveMin: true }), trunkRadius: k.between(k.number, { min: 0, exclusiveMin: true }), crownMaterial: k.string, trunkMaterial: k.string };
+const IFC_AddWallDto = { model: k.required(k.opaque), storey: k.required(k.string), id: k.string, name: k.string, start: k.required(k.point2), end: k.required(k.point2), height: k.between(k.number, { min: 0, exclusiveMin: true }), thickness: k.between(k.number, { min: 0, exclusiveMin: true }), layerSet: k.string, alignment: k.oneOf(["center", "left", "right"]), baseOffset: k.number, wallType: k.string, predefinedType: k.oneOf(["STANDARD", "SOLIDWALL", "PARTITIONING", "SHEAR", "PARAPET", "MOVABLE", "PLUMBINGWALL", "NOTDEFINED"]) };
+const IFC_AddWallTypeDto = { model: k.required(k.opaque), id: k.string, name: k.string, layerSet: k.required(k.string), predefinedType: k.oneOf(["STANDARD", "SOLIDWALL", "PARTITIONING", "SHEAR", "PARAPET", "MOVABLE", "PLUMBINGWALL", "NOTDEFINED"]) };
+const IFC_AddWindowDto = { model: k.required(k.opaque), wall: k.required(k.string), windowType: k.required(k.string), id: k.string, name: k.string, offset: k.between(k.number, { min: 0 }), sill: k.number };
+const IFC_AddWindowTypeDto = { model: k.required(k.opaque), id: k.string, name: k.string, width: k.between(k.number, { min: 0, exclusiveMin: true }), height: k.between(k.number, { min: 0, exclusiveMin: true }), frameThickness: k.between(k.number, { min: 0, exclusiveMin: true }), frameDepth: k.between(k.number, { min: 0, exclusiveMin: true }), glassThickness: k.between(k.number, { min: 0, exclusiveMin: true }), frameMaterial: k.string, glassMaterial: k.string };
+const IFC_ClipWallByRoofDto = { model: k.required(k.opaque), wall: k.required(k.string), roof: k.required(k.string) };
+const IFC_ClipWallDto = { model: k.required(k.opaque), wall: k.required(k.string), origin: k.required(k.point3), normal: k.vector3 };
+const IFC_ComputeQuantitiesDto = { model: k.required(k.opaque), elements: k.list(k.string) };
+const IFC_ConnectWallsDto = { model: k.required(k.opaque), wall: k.required(k.string), other: k.required(k.string) };
+const IFC_CreateModelDto = { name: k.string, siteName: k.string, buildingName: k.string, lengthUnit: k.oneOf(["millimetre", "centimetre", "metre"]), seed: k.string, author: k.string, organization: k.string };
+const IFC_EditOpeningDto = { model: k.required(k.opaque), opening: k.required(k.string), offset: k.between(k.number, { min: 0 }), sill: k.number, width: k.between(k.number, { min: 0, exclusiveMin: true }), height: k.between(k.number, { min: 0, exclusiveMin: true }) };
+const IFC_EditWallDto = { model: k.required(k.opaque), wall: k.required(k.string), start: k.point2, end: k.point2, height: k.between(k.number, { min: 0, exclusiveMin: true }), baseOffset: k.number, thickness: k.between(k.number, { min: 0, exclusiveMin: true }), layerSet: k.string, alignment: k.oneOf(["center", "left", "right"]) };
+const IFC_ElementDto = { model: k.required(k.opaque), element: k.required(k.string) };
+const IFC_ElementsDto = { model: k.required(k.opaque), type: k.string, storey: k.string };
+const IFC_GeometryDto = { model: k.required(k.opaque), elements: k.list(k.string), groupByClass: k.boolean };
+const IFC_GeometryElementsDto = { model: k.required(k.opaque), elements: k.list(k.string) };
+const IFC_GetAttributeDto = { model: k.required(k.opaque), element: k.required(k.string), attribute: k.string };
+const IFC_GlobalIdOfDto = { model: k.required(k.opaque), id: k.required(k.string) };
+const IFC_ModelDto = { model: k.required(k.opaque) };
+const IFC_MoveElementDto = { model: k.required(k.opaque), element: k.required(k.string), translation: k.vector3, rotation: k.number };
+const IFC_ReadModelDto = { data: k.required(k.opaque) };
+const IFC_RemovePropertySetDto = { model: k.required(k.opaque), element: k.required(k.string), name: k.string };
+const IFC_RemovePropertyValuesDto = { model: k.required(k.opaque), element: k.required(k.string), name: k.string, names: k.required(k.list(k.string)) };
+const IFC_SetAttributeDto = { model: k.required(k.opaque), element: k.required(k.string), attribute: k.string, value: k.required(k.opaque) };
+const IFC_SetPropertyValuesDto = { model: k.required(k.opaque), element: k.required(k.string), name: k.string, properties: k.required(k.list(k.opaque)) };
+const IFC_SetStoreyElevationDto = { model: k.required(k.opaque), storey: k.required(k.string), elevation: k.number };
+const IFC_SpacesDto = { model: k.required(k.opaque), storey: k.string };
+const IFC_WallDto = { model: k.required(k.opaque), wall: k.required(k.string) };
+const IFC_WriteModelDto = { model: k.required(k.opaque), fileName: k.string, timeStamp: k.string };
+/**
+ * Every public operation of the IFC kernel by its dotted path, the inputs DTO it
+ * takes, and what each property of that DTO accepts. `resolveInputs` from the base package reads
+ * it to lay a caller's properties over that DTO's defaults before the kernel runs, and
+ * `validateInputs` to check what the call was given.
+ */
+export const ifcDtoRegistry = {
+    "assemblies.add": { dto: Inputs.IFC.AddAssemblyDto, constraints: IFC_AddAssemblyDto },
+    "beams.add": { dto: Inputs.IFC.AddBeamDto, constraints: IFC_AddBeamDto },
+    "columns.add": { dto: Inputs.IFC.AddColumnDto, constraints: IFC_AddColumnDto },
+    "doors.add": { dto: Inputs.IFC.AddDoorDto, constraints: IFC_AddDoorDto },
+    "doors.addType": { dto: Inputs.IFC.AddDoorTypeDto, constraints: IFC_AddDoorTypeDto },
+    "geometry.recipe": { dto: Inputs.IFC.GeometryDto, constraints: IFC_GeometryDto },
+    "geometry.unsupported": { dto: Inputs.IFC.GeometryElementsDto, constraints: IFC_GeometryElementsDto },
+    "materials.add": { dto: Inputs.IFC.AddMaterialDto, constraints: IFC_AddMaterialDto },
+    "materials.addLayerSet": { dto: Inputs.IFC.AddLayerSetDto, constraints: IFC_AddLayerSetDto },
+    "members.add": { dto: Inputs.IFC.AddMemberDto, constraints: IFC_AddMemberDto },
+    "model.create": { dto: Inputs.IFC.CreateModelDto, constraints: IFC_CreateModelDto },
+    "model.element": { dto: Inputs.IFC.ElementDto, constraints: IFC_ElementDto },
+    "model.elements": { dto: Inputs.IFC.ElementsDto, constraints: IFC_ElementsDto },
+    "model.georeference": { dto: Inputs.IFC.ModelDto, constraints: IFC_ModelDto },
+    "model.getAttribute": { dto: Inputs.IFC.GetAttributeDto, constraints: IFC_GetAttributeDto },
+    "model.globalIdOf": { dto: Inputs.IFC.GlobalIdOfDto, constraints: IFC_GlobalIdOfDto },
+    "model.move": { dto: Inputs.IFC.MoveElementDto, constraints: IFC_MoveElementDto },
+    "model.read": { dto: Inputs.IFC.ReadModelDto, constraints: IFC_ReadModelDto },
+    "model.remove": { dto: Inputs.IFC.ElementDto, constraints: IFC_ElementDto },
+    "model.setAttribute": { dto: Inputs.IFC.SetAttributeDto, constraints: IFC_SetAttributeDto },
+    "model.summary": { dto: Inputs.IFC.ModelDto, constraints: IFC_ModelDto },
+    "model.upgradeToIfc4": { dto: Inputs.IFC.ModelDto, constraints: IFC_ModelDto },
+    "model.write": { dto: Inputs.IFC.WriteModelDto, constraints: IFC_WriteModelDto },
+    "model.writeBytes": { dto: Inputs.IFC.WriteModelDto, constraints: IFC_WriteModelDto },
+    "openings.add": { dto: Inputs.IFC.AddOpeningDto, constraints: IFC_AddOpeningDto },
+    "openings.addInSlab": { dto: Inputs.IFC.AddSlabOpeningDto, constraints: IFC_AddSlabOpeningDto },
+    "openings.edit": { dto: Inputs.IFC.EditOpeningDto, constraints: IFC_EditOpeningDto },
+    "properties.addSet": { dto: Inputs.IFC.AddPropertySetDto, constraints: IFC_AddPropertySetDto },
+    "properties.getSets": { dto: Inputs.IFC.ElementDto, constraints: IFC_ElementDto },
+    "properties.removeSet": { dto: Inputs.IFC.RemovePropertySetDto, constraints: IFC_RemovePropertySetDto },
+    "properties.removeValues": { dto: Inputs.IFC.RemovePropertyValuesDto, constraints: IFC_RemovePropertyValuesDto },
+    "properties.setValues": { dto: Inputs.IFC.SetPropertyValuesDto, constraints: IFC_SetPropertyValuesDto },
+    "quantities.compute": { dto: Inputs.IFC.ComputeQuantitiesDto, constraints: IFC_ComputeQuantitiesDto },
+    "quantities.get": { dto: Inputs.IFC.ElementDto, constraints: IFC_ElementDto },
+    "roofs.add": { dto: Inputs.IFC.AddRoofDto, constraints: IFC_AddRoofDto },
+    "site.addTerrain": { dto: Inputs.IFC.AddTerrainDto, constraints: IFC_AddTerrainDto },
+    "site.addTree": { dto: Inputs.IFC.AddTreeDto, constraints: IFC_AddTreeDto },
+    "slabs.add": { dto: Inputs.IFC.AddSlabDto, constraints: IFC_AddSlabDto },
+    "spaces.add": { dto: Inputs.IFC.AddSpaceDto, constraints: IFC_AddSpaceDto },
+    "spaces.list": { dto: Inputs.IFC.SpacesDto, constraints: IFC_SpacesDto },
+    "spatial.addStorey": { dto: Inputs.IFC.AddStoreyDto, constraints: IFC_AddStoreyDto },
+    "spatial.setElevation": { dto: Inputs.IFC.SetStoreyElevationDto, constraints: IFC_SetStoreyElevationDto },
+    "spatial.storeys": { dto: Inputs.IFC.ModelDto, constraints: IFC_ModelDto },
+    "walls.add": { dto: Inputs.IFC.AddWallDto, constraints: IFC_AddWallDto },
+    "walls.addType": { dto: Inputs.IFC.AddWallTypeDto, constraints: IFC_AddWallTypeDto },
+    "walls.clipByPlane": { dto: Inputs.IFC.ClipWallDto, constraints: IFC_ClipWallDto },
+    "walls.clipByRoof": { dto: Inputs.IFC.ClipWallByRoofDto, constraints: IFC_ClipWallByRoofDto },
+    "walls.connect": { dto: Inputs.IFC.ConnectWallsDto, constraints: IFC_ConnectWallsDto },
+    "walls.disconnect": { dto: Inputs.IFC.ConnectWallsDto, constraints: IFC_ConnectWallsDto },
+    "walls.edit": { dto: Inputs.IFC.EditWallDto, constraints: IFC_EditWallDto },
+    "walls.parameters": { dto: Inputs.IFC.WallDto, constraints: IFC_WallDto },
+    "windows.add": { dto: Inputs.IFC.AddWindowDto, constraints: IFC_AddWindowDto },
+    "windows.addType": { dto: Inputs.IFC.AddWindowTypeDto, constraints: IFC_AddWindowTypeDto },
+};

package/lib/api/ifc-service.d.ts

@@ -0,0 +1,109 @@
+import { IFCAssemblies } from "./services/assemblies";
+import { IFCBeams } from "./services/beams";
+import { IFCColumns } from "./services/columns";
+import { IFCDoors } from "./services/doors";
+import { IFCGeometry } from "./services/geometry";
+import { IFCMaterials } from "./services/materials";
+import { IFCMembers } from "./services/members";
+import { IFCModels } from "./services/model";
+import { IFCOpenings } from "./services/openings";
+import { IFCProperties } from "./services/properties";
+import { IFCQuantities } from "./services/quantities";
+import { IFCRoofs } from "./services/roofs";
+import { IFCSite } from "./services/site";
+import { IFCSlabs } from "./services/slabs";
+import { IFCSpaces } from "./services/spaces";
+import { IFCSpatial } from "./services/spatial";
+import { IFCWalls } from "./services/walls";
+import { IFCWindows } from "./services/windows";
+/**
+ * The entry point to IFC, the open BIM exchange format: `model` creates, reads, writes and edits
+ * models; `spatial`, `spaces`, `materials` and `site` add storeys, rooms, materials and the terrain;
+ * `walls`, `openings`, `doors`, `windows`, `slabs`, `roofs`, `columns`, `beams` and `members` add
+ * elements, `assemblies` groups them; `properties` attaches property sets, `quantities` measures, and `geometry` describes
+ * elements as a recipe a kernel builds.
+ *
+ * A model is a value: every method that changes one returns a new model and leaves the one it was
+ * given as it was. Elements are parametric IFC4 that other BIM tools edit as walls, slabs and doors.
+ * Experimental: names and inputs may still change before the first stable version.
+ * @beta
+ */
+export declare class IFCService {
+    /**
+     * Creates, reads, writes and summarizes models, reads and sets single attributes, and moves and
+     * removes objects.
+     */
+    readonly model: IFCModels;
+    /**
+     * Adds storeys to a model's building, raises or lowers them, and lists them.
+     */
+    readonly spatial: IFCSpatial;
+    /**
+     * Adds rooms and areas to storeys and lists them with their areas.
+     */
+    readonly spaces: IFCSpaces;
+    /**
+     * Adds materials with their colours, and layer sets that walls and slabs are made of.
+     */
+    readonly materials: IFCMaterials;
+    /**
+     * Adds walls, joins them at their corners and clips them under roofs.
+     */
+    readonly walls: IFCWalls;
+    /**
+     * Cuts openings through walls and slabs, and moves them along their walls.
+     */
+    readonly openings: IFCOpenings;
+    /**
+     * Adds door types and doors placed in walls.
+     */
+    readonly doors: IFCDoors;
+    /**
+     * Adds window types and windows placed in walls.
+     */
+    readonly windows: IFCWindows;
+    /**
+     * Adds floors, roofs and landings.
+     */
+    readonly slabs: IFCSlabs;
+    /**
+     * Adds flat, mono-pitch, gable and hip roofs over rectangles.
+     */
+    readonly roofs: IFCRoofs;
+    /**
+     * Adds the site's terrain and trees.
+     */
+    readonly site: IFCSite;
+    /**
+     * Adds columns standing on a storey.
+     */
+    readonly columns: IFCColumns;
+    /**
+     * Adds beams between two points.
+     */
+    readonly beams: IFCBeams;
+    /**
+     * Adds braces, rafters, studs, mullions and other members between two points.
+     */
+    readonly members: IFCMembers;
+    /**
+     * Makes elements of the model the parts of an assembly, such as a facade's cladding boards.
+     */
+    readonly assemblies: IFCAssemblies;
+    /**
+     * Attaches property sets to objects and types, sets and removes their values, and reads them back.
+     */
+    readonly properties: IFCProperties;
+    /**
+     * Measures elements and writes and reads their base quantity sets.
+     */
+    readonly quantities: IFCQuantities;
+    /**
+     * Describes elements as a recipe a geometry kernel builds into solids.
+     */
+    readonly geometry: IFCGeometry;
+    /**
+     * Makes the entry point with every part of the IFC library.
+     */
+    constructor();
+}

package/lib/api/ifc-service.js

@@ -0,0 +1,55 @@
+import { IFCAssemblies } from "./services/assemblies";
+import { IFCBeams } from "./services/beams";
+import { IFCColumns } from "./services/columns";
+import { IFCDoors } from "./services/doors";
+import { IFCGeometry } from "./services/geometry";
+import { IFCMaterials } from "./services/materials";
+import { IFCMembers } from "./services/members";
+import { IFCModels } from "./services/model";
+import { IFCOpenings } from "./services/openings";
+import { IFCProperties } from "./services/properties";
+import { IFCQuantities } from "./services/quantities";
+import { IFCRoofs } from "./services/roofs";
+import { IFCSite } from "./services/site";
+import { IFCSlabs } from "./services/slabs";
+import { IFCSpaces } from "./services/spaces";
+import { IFCSpatial } from "./services/spatial";
+import { IFCWalls } from "./services/walls";
+import { IFCWindows } from "./services/windows";
+/**
+ * The entry point to IFC, the open BIM exchange format: `model` creates, reads, writes and edits
+ * models; `spatial`, `spaces`, `materials` and `site` add storeys, rooms, materials and the terrain;
+ * `walls`, `openings`, `doors`, `windows`, `slabs`, `roofs`, `columns`, `beams` and `members` add
+ * elements, `assemblies` groups them; `properties` attaches property sets, `quantities` measures, and `geometry` describes
+ * elements as a recipe a kernel builds.
+ *
+ * A model is a value: every method that changes one returns a new model and leaves the one it was
+ * given as it was. Elements are parametric IFC4 that other BIM tools edit as walls, slabs and doors.
+ * Experimental: names and inputs may still change before the first stable version.
+ * @beta
+ */
+export class IFCService {
+    /**
+     * Makes the entry point with every part of the IFC library.
+     */
+    constructor() {
+        this.model = new IFCModels();
+        this.spatial = new IFCSpatial();
+        this.spaces = new IFCSpaces();
+        this.materials = new IFCMaterials();
+        this.walls = new IFCWalls();
+        this.openings = new IFCOpenings();
+        this.doors = new IFCDoors();
+        this.windows = new IFCWindows();
+        this.slabs = new IFCSlabs();
+        this.roofs = new IFCRoofs();
+        this.site = new IFCSite();
+        this.columns = new IFCColumns();
+        this.beams = new IFCBeams();
+        this.members = new IFCMembers();
+        this.assemblies = new IFCAssemblies();
+        this.properties = new IFCProperties();
+        this.quantities = new IFCQuantities();
+        this.geometry = new IFCGeometry();
+    }
+}

package/lib/api/inputs/base-inputs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Re-export Base namespace from @bitbybit-dev/base.
+ * IFC package uses the same foundational types without additions.
+ */
+export { Base } from "@bitbybit-dev/base";

package/lib/api/inputs/base-inputs.js

@@ -0,0 +1,5 @@
+/**
+ * Re-export Base namespace from @bitbybit-dev/base.
+ * IFC package uses the same foundational types without additions.
+ */
+export { Base } from "@bitbybit-dev/base";