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

package/lib/api/inputs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ifc-inputs";
+export * from "./base-inputs";
+export * from "@bitbybit-dev/base/lib/api/inputs";

package/lib/api/inputs/index.js

@@ -0,0 +1,3 @@
+export * from "./ifc-inputs";
+export * from "./base-inputs";
+export * from "@bitbybit-dev/base/lib/api/inputs";

package/lib/api/resolved-inputs/index.d.ts

@@ -0,0 +1,70 @@
+import { WithDefaults } from "@bitbybit-dev/base";
+import * as Inputs from "../inputs";
+export * from "@bitbybit-dev/base/lib/api/resolved-inputs";
+/**
+ * The IFC inputs DTOs as their defaults leave them: every property with a default is present,
+ * the way `resolveDto` hands a DTO to the code that reads it.
+ */
+export declare namespace IFC {
+    type AddAssemblyDto<T> = WithDefaults<Inputs.IFC.AddAssemblyDto<T>, "predefinedType">;
+    type AddBeamDto<T> = WithDefaults<Inputs.IFC.AddBeamDto<T>, "profile" | "rotation">;
+    type AddColumnDto<T> = WithDefaults<Inputs.IFC.AddColumnDto<T>, "position" | "baseOffset" | "profile" | "rotation">;
+    type AddDoorDto<T> = WithDefaults<Inputs.IFC.AddDoorDto<T>, "sill">;
+    type AddDoorTypeDto<T> = WithDefaults<Inputs.IFC.AddDoorTypeDto<T>, "name" | "operation" | "handle">;
+    type AddLayerSetDto<T> = WithDefaults<Inputs.IFC.AddLayerSetDto<T>, "name">;
+    type AddMaterialDto<T> = WithDefaults<Inputs.IFC.AddMaterialDto<T>, "name" | "transparency">;
+    type AddMemberDto<T> = WithDefaults<Inputs.IFC.AddMemberDto<T>, "predefinedType" | "profile" | "rotation">;
+    type AddOpeningDto<T> = WithDefaults<Inputs.IFC.AddOpeningDto<T>, "sill">;
+    type AddPropertySetDto<T> = WithDefaults<Inputs.IFC.AddPropertySetDto<T>, "name">;
+    type AddRoofDto<T> = WithDefaults<Inputs.IFC.AddRoofDto<T>, "kind" | "pitch" | "overhang" | "baseOffset">;
+    type AddSlabDto<T> = WithDefaults<Inputs.IFC.AddSlabDto<T>, "topOffset" | "predefinedType">;
+    type AddSlabOpeningDto<T> = Inputs.IFC.AddSlabOpeningDto<T>;
+    type AddSpaceDto<T> = WithDefaults<Inputs.IFC.AddSpaceDto<T>, "baseOffset" | "predefinedType">;
+    type AddStoreyDto<T> = WithDefaults<Inputs.IFC.AddStoreyDto<T>, "name" | "elevation">;
+    type AddTerrainDto<T> = WithDefaults<Inputs.IFC.AddTerrainDto<T>, "name" | "elevation">;
+    type AddTreeDto<T> = WithDefaults<Inputs.IFC.AddTreeDto<T>, "name" | "species" | "position" | "elevation">;
+    type AddWallDto<T> = WithDefaults<Inputs.IFC.AddWallDto<T>, "alignment" | "baseOffset" | "predefinedType">;
+    type AddWallTypeDto<T> = WithDefaults<Inputs.IFC.AddWallTypeDto<T>, "name" | "predefinedType">;
+    type AddWindowDto<T> = Inputs.IFC.AddWindowDto<T>;
+    type AddWindowTypeDto<T> = WithDefaults<Inputs.IFC.AddWindowTypeDto<T>, "name">;
+    type ClipWallByRoofDto<T> = Inputs.IFC.ClipWallByRoofDto<T>;
+    type ClipWallDto<T> = WithDefaults<Inputs.IFC.ClipWallDto<T>, "normal">;
+    type ComputeQuantitiesDto<T> = Inputs.IFC.ComputeQuantitiesDto<T>;
+    type ConnectWallsDto<T> = Inputs.IFC.ConnectWallsDto<T>;
+    type CreateModelDto = WithDefaults<Inputs.IFC.CreateModelDto, "name" | "siteName" | "buildingName" | "lengthUnit">;
+    type EditOpeningDto<T> = Inputs.IFC.EditOpeningDto<T>;
+    type EditWallDto<T> = Inputs.IFC.EditWallDto<T>;
+    type ElementDto<T> = Inputs.IFC.ElementDto<T>;
+    type ElementInfoDto = WithDefaults<Inputs.IFC.ElementInfoDto, "globalId" | "type" | "name" | "storey">;
+    type ElementsDto<T> = WithDefaults<Inputs.IFC.ElementsDto<T>, "type">;
+    type GeometryDto<T> = WithDefaults<Inputs.IFC.GeometryDto<T>, "groupByClass">;
+    type GeometryElementsDto<T> = Inputs.IFC.GeometryElementsDto<T>;
+    type GeometryProblemDto = WithDefaults<Inputs.IFC.GeometryProblemDto, "globalId" | "type" | "message">;
+    type GeometryToDocumentDto<T> = WithDefaults<Inputs.IFC.GeometryToDocumentDto<T>, "name" | "emptyWhenFailed" | "facetedMeshes" | "maxTriangles" | "groupByClass">;
+    type GeometryToShapesDto<T> = WithDefaults<Inputs.IFC.GeometryToShapesDto<T>, "adjustZtoY" | "emptyWhenFailed" | "facetedMeshes" | "maxTriangles">;
+    type GeometryToStepDto<T> = WithDefaults<Inputs.IFC.GeometryToStepDto<T>, "name" | "fileName" | "emptyWhenFailed" | "facetedMeshes" | "maxTriangles" | "compress" | "tryDownload" | "groupByClass">;
+    type GeoreferenceDto = WithDefaults<Inputs.IFC.GeoreferenceDto, "mapped" | "crs" | "eastings" | "northings" | "orthogonalHeight" | "xAxisAbscissa" | "xAxisOrdinate" | "scale" | "located" | "latitude" | "longitude" | "elevation">;
+    type GetAttributeDto<T> = WithDefaults<Inputs.IFC.GetAttributeDto<T>, "attribute">;
+    type GlobalIdOfDto<T> = Inputs.IFC.GlobalIdOfDto<T>;
+    type MaterialLayerDto = Inputs.IFC.MaterialLayerDto;
+    type MemberSharedDto<T> = WithDefaults<Inputs.IFC.MemberSharedDto<T>, "profile" | "rotation">;
+    type ModelDto<T> = Inputs.IFC.ModelDto<T>;
+    type ModelSummaryDto = WithDefaults<Inputs.IFC.ModelSummaryDto, "schema" | "editable" | "project" | "millimetresPerUnit" | "entities" | "storeys" | "elementCounts">;
+    type MoveElementDto<T> = WithDefaults<Inputs.IFC.MoveElementDto<T>, "translation" | "rotation">;
+    type PropertyDto = WithDefaults<Inputs.IFC.PropertyDto, "name">;
+    type PropertySetInfoDto = WithDefaults<Inputs.IFC.PropertySetInfoDto, "name" | "properties">;
+    type QuantitySetInfoDto = WithDefaults<Inputs.IFC.QuantitySetInfoDto, "name" | "quantities">;
+    type ReadModelDto = Inputs.IFC.ReadModelDto;
+    type RemovePropertySetDto<T> = WithDefaults<Inputs.IFC.RemovePropertySetDto<T>, "name">;
+    type RemovePropertyValuesDto<T> = WithDefaults<Inputs.IFC.RemovePropertyValuesDto<T>, "name">;
+    type SetAttributeDto<T> = WithDefaults<Inputs.IFC.SetAttributeDto<T>, "attribute">;
+    type SetPropertyValuesDto<T> = WithDefaults<Inputs.IFC.SetPropertyValuesDto<T>, "name">;
+    type SetStoreyElevationDto<T> = WithDefaults<Inputs.IFC.SetStoreyElevationDto<T>, "elevation">;
+    type SpaceInfoDto = WithDefaults<Inputs.IFC.SpaceInfoDto, "globalId" | "name" | "longName" | "storey" | "area" | "height">;
+    type SpacesDto<T> = Inputs.IFC.SpacesDto<T>;
+    type StoreyInfoDto = WithDefaults<Inputs.IFC.StoreyInfoDto, "globalId" | "name" | "elevation">;
+    type WallDto<T> = Inputs.IFC.WallDto<T>;
+    type WallJoinInfoDto = WithDefaults<Inputs.IFC.WallJoinInfoDto, "other" | "at" | "otherAt">;
+    type WallParametersDto = WithDefaults<Inputs.IFC.WallParametersDto, "globalId" | "name" | "storey" | "start" | "end" | "height" | "baseOffset" | "thickness" | "offset" | "alignment" | "layerSet" | "wallType" | "joins" | "openings" | "clippings">;
+    type WriteModelDto<T> = WithDefaults<Inputs.IFC.WriteModelDto<T>, "fileName">;
+}

package/lib/api/resolved-inputs/index.js

@@ -0,0 +1 @@
+export * from "@bitbybit-dev/base/lib/api/resolved-inputs";

package/lib/api/services/assemblies.d.ts

@@ -0,0 +1,28 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Assemblies: elements made of other elements, such as a facade's cladding boards or a truss's
+ * members, which other tools list as one element with its parts and the STEP export of a model
+ * nests as one assembly.
+ * @beta
+ */
+export declare class IFCAssemblies {
+    /**
+     * Makes elements the parts of a new assembly standing in their storey in their place. The parts
+     * keep their geometry and placement and stand in the model through it; removing the assembly
+     * removes them.
+     *
+     * They must share one storey, or other part of the structure, and belong to no other assembly;
+     * openings cannot be parts.
+     * @param inputs - The model, the parts, and the assembly's id, name and kind
+     * @returns A new model with the assembly
+     * @group create
+     * @shortname add assembly
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.assemblies.add({ model, parts: ["board-1", "board-2", "board-3"], id: "south-cladding", name: "South cladding", predefinedType: Bit.Inputs.IFC.elementAssemblyPredefinedTypeEnum.userDefined, objectType: "Cladding" });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddAssemblyDto<IfcModel>): IfcModel;
+}

package/lib/api/services/assemblies.js

@@ -0,0 +1,49 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { createAssembly } from "../../build/assemblies";
+import * as Inputs from "../inputs";
+import { editModel, modelOf, oneOf, resolveId } from "./service-support";
+/**
+ * Assemblies: elements made of other elements, such as a facade's cladding boards or a truss's
+ * members, which other tools list as one element with its parts and the STEP export of a model
+ * nests as one assembly.
+ * @beta
+ */
+export class IFCAssemblies {
+    /**
+     * Makes elements the parts of a new assembly standing in their storey in their place. The parts
+     * keep their geometry and placement and stand in the model through it; removing the assembly
+     * removes them.
+     *
+     * They must share one storey, or other part of the structure, and belong to no other assembly;
+     * openings cannot be parts.
+     * @param inputs - The model, the parts, and the assembly's id, name and kind
+     * @returns A new model with the assembly
+     * @group create
+     * @shortname add assembly
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.assemblies.add({ model, parts: ["board-1", "board-2", "board-3"], id: "south-cladding", name: "South cladding", predefinedType: Bit.Inputs.IFC.elementAssemblyPredefinedTypeEnum.userDefined, objectType: "Cladding" });
+     * ```
+     */
+    add(inputs) {
+        var _a;
+        const resolved = resolveDto(Inputs.IFC.AddAssemblyDto, inputs);
+        const model = modelOf(resolved.model);
+        if (!Array.isArray(resolved.parts) || resolved.parts.length === 0) {
+            throw new TypeError("Expected the parts as a list of at least one element's GlobalId or id");
+        }
+        const parts = resolved.parts.map((part) => resolveId(model, part, "IfcElement", "part"));
+        if (new Set(parts).size !== parts.length) {
+            throw new Error("The parts name one element more than once");
+        }
+        const predefinedType = oneOf(resolved.predefinedType, Inputs.IFC.elementAssemblyPredefinedTypeEnum, "predefined type");
+        const objectType = ((_a = resolved.objectType) === null || _a === void 0 ? void 0 : _a.trim()) || undefined;
+        if (predefinedType === Inputs.IFC.elementAssemblyPredefinedTypeEnum.userDefined && objectType === undefined) {
+            throw new Error("A userDefined assembly needs an objectType that says what kind it is, such as Cladding");
+        }
+        return editModel(model, (tx, writer) => {
+            createAssembly(tx, writer, { parts, id: resolved.id, name: resolved.name, predefinedType, objectType });
+        });
+    }
+}

package/lib/api/services/beams.d.ts

@@ -0,0 +1,33 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Beams: sections swept straight between two points of a storey, each a rectangle, a circle or an I
+ * section centred on the line between them.
+ * @beta
+ */
+export declare class IFCBeams {
+    /**
+     * Adds a beam from `start` to `end` in a storey, its section centred on the line between them.
+     *
+     * The section's Y points up, so an I section stands upright on a level beam; `rotation` turns it
+     * about the beam's axis. The section is chosen by `profile` as for columns.
+     * @param inputs - The model, the storey, the two ends and the section
+     * @returns A new model with the beam
+     * @group create
+     * @shortname add beam
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.beams.add({
+     *     model,
+     *     storey: "first",
+     *     start: [0, 4000, 2850],
+     *     end: [10000, 4000, 2850],
+     *     profile: Bit.Inputs.IFC.profileKindEnum.iShape,
+     *     width: 150,
+     *     depth: 300,
+     * });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddBeamDto<IfcModel>): IfcModel;
+}

package/lib/api/services/beams.js

@@ -0,0 +1,59 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { POINT3_SIZE } from "../../build/constants";
+import { createMember } from "../../build/slabs-columns-beams";
+import * as Inputs from "../inputs";
+import { requirePoint } from "../../build/checks";
+import { editModel, modelOf, resolveId } from "./service-support";
+import { finiteRotation, memberMaterial, profileOf } from "./member-support";
+/**
+ * Beams: sections swept straight between two points of a storey, each a rectangle, a circle or an I
+ * section centred on the line between them.
+ * @beta
+ */
+export class IFCBeams {
+    /**
+     * Adds a beam from `start` to `end` in a storey, its section centred on the line between them.
+     *
+     * The section's Y points up, so an I section stands upright on a level beam; `rotation` turns it
+     * about the beam's axis. The section is chosen by `profile` as for columns.
+     * @param inputs - The model, the storey, the two ends and the section
+     * @returns A new model with the beam
+     * @group create
+     * @shortname add beam
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.beams.add({
+     *     model,
+     *     storey: "first",
+     *     start: [0, 4000, 2850],
+     *     end: [10000, 4000, 2850],
+     *     profile: Bit.Inputs.IFC.profileKindEnum.iShape,
+     *     width: 150,
+     *     depth: 300,
+     * });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddBeamDto, inputs);
+        const model = modelOf(resolved.model);
+        requirePoint(resolved.start, POINT3_SIZE, "start");
+        requirePoint(resolved.end, POINT3_SIZE, "end");
+        finiteRotation(resolved.rotation);
+        const profile = profileOf(model, resolved);
+        const storey = resolveId(model, resolved.storey, "IfcBuildingStorey", "storey");
+        return editModel(model, (tx, writer) => {
+            createMember(tx, writer, "IfcBeam", {
+                storey,
+                id: resolved.id,
+                name: resolved.name,
+                start: resolved.start,
+                end: resolved.end,
+                profile,
+                rotation: resolved.rotation,
+                material: memberMaterial(tx, resolved.material),
+                predefinedType: "BEAM",
+            });
+        });
+    }
+}

package/lib/api/services/columns.d.ts

@@ -0,0 +1,26 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Columns: sections standing upright on a storey, each a rectangle, a circle or an I section
+ * extruded up by the column's height.
+ * @beta
+ */
+export declare class IFCColumns {
+    /**
+     * Adds a column standing on `position` in a storey's plan, its section centred on that point and
+     * extruded `height` up from `baseOffset` above the floor.
+     *
+     * `profile` picks the section: a rectangle reads `width` and `depth`, a circle `radius`, an I
+     * section also `webThickness` and `flangeThickness`. `rotation` turns it about the axis.
+     * @param inputs - The model, the storey, the position, the height and the section
+     * @returns A new model with the column
+     * @group create
+     * @shortname add column
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.columns.add({ model, storey: "ground", position: [5000, 4000], height: 2700, width: 300, depth: 300 });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddColumnDto<IfcModel>): IfcModel;
+}

package/lib/api/services/columns.js

@@ -0,0 +1,56 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { createMember } from "../../build/slabs-columns-beams";
+import * as Inputs from "../inputs";
+import { requireFinite, requirePoint, requirePositive } from "../../build/checks";
+import { POINT2_SIZE } from "../../build/constants";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, modelOf, resolveId } from "./service-support";
+import { finiteRotation, memberMaterial, profileOf } from "./member-support";
+/**
+ * Columns: sections standing upright on a storey, each a rectangle, a circle or an I section
+ * extruded up by the column's height.
+ * @beta
+ */
+export class IFCColumns {
+    /**
+     * Adds a column standing on `position` in a storey's plan, its section centred on that point and
+     * extruded `height` up from `baseOffset` above the floor.
+     *
+     * `profile` picks the section: a rectangle reads `width` and `depth`, a circle `radius`, an I
+     * section also `webThickness` and `flangeThickness`. `rotation` turns it about the axis.
+     * @param inputs - The model, the storey, the position, the height and the section
+     * @returns A new model with the column
+     * @group create
+     * @shortname add column
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.columns.add({ model, storey: "ground", position: [5000, 4000], height: 2700, width: 300, depth: 300 });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddColumnDto, inputs);
+        const model = modelOf(resolved.model);
+        const position = resolved.position;
+        requirePoint(position, POINT2_SIZE, "position");
+        const height = lengthIn(model, resolved.height, DEFAULT_MILLIMETRES.columnHeight);
+        requirePositive(height, "column's height");
+        requireFinite(resolved.baseOffset, "column's base offset");
+        finiteRotation(resolved.rotation);
+        const profile = profileOf(model, resolved);
+        const storey = resolveId(model, resolved.storey, "IfcBuildingStorey", "storey");
+        return editModel(model, (tx, writer) => {
+            createMember(tx, writer, "IfcColumn", {
+                storey,
+                id: resolved.id,
+                name: resolved.name,
+                start: [position[0], position[1], resolved.baseOffset],
+                end: [position[0], position[1], resolved.baseOffset + height],
+                profile,
+                rotation: resolved.rotation,
+                material: memberMaterial(tx, resolved.material),
+                predefinedType: "COLUMN",
+            });
+        });
+    }
+}

package/lib/api/services/defaults.constants.d.ts

@@ -0,0 +1,44 @@
+export declare const DEFAULT_MILLIMETRES: {
+    readonly wallHeight: 3000;
+    readonly spaceHeight: 3000;
+    readonly wallThickness: 200;
+    readonly slabThickness: 200;
+    readonly layerThickness: 100;
+    readonly columnHeight: 3000;
+    readonly sectionWidth: 300;
+    readonly sectionDepth: 300;
+    readonly sectionRadius: 150;
+    readonly webThickness: 10;
+    readonly flangeThickness: 15;
+    readonly openingOffset: 1000;
+    readonly openingWidth: 1000;
+    readonly openingHeight: 2000;
+    readonly doorWidth: 900;
+    readonly doorHeight: 2100;
+    readonly liningThickness: 50;
+    readonly liningDepth: 100;
+    readonly panelThickness: 40;
+    readonly windowWidth: 1200;
+    readonly windowHeight: 1200;
+    readonly windowSill: 900;
+    readonly frameThickness: 60;
+    readonly frameDepth: 80;
+    readonly glassThickness: 24;
+    readonly terrainDepth: 1000;
+    readonly treeHeight: 8000;
+    readonly crownRadius: 2500;
+    readonly trunkRadius: 150;
+};
+export declare const HANDLE_MILLIMETRES: {
+    readonly inset: 75;
+    readonly leverHeight: 1050;
+    readonly leverStandoff: 45;
+    readonly leverSection: 20;
+    readonly leverLength: 130;
+    readonly pullBarLength: 1200;
+    readonly pullBarMiddle: 1100;
+    readonly pullBarStandoff: 50;
+    readonly pullBarSection: 30;
+    readonly pullBarPost: 20;
+    readonly pullBarPostInset: 80;
+};

package/lib/api/services/defaults.constants.js

@@ -0,0 +1,44 @@
+export const DEFAULT_MILLIMETRES = {
+    wallHeight: 3000,
+    spaceHeight: 3000,
+    wallThickness: 200,
+    slabThickness: 200,
+    layerThickness: 100,
+    columnHeight: 3000,
+    sectionWidth: 300,
+    sectionDepth: 300,
+    sectionRadius: 150,
+    webThickness: 10,
+    flangeThickness: 15,
+    openingOffset: 1000,
+    openingWidth: 1000,
+    openingHeight: 2000,
+    doorWidth: 900,
+    doorHeight: 2100,
+    liningThickness: 50,
+    liningDepth: 100,
+    panelThickness: 40,
+    windowWidth: 1200,
+    windowHeight: 1200,
+    windowSill: 900,
+    frameThickness: 60,
+    frameDepth: 80,
+    glassThickness: 24,
+    terrainDepth: 1000,
+    treeHeight: 8000,
+    crownRadius: 2500,
+    trunkRadius: 150,
+};
+export const HANDLE_MILLIMETRES = {
+    inset: 75,
+    leverHeight: 1050,
+    leverStandoff: 45,
+    leverSection: 20,
+    leverLength: 130,
+    pullBarLength: 1200,
+    pullBarMiddle: 1100,
+    pullBarStandoff: 50,
+    pullBarSection: 30,
+    pullBarPost: 20,
+    pullBarPostInset: 80,
+};

package/lib/api/services/doors.d.ts

@@ -0,0 +1,45 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Doors: door types, each a lining around one panel, and doors of those types placed in walls. A
+ * door cuts its own opening and shares its type's geometry, so a type placed many times is written
+ * once.
+ * @beta
+ */
+export declare class IFCDoors {
+    /**
+     * Adds a door type: a lining around one panel, `width` by `height`, which doors are then placed
+     * from.
+     *
+     * The lining's sides and head are `liningThickness` wide and `liningDepth` deep; the panel sits
+     * in the middle of the depth. A `handle` goes on both faces, away from the hinges. Materials give
+     * the lining, panel and handle their colours.
+     * @param inputs - The model, the type's id and name, its sizes and how it opens
+     * @returns A new model with the door type
+     * @group types
+     * @shortname add door type
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.doors.addType({ model, id: "door-90", name: "Door 900", width: 900, height: 2100 });
+     * ```
+     */
+    addType(inputs: Inputs.IFC.AddDoorTypeDto<IfcModel>): IfcModel;
+    /**
+     * Places a door of a door type in a wall, `offset` along the wall's axis from its start, cutting
+     * an opening as wide and high as the type.
+     *
+     * The door is centred in the wall's thickness and belongs to the wall's storey. It must fit
+     * along the wall.
+     * @param inputs - The model, the wall, the door type, and where the door goes
+     * @returns A new model with the door
+     * @group create
+     * @shortname add door
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.doors.add({ model, wall: "south", doorType: "door-90", id: "front-door", offset: 2000 });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddDoorDto<IfcModel>): IfcModel;
+}

package/lib/api/services/doors.js

@@ -0,0 +1,94 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { createDoorType, createFilling } from "../../build/fillings";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES, HANDLE_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, lengthTolerance, modelOf, oneOf, resolveId } from "./service-support";
+function handleSizesIn(model) {
+    const size = (millimetres) => lengthIn(model, undefined, millimetres);
+    return {
+        inset: size(HANDLE_MILLIMETRES.inset),
+        leverHeight: size(HANDLE_MILLIMETRES.leverHeight),
+        leverStandoff: size(HANDLE_MILLIMETRES.leverStandoff),
+        leverSection: size(HANDLE_MILLIMETRES.leverSection),
+        leverLength: size(HANDLE_MILLIMETRES.leverLength),
+        pullBarLength: size(HANDLE_MILLIMETRES.pullBarLength),
+        pullBarMiddle: size(HANDLE_MILLIMETRES.pullBarMiddle),
+        pullBarStandoff: size(HANDLE_MILLIMETRES.pullBarStandoff),
+        pullBarSection: size(HANDLE_MILLIMETRES.pullBarSection),
+        pullBarPost: size(HANDLE_MILLIMETRES.pullBarPost),
+        pullBarPostInset: size(HANDLE_MILLIMETRES.pullBarPostInset),
+    };
+}
+/**
+ * Doors: door types, each a lining around one panel, and doors of those types placed in walls. A
+ * door cuts its own opening and shares its type's geometry, so a type placed many times is written
+ * once.
+ * @beta
+ */
+export class IFCDoors {
+    /**
+     * Adds a door type: a lining around one panel, `width` by `height`, which doors are then placed
+     * from.
+     *
+     * The lining's sides and head are `liningThickness` wide and `liningDepth` deep; the panel sits
+     * in the middle of the depth. A `handle` goes on both faces, away from the hinges. Materials give
+     * the lining, panel and handle their colours.
+     * @param inputs - The model, the type's id and name, its sizes and how it opens
+     * @returns A new model with the door type
+     * @group types
+     * @shortname add door type
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.doors.addType({ model, id: "door-90", name: "Door 900", width: 900, height: 2100 });
+     * ```
+     */
+    addType(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddDoorTypeDto, inputs);
+        const model = modelOf(resolved.model);
+        const spec = {
+            id: resolved.id,
+            name: resolved.name,
+            width: lengthIn(model, resolved.width, DEFAULT_MILLIMETRES.doorWidth),
+            height: lengthIn(model, resolved.height, DEFAULT_MILLIMETRES.doorHeight),
+            liningThickness: lengthIn(model, resolved.liningThickness, DEFAULT_MILLIMETRES.liningThickness),
+            liningDepth: lengthIn(model, resolved.liningDepth, DEFAULT_MILLIMETRES.liningDepth),
+            panelThickness: lengthIn(model, resolved.panelThickness, DEFAULT_MILLIMETRES.panelThickness),
+            operation: oneOf(resolved.operation, Inputs.IFC.doorOperationEnum, "door operation"),
+            liningMaterial: resolved.liningMaterial,
+            panelMaterial: resolved.panelMaterial,
+            handle: oneOf(resolved.handle, Inputs.IFC.doorHandleEnum, "door handle"),
+            handleMaterial: resolved.handleMaterial,
+            hardware: handleSizesIn(model),
+        };
+        return editModel(model, (tx, writer) => {
+            createDoorType(tx, writer, spec);
+        });
+    }
+    /**
+     * Places a door of a door type in a wall, `offset` along the wall's axis from its start, cutting
+     * an opening as wide and high as the type.
+     *
+     * The door is centred in the wall's thickness and belongs to the wall's storey. It must fit
+     * along the wall.
+     * @param inputs - The model, the wall, the door type, and where the door goes
+     * @returns A new model with the door
+     * @group create
+     * @shortname add door
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.doors.add({ model, wall: "south", doorType: "door-90", id: "front-door", offset: 2000 });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddDoorDto, inputs);
+        const model = modelOf(resolved.model);
+        const wall = resolveId(model, resolved.wall, "IfcWall", "wall");
+        const type = resolveId(model, resolved.doorType, "IfcDoorType", "door type");
+        return editModel(model, (tx, writer) => {
+            const offset = lengthIn(model, resolved.offset, DEFAULT_MILLIMETRES.openingOffset);
+            createFilling(tx, writer, "IfcDoor", { wall, type, id: resolved.id, name: resolved.name, offset, sill: resolved.sill }, lengthTolerance(model));
+        });
+    }
+}

package/lib/api/services/geometry.d.ts

@@ -0,0 +1,51 @@
+import type { Base } from "@bitbybit-dev/base";
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Describes a model's geometry as a recipe: data that a geometry kernel builds into solids or
+ * meshes, one result per element, with the openings of walls and slabs cut through them and each
+ * door or window type described once however many times it is placed.
+ *
+ * The recipe stays in the model's units and its Z up; each result is tagged with its element's
+ * `globalId`, `type`, `name` and, when its material has a colour, `rgba`.
+ * @beta
+ */
+export declare class IFCGeometry {
+    private readonly lastDescribed;
+    /**
+     * Describes the geometry of a model's elements as a recipe, ready for a kernel to build.
+     *
+     * Each element with a body becomes one root, placed by its matrix and tagged with its GlobalId;
+     * openings are cut from their hosts rather than becoming roots. An element that cannot be
+     * described is left out, and `geometry.unsupported` lists it with the reason.
+     * @param inputs - The model and, optionally, the elements to describe
+     * @returns A recipe with one root per element
+     * @group recipes
+     * @shortname geometry recipe
+     * @drawable false
+     * @example
+     * ```typescript
+     * const recipe = await bitbybit.ifc.geometry.recipe({ model });
+     * console.log(recipe.roots.length, recipe.millimetresPerUnit);
+     * ```
+     */
+    recipe(inputs: Inputs.IFC.GeometryDto<IfcModel>): Base.Recipe;
+    /**
+     * Lists the elements whose geometry `geometry.recipe` leaves out, each with what it could not
+     * describe, such as a profile type that is not supported yet.
+     *
+     * An element asked for in `elements` is listed too when it has no body to describe, such as an
+     * opening, a storey or an element without a 'Body' representation.
+     * @param inputs - The model and, optionally, the elements to check
+     * @returns The elements left out, empty when every one is described
+     * @group recipes
+     * @shortname unsupported geometry
+     * @drawable false
+     * @example
+     * ```typescript
+     * const problems = await bitbybit.ifc.geometry.unsupported({ model });
+     * problems.forEach((problem) => console.log(problem.type, problem.message));
+     * ```
+     */
+    unsupported(inputs: Inputs.IFC.GeometryElementsDto<IfcModel>): Inputs.IFC.GeometryProblemDto[];
+}