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

package/lib/api/services/spaces.js

@@ -0,0 +1,64 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { requireFinite, requireOutline } from "../../build/checks";
+import { createSpace, spacesOf } from "../../build/spaces";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, lengthTolerance, modelOf, oneOf, resolveId } from "./service-support";
+/**
+ * Spaces: the rooms and areas of a storey, each an outline in the storey's plan extruded up to its
+ * height, with a number and a name. Tools schedule rooms and their areas from them.
+ * @beta
+ */
+export class IFCSpaces {
+    /**
+     * Adds a space to a storey: a room or an area, from an outline in the storey's plan, `height`
+     * high. A space is part of its storey, as IFC aggregates spaces, rather than an element on it.
+     * @param inputs - The model, the storey, the outline, the height, and the space's number and name
+     * @returns A new model with the space
+     * @group create
+     * @shortname add space
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.spaces.add({ model, storey: "ground", id: "kitchen", name: "0.01", longName: "Kitchen", outline: [[0, 0], [4000, 0], [4000, 3000], [0, 3000]], height: 2700 });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddSpaceDto, inputs);
+        const model = modelOf(resolved.model);
+        requireOutline(resolved.outline, "outline");
+        requireFinite(resolved.baseOffset, "base offset");
+        const storey = resolveId(model, resolved.storey, "IfcBuildingStorey", "storey");
+        const predefinedType = oneOf(resolved.predefinedType, Inputs.IFC.spacePredefinedTypeEnum, "predefined type");
+        const height = lengthIn(model, resolved.height, DEFAULT_MILLIMETRES.spaceHeight);
+        return editModel(model, (tx, writer) => {
+            createSpace(tx, writer, {
+                storey,
+                id: resolved.id,
+                name: resolved.name,
+                longName: resolved.longName,
+                outline: resolved.outline,
+                height,
+                baseOffset: resolved.baseOffset,
+                predefinedType,
+            }, lengthTolerance(model));
+        });
+    }
+    /**
+     * Lists the spaces of the model, or of one storey, with their numbers, names, areas and heights.
+     * @param inputs - The model and, optionally, the storey
+     * @returns The spaces
+     * @group query
+     * @shortname list spaces
+     * @drawable false
+     * @example
+     * ```typescript
+     * const rooms = await bitbybit.ifc.spaces.list({ model, storey: "ground" });
+     * ```
+     */
+    list(inputs) {
+        const model = modelOf(inputs.model);
+        const storey = inputs.storey === undefined ? undefined : resolveId(model, inputs.storey, "IfcBuildingStorey", "storey");
+        return spacesOf(model, storey);
+    }
+}

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

@@ -0,0 +1,54 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * The spatial structure of a model: the storeys of its building, which every wall, slab, column and
+ * beam is added to. A storey has an elevation; what stands on it is placed in its plan, with Z up
+ * from its floor.
+ * @beta
+ */
+export declare class IFCSpatial {
+    /**
+     * Adds a storey to the model's building at an elevation above the building's origin.
+     *
+     * Give it an `id` such as `ground` to refer to it when adding walls and slabs. The model must
+     * have exactly one building, as `model.create` makes.
+     * @param inputs - The model, the storey's id, name and elevation
+     * @returns A new model with the storey
+     * @group storeys
+     * @shortname add storey
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.spatial.addStorey({ model, id: "first", name: "First floor", elevation: 3000 });
+     * ```
+     */
+    addStorey(inputs: Inputs.IFC.AddStoreyDto<IfcModel>): IfcModel;
+    /**
+     * Raises or lowers a storey to a new elevation. Everything placed on the storey moves with it;
+     * the other storeys stay where they are.
+     * @param inputs - The model, the storey and its new elevation
+     * @returns A new model with the storey moved
+     * @group storeys
+     * @shortname set storey elevation
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.spatial.setElevation({ model, storey: "first", elevation: 3200 });
+     * ```
+     */
+    setElevation(inputs: Inputs.IFC.SetStoreyElevationDto<IfcModel>): IfcModel;
+    /**
+     * Lists the storeys of the model's buildings, lowest first, with their GlobalIds, names and
+     * elevations.
+     * @param inputs - The model
+     * @returns The storeys, lowest first
+     * @group storeys
+     * @shortname storeys
+     * @drawable false
+     * @example
+     * ```typescript
+     * const storeys = await bitbybit.ifc.spatial.storeys({ model });
+     * ```
+     */
+    storeys(inputs: Inputs.IFC.ModelDto<IfcModel>): Inputs.IFC.StoreyInfoDto[];
+}

package/lib/api/services/spatial.js

@@ -0,0 +1,75 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { requireFinite } from "../../build/checks";
+import { addStorey, onlyBuilding, setStoreyElevation, storeysOf } from "../../build/spatial";
+import * as Inputs from "../inputs";
+import { editModel, modelOf, resolveId } from "./service-support";
+/**
+ * The spatial structure of a model: the storeys of its building, which every wall, slab, column and
+ * beam is added to. A storey has an elevation; what stands on it is placed in its plan, with Z up
+ * from its floor.
+ * @beta
+ */
+export class IFCSpatial {
+    /**
+     * Adds a storey to the model's building at an elevation above the building's origin.
+     *
+     * Give it an `id` such as `ground` to refer to it when adding walls and slabs. The model must
+     * have exactly one building, as `model.create` makes.
+     * @param inputs - The model, the storey's id, name and elevation
+     * @returns A new model with the storey
+     * @group storeys
+     * @shortname add storey
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.spatial.addStorey({ model, id: "first", name: "First floor", elevation: 3000 });
+     * ```
+     */
+    addStorey(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddStoreyDto, inputs);
+        const model = modelOf(resolved.model);
+        requireFinite(resolved.elevation, "storey's elevation");
+        const building = onlyBuilding(model);
+        return editModel(model, (tx, writer) => {
+            addStorey(tx, writer, building, resolved.id, resolved.name, resolved.elevation);
+        });
+    }
+    /**
+     * Raises or lowers a storey to a new elevation. Everything placed on the storey moves with it;
+     * the other storeys stay where they are.
+     * @param inputs - The model, the storey and its new elevation
+     * @returns A new model with the storey moved
+     * @group storeys
+     * @shortname set storey elevation
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.spatial.setElevation({ model, storey: "first", elevation: 3200 });
+     * ```
+     */
+    setElevation(inputs) {
+        const resolved = resolveDto(Inputs.IFC.SetStoreyElevationDto, inputs);
+        const model = modelOf(resolved.model);
+        requireFinite(resolved.elevation, "storey's elevation");
+        const storey = resolveId(model, resolved.storey, "IfcBuildingStorey", "storey");
+        return editModel(model, (tx, writer) => {
+            setStoreyElevation(tx, writer, storey, resolved.elevation);
+        });
+    }
+    /**
+     * Lists the storeys of the model's buildings, lowest first, with their GlobalIds, names and
+     * elevations.
+     * @param inputs - The model
+     * @returns The storeys, lowest first
+     * @group storeys
+     * @shortname storeys
+     * @drawable false
+     * @example
+     * ```typescript
+     * const storeys = await bitbybit.ifc.spatial.storeys({ model });
+     * ```
+     */
+    storeys(inputs) {
+        return storeysOf(modelOf(inputs.model));
+    }
+}

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

@@ -0,0 +1,140 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Walls: straight walls on a storey, from an axis, a height and a thickness or a layer set, joined
+ * at their corners and clipped under roofs. A wall keeps its axis, layers and height, so joins and
+ * clippings are worked out again from them whenever a wall changes, and tools that edit IFC walls
+ * edit these as walls.
+ *
+ * Doors, windows and openings go into walls through `doors`, `windows` and `openings`.
+ * @beta
+ */
+export declare class IFCWalls {
+    /**
+     * Adds a straight wall on a storey, from `start` to `end` in the storey's plan, `height` high.
+     *
+     * The wall is made of its type's layer set, the named `layerSet`, or one layer `thickness` thick,
+     * in that order of preference. `alignment` says which side of the axis the layers lie on; join
+     * walls at their corners afterwards with `walls.connect`.
+     * @param inputs - The model, the storey, the axis, the height, the thickness or layer set, and the alignment
+     * @returns A new model with the wall
+     * @group create
+     * @shortname add wall
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.add({ model, storey: "ground", id: "south", start: [0, 0], end: [10000, 0], height: 2700, thickness: 250 });
+     * model = await bitbybit.ifc.walls.add({ model, storey: "ground", id: "east", start: [10000, 0], end: [10000, 8000], height: 2700, thickness: 250 });
+     * model = await bitbybit.ifc.walls.connect({ model, wall: "south", other: "east" });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddWallDto<IfcModel>): IfcModel;
+    /**
+     * Joins two walls where they meet, trimming both: two walls meeting at their ends are mitred
+     * into a corner, and a wall ending against another's side is cut back to that side.
+     *
+     * The join is recorded in the model, and joining the two walls again replaces it. Walls that do
+     * not meet cannot be joined.
+     * @param inputs - The model and the two walls
+     * @returns A new model with the walls joined
+     * @group edit
+     * @shortname connect walls
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.connect({ model, wall: "south", other: "east" });
+     * ```
+     */
+    connect(inputs: Inputs.IFC.ConnectWallsDto<IfcModel>): IfcModel;
+    /**
+     * Takes away the join between two walls, so the ends it trimmed are square again.
+     * @param inputs - The model and the two walls
+     * @returns A new model with the walls no longer joined
+     * @group edit
+     * @shortname disconnect walls
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.disconnect({ model, wall: "south", other: "east" });
+     * ```
+     */
+    disconnect(inputs: Inputs.IFC.ConnectWallsDto<IfcModel>): IfcModel;
+    /**
+     * Changes a wall's axis, height, base, layers or alignment. Joined walls are trimmed again,
+     * clippings stay put, and openings, doors and windows move with it, keeping their offset and sill. A
+     * change is refused when it parts the wall from a joined wall, puts an opening off its end, or leaves
+     * behind an opening, door or window placed elsewhere.
+     * @param inputs - The model, the wall and what to change
+     * @returns A new model with the wall changed
+     * @group edit
+     * @shortname edit wall
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.edit({ model, wall: "south", height: 3200, thickness: 300 });
+     * ```
+     */
+    edit(inputs: Inputs.IFC.EditWallDto<IfcModel>): IfcModel;
+    /**
+     * Reads a wall's parameters back from the model: its axis, height, base, thickness, layers and
+     * alignment, the walls it is joined to, its openings and its clippings. It reads walls other tools
+     * wrote too, when they keep an axis and a layer set usage as IFC's standard walls do.
+     * @param inputs - The model and the wall
+     * @returns The wall's parameters, in the plan of its storey
+     * @group query
+     * @shortname wall parameters
+     * @drawable false
+     * @example
+     * ```typescript
+     * const wall = await bitbybit.ifc.walls.parameters({ model, wall: "south" });
+     * ```
+     */
+    parameters(inputs: Inputs.IFC.WallDto<IfcModel>): Inputs.IFC.WallParametersDto;
+    /**
+     * Clips a wall with a plane, removing the part on the side the plane's normal points to, as a
+     * wall is cut under a sloping roof.
+     *
+     * The plane is given in the wall's storey, and a wall can be clipped by several planes. Clipping
+     * keeps the wall's full height in its data, so joins stay right.
+     * @param inputs - The model, the wall, a point on the plane and its normal
+     * @returns A new model with the wall clipped
+     * @group edit
+     * @shortname clip wall by plane
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.clipByPlane({ model, wall: "south", origin: [0, 0, 2600], normal: [0, -0.5, 1] });
+     * ```
+     */
+    clipByPlane(inputs: Inputs.IFC.ClipWallDto<IfcModel>): IfcModel;
+    /**
+     * Clips a wall under a roof by each of the roof's planes that cuts it: under the eaves level or
+     * along the slope, under a gable to the gable's triangle. Planes above the wall leave it alone, and
+     * clipping again changes nothing. A plane below the wall's bottom everywhere is refused, as it would
+     * leave nothing of the wall.
+     * @param inputs - The model, the wall and the roof
+     * @returns A new model with the wall clipped
+     * @group edit
+     * @shortname clip wall by roof
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.clipByRoof({ model, wall: "west", roof: "roof" });
+     * ```
+     */
+    clipByRoof(inputs: Inputs.IFC.ClipWallByRoofDto<IfcModel>): IfcModel;
+    /**
+     * Adds a wall type: a named kind of wall made of a layer set. Walls added with this type as their
+     * `wallType` are made of its layers.
+     * @param inputs - The model, the type's id and name, its layer set and its kind
+     * @returns A new model with the wall type
+     * @group types
+     * @shortname add wall type
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.addType({ model, id: "exterior", name: "Exterior 230", layerSet: "Exterior wall" });
+     * ```
+     */
+    addType(inputs: Inputs.IFC.AddWallTypeDto<IfcModel>): IfcModel;
+}

package/lib/api/services/walls.js

@@ -0,0 +1,268 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { WORLD_AXES, pointToWorld, vectorToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { requireFinite, requirePoint } from "../../build/checks";
+import { PARALLEL_TOLERANCE, POINT2_SIZE, POINT3_SIZE } from "../../build/constants";
+import { associateMaterial, layerSetFor, materialOf, requireLayerSet } from "../../build/materials";
+import { containerOf, storeyFrame } from "../../build/spatial";
+import { declareInProject } from "../../build/type-objects";
+import { clipWallByRoof } from "../../build/roof-clipping";
+import { disconnectWalls, editWall } from "../../build/wall-edits";
+import { wallParametersOf } from "../../build/wall-parameters";
+import { clipWall, connectWalls, createWall } from "../../build/walls";
+import { enumValue } from "../../step/values";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, lengthTolerance, modelOf, oneOf, resolveId } from "./service-support";
+function typeLayerSet(tx, wallType, name) {
+    const material = materialOf(tx, wallType);
+    if (material === undefined || tx.entity(material).type !== "IfcMaterialLayerSet") {
+        throw new Error(`The wall type '${name}' has no layer set`);
+    }
+    return material;
+}
+/**
+ * Walls: straight walls on a storey, from an axis, a height and a thickness or a layer set, joined
+ * at their corners and clipped under roofs. A wall keeps its axis, layers and height, so joins and
+ * clippings are worked out again from them whenever a wall changes, and tools that edit IFC walls
+ * edit these as walls.
+ *
+ * Doors, windows and openings go into walls through `doors`, `windows` and `openings`.
+ * @beta
+ */
+export class IFCWalls {
+    /**
+     * Adds a straight wall on a storey, from `start` to `end` in the storey's plan, `height` high.
+     *
+     * The wall is made of its type's layer set, the named `layerSet`, or one layer `thickness` thick,
+     * in that order of preference. `alignment` says which side of the axis the layers lie on; join
+     * walls at their corners afterwards with `walls.connect`.
+     * @param inputs - The model, the storey, the axis, the height, the thickness or layer set, and the alignment
+     * @returns A new model with the wall
+     * @group create
+     * @shortname add wall
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.add({ model, storey: "ground", id: "south", start: [0, 0], end: [10000, 0], height: 2700, thickness: 250 });
+     * model = await bitbybit.ifc.walls.add({ model, storey: "ground", id: "east", start: [10000, 0], end: [10000, 8000], height: 2700, thickness: 250 });
+     * model = await bitbybit.ifc.walls.connect({ model, wall: "south", other: "east" });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddWallDto, inputs);
+        const model = modelOf(resolved.model);
+        requirePoint(resolved.start, POINT2_SIZE, "start");
+        requirePoint(resolved.end, POINT2_SIZE, "end");
+        const storey = resolveId(model, resolved.storey, "IfcBuildingStorey", "storey");
+        const typeName = resolved.wallType;
+        const wallType = typeName === undefined ? undefined : resolveId(model, typeName, "IfcWallType", "wall type");
+        const alignment = oneOf(resolved.alignment, Inputs.IFC.wallAlignmentEnum, "wall alignment");
+        const predefinedType = oneOf(resolved.predefinedType, Inputs.IFC.wallPredefinedTypeEnum, "predefined type");
+        const height = lengthIn(model, resolved.height, DEFAULT_MILLIMETRES.wallHeight);
+        const thickness = lengthIn(model, resolved.thickness, DEFAULT_MILLIMETRES.wallThickness);
+        return editModel(model, (tx, writer) => {
+            createWall(tx, writer, {
+                storey,
+                id: resolved.id,
+                name: resolved.name,
+                start: resolved.start,
+                end: resolved.end,
+                height,
+                baseOffset: resolved.baseOffset,
+                layerSet: wallType === undefined || typeName === undefined ? layerSetFor(tx, writer, resolved.layerSet, thickness, "Wall") : typeLayerSet(tx, wallType, typeName),
+                alignment,
+                wallType,
+                predefinedType: wallType === undefined ? predefinedType : undefined,
+            }, lengthTolerance(model));
+        });
+    }
+    /**
+     * Joins two walls where they meet, trimming both: two walls meeting at their ends are mitred
+     * into a corner, and a wall ending against another's side is cut back to that side.
+     *
+     * The join is recorded in the model, and joining the two walls again replaces it. Walls that do
+     * not meet cannot be joined.
+     * @param inputs - The model and the two walls
+     * @returns A new model with the walls joined
+     * @group edit
+     * @shortname connect walls
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.connect({ model, wall: "south", other: "east" });
+     * ```
+     */
+    connect(inputs) {
+        const model = modelOf(inputs.model);
+        const wall = resolveId(model, inputs.wall, "IfcWall", "wall");
+        const other = resolveId(model, inputs.other, "IfcWall", "wall");
+        return editModel(model, (tx, writer) => {
+            connectWalls(tx, writer, wall, other, lengthTolerance(model), PARALLEL_TOLERANCE);
+        });
+    }
+    /**
+     * Takes away the join between two walls, so the ends it trimmed are square again.
+     * @param inputs - The model and the two walls
+     * @returns A new model with the walls no longer joined
+     * @group edit
+     * @shortname disconnect walls
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.disconnect({ model, wall: "south", other: "east" });
+     * ```
+     */
+    disconnect(inputs) {
+        const model = modelOf(inputs.model);
+        const wall = resolveId(model, inputs.wall, "IfcWall", "wall");
+        const other = resolveId(model, inputs.other, "IfcWall", "wall");
+        return editModel(model, (tx, writer) => {
+            disconnectWalls(tx, writer, wall, other, lengthTolerance(model), PARALLEL_TOLERANCE);
+        });
+    }
+    /**
+     * Changes a wall's axis, height, base, layers or alignment. Joined walls are trimmed again,
+     * clippings stay put, and openings, doors and windows move with it, keeping their offset and sill. A
+     * change is refused when it parts the wall from a joined wall, puts an opening off its end, or leaves
+     * behind an opening, door or window placed elsewhere.
+     * @param inputs - The model, the wall and what to change
+     * @returns A new model with the wall changed
+     * @group edit
+     * @shortname edit wall
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.edit({ model, wall: "south", height: 3200, thickness: 300 });
+     * ```
+     */
+    edit(inputs) {
+        const resolved = resolveDto(Inputs.IFC.EditWallDto, inputs);
+        const model = modelOf(resolved.model);
+        const wall = resolveId(model, resolved.wall, "IfcWall", "wall");
+        if (resolved.start !== undefined) {
+            requirePoint(resolved.start, POINT2_SIZE, "start");
+        }
+        if (resolved.end !== undefined) {
+            requirePoint(resolved.end, POINT2_SIZE, "end");
+        }
+        if (resolved.baseOffset !== undefined) {
+            requireFinite(resolved.baseOffset, "base offset");
+        }
+        const alignment = resolved.alignment === undefined ? undefined : oneOf(resolved.alignment, Inputs.IFC.wallAlignmentEnum, "wall alignment");
+        const tolerance = lengthTolerance(model);
+        const storey = containerOf(model, wall);
+        const plan = storey === undefined ? WORLD_AXES : storeyFrame(model, storey);
+        const inWorld = (point) => {
+            const world = pointToWorld(plan, [point[0], point[1], 0]);
+            return [world[0], world[1]];
+        };
+        return editModel(model, (tx, writer) => {
+            editWall(tx, writer, wall, {
+                start: resolved.start === undefined ? undefined : inWorld(resolved.start),
+                end: resolved.end === undefined ? undefined : inWorld(resolved.end),
+                bottom: resolved.baseOffset === undefined ? undefined : pointToWorld(plan, [0, 0, resolved.baseOffset])[2],
+                height: resolved.height,
+                layerSet: resolved.layerSet !== undefined ? requireLayerSet(tx, resolved.layerSet) : resolved.thickness !== undefined ? layerSetFor(tx, writer, undefined, resolved.thickness, "Wall") : undefined,
+                alignment,
+            }, tolerance, PARALLEL_TOLERANCE);
+        });
+    }
+    /**
+     * Reads a wall's parameters back from the model: its axis, height, base, thickness, layers and
+     * alignment, the walls it is joined to, its openings and its clippings. It reads walls other tools
+     * wrote too, when they keep an axis and a layer set usage as IFC's standard walls do.
+     * @param inputs - The model and the wall
+     * @returns The wall's parameters, in the plan of its storey
+     * @group query
+     * @shortname wall parameters
+     * @drawable false
+     * @example
+     * ```typescript
+     * const wall = await bitbybit.ifc.walls.parameters({ model, wall: "south" });
+     * ```
+     */
+    parameters(inputs) {
+        const model = modelOf(inputs.model);
+        return wallParametersOf(model, resolveId(model, inputs.wall, "IfcWall", "wall"), lengthTolerance(model));
+    }
+    /**
+     * Clips a wall with a plane, removing the part on the side the plane's normal points to, as a
+     * wall is cut under a sloping roof.
+     *
+     * The plane is given in the wall's storey, and a wall can be clipped by several planes. Clipping
+     * keeps the wall's full height in its data, so joins stay right.
+     * @param inputs - The model, the wall, a point on the plane and its normal
+     * @returns A new model with the wall clipped
+     * @group edit
+     * @shortname clip wall by plane
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.clipByPlane({ model, wall: "south", origin: [0, 0, 2600], normal: [0, -0.5, 1] });
+     * ```
+     */
+    clipByPlane(inputs) {
+        const resolved = resolveDto(Inputs.IFC.ClipWallDto, inputs);
+        const model = modelOf(resolved.model);
+        requirePoint(resolved.origin, POINT3_SIZE, "origin");
+        requirePoint(resolved.normal, POINT3_SIZE, "normal");
+        const wall = resolveId(model, resolved.wall, "IfcWall", "wall");
+        const storey = containerOf(model, wall);
+        const frame = storey === undefined ? undefined : storeyFrame(model, storey);
+        const origin = frame ? pointToWorld(frame, resolved.origin) : resolved.origin;
+        const normal = frame ? vectorToWorld(frame, resolved.normal) : resolved.normal;
+        return editModel(model, (tx, writer) => {
+            clipWall(tx, writer, wall, origin, normal);
+        });
+    }
+    /**
+     * Clips a wall under a roof by each of the roof's planes that cuts it: under the eaves level or
+     * along the slope, under a gable to the gable's triangle. Planes above the wall leave it alone, and
+     * clipping again changes nothing. A plane below the wall's bottom everywhere is refused, as it would
+     * leave nothing of the wall.
+     * @param inputs - The model, the wall and the roof
+     * @returns A new model with the wall clipped
+     * @group edit
+     * @shortname clip wall by roof
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.clipByRoof({ model, wall: "west", roof: "roof" });
+     * ```
+     */
+    clipByRoof(inputs) {
+        const model = modelOf(inputs.model);
+        const wall = resolveId(model, inputs.wall, "IfcWall", "wall");
+        const roof = resolveId(model, inputs.roof, "IfcRoof", "roof");
+        return editModel(model, (tx, writer) => {
+            clipWallByRoof(tx, writer, wall, roof, lengthTolerance(model));
+        });
+    }
+    /**
+     * Adds a wall type: a named kind of wall made of a layer set. Walls added with this type as their
+     * `wallType` are made of its layers.
+     * @param inputs - The model, the type's id and name, its layer set and its kind
+     * @returns A new model with the wall type
+     * @group types
+     * @shortname add wall type
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.walls.addType({ model, id: "exterior", name: "Exterior 230", layerSet: "Exterior wall" });
+     * ```
+     */
+    addType(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddWallTypeDto, inputs);
+        const model = modelOf(resolved.model);
+        return editModel(model, (tx, writer) => {
+            const layerSet = requireLayerSet(tx, resolved.layerSet);
+            const type = writer.create("IfcWallType", {
+                GlobalId: tx.globalId(resolved.id),
+                Name: resolved.name,
+                PredefinedType: enumValue(oneOf(resolved.predefinedType, Inputs.IFC.wallPredefinedTypeEnum, "predefined type")),
+            });
+            associateMaterial(tx, writer, [type], layerSet);
+            declareInProject(tx, writer, type);
+        });
+    }
+}

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

@@ -0,0 +1,46 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Windows: window types, each a frame around one pane of glass, and windows of those types placed
+ * in walls. A window cuts its own opening and shares its type's geometry, so a type placed many
+ * times is written once.
+ * @beta
+ */
+export declare class IFCWindows {
+    /**
+     * Adds a window type: a frame around one pane, `width` by `height`, which windows are then
+     * placed from.
+     *
+     * The frame's members are `frameThickness` wide and `frameDepth` deep; the glass sits in the
+     * middle of the depth. A `frameMaterial` and a `glassMaterial` give each part its material and
+     * colour.
+     * @param inputs - The model, the type's id and name, and its sizes
+     * @returns A new model with the window type
+     * @group types
+     * @shortname add window type
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.materials.add({ model, name: "Glass", color: "#a9c7d6", transparency: 0.7 });
+     * model = await bitbybit.ifc.windows.addType({ model, id: "window-120", name: "Window 1200", width: 1200, height: 1400, glassMaterial: "Glass" });
+     * ```
+     */
+    addType(inputs: Inputs.IFC.AddWindowTypeDto<IfcModel>): IfcModel;
+    /**
+     * Places a window of a window type in a wall, `offset` along the wall's axis from its start and
+     * `sill` above its base, cutting an opening as wide and high as the type.
+     *
+     * The window 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 window type, and where the window goes
+     * @returns A new model with the window
+     * @group create
+     * @shortname add window
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.windows.add({ model, wall: "south", windowType: "window-120", offset: 6000, sill: 900 });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddWindowDto<IfcModel>): IfcModel;
+}