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

package/lib/api/services/properties.js

@@ -0,0 +1,142 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { addPropertySet, propertySetsOf, removePropertySet, removePropertyValues, setPropertyValues } from "../../build/properties";
+import * as Inputs from "../inputs";
+import { editModel, modelOf, resolveId } from "./service-support";
+function propertySpecs(properties) {
+    if (!Array.isArray(properties)) {
+        throw new TypeError("Expected the properties as a list");
+    }
+    return properties.map((property) => {
+        const full = resolveDto(Inputs.IFC.PropertyDto, property);
+        if (typeof full.value !== "string" && typeof full.value !== "boolean" && !(typeof full.value === "number" && Number.isFinite(full.value))) {
+            throw new TypeError(`The property '${full.name}' needs a text, a finite number, or true or false`);
+        }
+        return { name: full.name, value: full.value, type: full.type };
+    });
+}
+/**
+ * Properties: named sets of values attached to elements and types, such as `Pset_WallCommon` with
+ * `IsExternal` and `FireRating`, which other tools list, filter and schedule by.
+ * @beta
+ */
+export class IFCProperties {
+    /**
+     * Attaches a property set to one or more objects: walls, doors, types or any object with a
+     * GlobalId.
+     *
+     * Each value is written as its `type`, or as a label, an integer, a real or a boolean by the
+     * kind of value. One set is shared by every object it is attached to.
+     * @param inputs - The model, the objects, the set's name and its properties
+     * @returns A new model with the property set
+     * @group properties
+     * @shortname add property set
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.properties.addSet({
+     *     model,
+     *     elements: ["south", "east"],
+     *     name: "Pset_WallCommon",
+     *     properties: [{ name: "IsExternal", value: true }, { name: "FireRating", value: "REI 60" }],
+     * });
+     * ```
+     */
+    addSet(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddPropertySetDto, inputs);
+        const model = modelOf(resolved.model);
+        if (!Array.isArray(resolved.elements) || !resolved.elements.length) {
+            throw new TypeError("A property set is attached to a list of at least one object");
+        }
+        const objects = resolved.elements.map((element) => resolveId(model, element, "IfcObjectDefinition", "object"));
+        const properties = propertySpecs(resolved.properties);
+        return editModel(model, (tx, writer) => {
+            addPropertySet(tx, writer, objects, resolved.name, properties);
+        });
+    }
+    /**
+     * Reads the property sets attached to an object, with each single value by name.
+     *
+     * Values of other kinds of property, such as lists and tables, and logical values that are
+     * unknown are left out.
+     * @param inputs - The model and the object
+     * @returns The object's property sets
+     * @group properties
+     * @shortname get property sets
+     * @drawable false
+     * @example
+     * ```typescript
+     * const sets = await bitbybit.ifc.properties.getSets({ model, element: "south" });
+     * ```
+     */
+    getSets(inputs) {
+        const model = modelOf(inputs.model);
+        return propertySetsOf(model, resolveId(model, inputs.element, "IfcObjectDefinition", "object"));
+    }
+    /**
+     * Sets property values of one object, in its property set of the given name, and makes the set
+     * when the object has none. A set the object shares with other objects is copied first, so only
+     * this object's values change.
+     * @param inputs - The model, the object, the set's name and the properties
+     * @returns A new model with the values set
+     * @group properties
+     * @shortname set property values
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.properties.setValues({ model, element: "south", name: "Pset_WallCommon", properties: [{ name: "FireRating", value: "REI 90" }] });
+     * ```
+     */
+    setValues(inputs) {
+        const resolved = resolveDto(Inputs.IFC.SetPropertyValuesDto, inputs);
+        const model = modelOf(resolved.model);
+        const object = resolveId(model, resolved.element, "IfcObjectDefinition", "object");
+        const properties = propertySpecs(resolved.properties);
+        return editModel(model, (tx, writer) => {
+            setPropertyValues(tx, writer, object, resolved.name, properties);
+        });
+    }
+    /**
+     * Takes properties out of one object's property set; the set goes when none are left. A set the
+     * object shares with other objects is copied first, so the others keep their values.
+     * @param inputs - The model, the object, the set's name and the names of the properties
+     * @returns A new model without the properties
+     * @group properties
+     * @shortname remove property values
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.properties.removeValues({ model, element: "south", name: "Pset_WallCommon", names: ["FireRating"] });
+     * ```
+     */
+    removeValues(inputs) {
+        const resolved = resolveDto(Inputs.IFC.RemovePropertyValuesDto, inputs);
+        const model = modelOf(resolved.model);
+        if (!Array.isArray(resolved.names) || !resolved.names.length || !resolved.names.every((name) => typeof name === "string")) {
+            throw new TypeError("Expected the names of the properties as a list of at least one text");
+        }
+        const object = resolveId(model, resolved.element, "IfcObjectDefinition", "object");
+        return editModel(model, (tx, writer) => {
+            removePropertyValues(tx, writer, object, resolved.name, resolved.names);
+        });
+    }
+    /**
+     * Takes a property set away from one object. Other objects that share the set keep it.
+     * @param inputs - The model, the object and the set's name
+     * @returns A new model without the set on the object
+     * @group properties
+     * @shortname remove property set
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.properties.removeSet({ model, element: "south", name: "Pset_WallCommon" });
+     * ```
+     */
+    removeSet(inputs) {
+        const resolved = resolveDto(Inputs.IFC.RemovePropertySetDto, inputs);
+        const model = modelOf(resolved.model);
+        const object = resolveId(model, resolved.element, "IfcObjectDefinition", "object");
+        return editModel(model, (tx, writer) => {
+            removePropertySet(tx, writer, object, resolved.name);
+        });
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { IfcModel } from "../../model/model-types";
+import type * as Inputs from "../inputs";
+/**
+ * Quantities: the base quantity sets IFC defines, such as `Qto_WallBaseQuantities` with a wall's
+ * length, side areas and volumes net of its openings, measured from the elements' own geometry, so
+ * other tools schedule and price them.
+ * @beta
+ */
+export declare class IFCQuantities {
+    /**
+     * Measures elements and writes their base quantity sets, replacing any set of the same name: walls,
+     * slabs, columns, beams, members, doors, windows, wall openings, spaces and roofs. A wall's volume
+     * and side area follow its clippings and lose its openings. Measure again after changing elements.
+     * @param inputs - The model and, optionally, the elements to measure
+     * @returns A new model with the quantity sets
+     * @group quantities
+     * @shortname compute quantities
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.quantities.compute({ model });
+     * ```
+     */
+    compute(inputs: Inputs.IFC.ComputeQuantitiesDto<IfcModel>): IfcModel;
+    /**
+     * Reads the quantity sets of an element, with each quantity's value by name.
+     * @param inputs - The model and the element
+     * @returns The element's quantity sets
+     * @group quantities
+     * @shortname get quantities
+     * @drawable false
+     * @example
+     * ```typescript
+     * const sets = await bitbybit.ifc.quantities.get({ model, element: "south" });
+     * ```
+     */
+    get(inputs: Inputs.IFC.ElementDto<IfcModel>): Inputs.IFC.QuantitySetInfoDto[];
+}

package/lib/api/services/quantities.js

@@ -0,0 +1,51 @@
+import { computeQuantities, quantitiesOf } from "../../build/quantities";
+import { editModel, lengthTolerance, modelOf, resolveId } from "./service-support";
+/**
+ * Quantities: the base quantity sets IFC defines, such as `Qto_WallBaseQuantities` with a wall's
+ * length, side areas and volumes net of its openings, measured from the elements' own geometry, so
+ * other tools schedule and price them.
+ * @beta
+ */
+export class IFCQuantities {
+    /**
+     * Measures elements and writes their base quantity sets, replacing any set of the same name: walls,
+     * slabs, columns, beams, members, doors, windows, wall openings, spaces and roofs. A wall's volume
+     * and side area follow its clippings and lose its openings. Measure again after changing elements.
+     * @param inputs - The model and, optionally, the elements to measure
+     * @returns A new model with the quantity sets
+     * @group quantities
+     * @shortname compute quantities
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.quantities.compute({ model });
+     * ```
+     */
+    compute(inputs) {
+        var _a;
+        const model = modelOf(inputs.model);
+        if (inputs.elements !== undefined && !Array.isArray(inputs.elements)) {
+            throw new TypeError("Expected the elements as a list");
+        }
+        const elements = (_a = inputs.elements) === null || _a === void 0 ? void 0 : _a.map((element) => resolveId(model, element, "IfcProduct", "element"));
+        return editModel(model, (tx, writer) => {
+            computeQuantities(tx, writer, model, elements, lengthTolerance(model));
+        });
+    }
+    /**
+     * Reads the quantity sets of an element, with each quantity's value by name.
+     * @param inputs - The model and the element
+     * @returns The element's quantity sets
+     * @group quantities
+     * @shortname get quantities
+     * @drawable false
+     * @example
+     * ```typescript
+     * const sets = await bitbybit.ifc.quantities.get({ model, element: "south" });
+     * ```
+     */
+    get(inputs) {
+        const model = modelOf(inputs.model);
+        return quantitiesOf(model, resolveId(model, inputs.element, "IfcObjectDefinition", "object"));
+    }
+}

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

@@ -0,0 +1,24 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Roofs: flat, mono-pitch, gable and hip roofs over a rectangle, each an `IfcRoof` whose parts are the
+ * sloping slabs of its planes. Walls are clipped under a roof with `walls.clipByRoof`.
+ * @beta
+ */
+export declare class IFCRoofs {
+    /**
+     * Adds a roof over a rectangle of a storey: flat, sloping one way, gabled, or hipped on all four
+     * sides. Every slope has the same `pitch`; its underside meets the outline at `baseOffset` above
+     * the storey's floor and reaches `overhang` past it on every side.
+     * @param inputs - The model, the storey, the rectangle, the roof's shape, pitch, thickness and overhang
+     * @returns A new model with the roof
+     * @group create
+     * @shortname add roof
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.roofs.add({ model, storey: "first", id: "roof", outline: [[0, 0], [10000, 0], [10000, 8000], [0, 8000]], kind: Bit.Inputs.IFC.roofKindEnum.gable, pitch: 35, baseOffset: 3000, overhang: 400 });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddRoofDto<IfcModel>): IfcModel;
+}

package/lib/api/services/roofs.js

@@ -0,0 +1,52 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { requireFinite, requireOutline } from "../../build/checks";
+import { layerSetFor } from "../../build/materials";
+import { createRoof } from "../../build/roofs";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, lengthTolerance, modelOf, oneOf, resolveId } from "./service-support";
+/**
+ * Roofs: flat, mono-pitch, gable and hip roofs over a rectangle, each an `IfcRoof` whose parts are the
+ * sloping slabs of its planes. Walls are clipped under a roof with `walls.clipByRoof`.
+ * @beta
+ */
+export class IFCRoofs {
+    /**
+     * Adds a roof over a rectangle of a storey: flat, sloping one way, gabled, or hipped on all four
+     * sides. Every slope has the same `pitch`; its underside meets the outline at `baseOffset` above
+     * the storey's floor and reaches `overhang` past it on every side.
+     * @param inputs - The model, the storey, the rectangle, the roof's shape, pitch, thickness and overhang
+     * @returns A new model with the roof
+     * @group create
+     * @shortname add roof
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.roofs.add({ model, storey: "first", id: "roof", outline: [[0, 0], [10000, 0], [10000, 8000], [0, 8000]], kind: Bit.Inputs.IFC.roofKindEnum.gable, pitch: 35, baseOffset: 3000, overhang: 400 });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddRoofDto, inputs);
+        const model = modelOf(resolved.model);
+        requireOutline(resolved.outline, "outline");
+        requireFinite(resolved.pitch, "pitch");
+        requireFinite(resolved.overhang, "overhang");
+        requireFinite(resolved.baseOffset, "base offset");
+        const storey = resolveId(model, resolved.storey, "IfcBuildingStorey", "storey");
+        const kind = oneOf(resolved.kind, Inputs.IFC.roofKindEnum, "roof kind");
+        const thickness = lengthIn(model, resolved.thickness, DEFAULT_MILLIMETRES.slabThickness);
+        return editModel(model, (tx, writer) => {
+            createRoof(tx, writer, {
+                storey,
+                id: resolved.id,
+                name: resolved.name,
+                outline: resolved.outline,
+                kind,
+                pitch: resolved.pitch,
+                layerSet: layerSetFor(tx, writer, resolved.layerSet, thickness, "Roof"),
+                overhang: resolved.overhang,
+                baseOffset: resolved.baseOffset,
+            }, lengthTolerance(model));
+        });
+    }
+}

package/lib/api/services/service-support.d.ts

@@ -0,0 +1,8 @@
+import { ModelSnapshot } from "../../model/snapshot";
+import type { ModelChange } from "./service-types";
+export declare function modelOf(value: unknown): ModelSnapshot;
+export declare function editModel(model: unknown, change: ModelChange): ModelSnapshot;
+export declare function lengthTolerance(model: ModelSnapshot): number;
+export declare function lengthIn(model: ModelSnapshot, value: number | undefined, millimetres: number): number;
+export declare function resolveId(model: ModelSnapshot, idOrGlobalId: string, type: string, what: string): number;
+export declare function oneOf<T extends string>(value: unknown, allowed: Readonly<Record<string, T>>, what: string): T;

package/lib/api/services/service-support.js

@@ -0,0 +1,37 @@
+import { GEOMETRY_TOLERANCE_METRES, METRES_TO_MILLIMETRES } from "../../build/constants";
+import { EntityWriter } from "../../build/entity-writer";
+import { millimetresPerUnit } from "../../build/project";
+import { resolveObject } from "../../build/spatial";
+import { ModelSnapshot } from "../../model/snapshot";
+import { IfcTransaction } from "../../model/transaction";
+export function modelOf(value) {
+    if (!(value instanceof ModelSnapshot)) {
+        throw new TypeError("Expected an IFC model, as `model.create` or `model.read` return");
+    }
+    return value;
+}
+export function editModel(model, change) {
+    const base = modelOf(model);
+    const tx = new IfcTransaction(base);
+    change(tx, new EntityWriter(tx));
+    return tx.commit();
+}
+export function lengthTolerance(model) {
+    return GEOMETRY_TOLERANCE_METRES * METRES_TO_MILLIMETRES / millimetresPerUnit(model);
+}
+export function lengthIn(model, value, millimetres) {
+    return value !== null && value !== void 0 ? value : millimetres / millimetresPerUnit(model);
+}
+export function resolveId(model, idOrGlobalId, type, what) {
+    if (typeof idOrGlobalId !== "string" || idOrGlobalId.length === 0) {
+        throw new TypeError(`Expected the ${what}'s GlobalId or id as a text`);
+    }
+    return resolveObject(model, idOrGlobalId, type, what);
+}
+export function oneOf(value, allowed, what) {
+    const values = Object.values(allowed);
+    if (typeof value !== "string" || !values.includes(value)) {
+        throw new RangeError(`The ${what} '${String(value)}' is not one of ${values.join(", ")}`);
+    }
+    return value;
+}

package/lib/api/services/service-types.d.ts

@@ -0,0 +1,3 @@
+import type { EntityWriter } from "../../build/entity-writer";
+import type { IfcTransaction } from "../../model/transaction";
+export type ModelChange = (tx: IfcTransaction, writer: EntityWriter) => void;

package/lib/api/services/service-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,37 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * The site around the building: its terrain and its trees, written as geographic elements of the
+ * site, so the ground and planting travel with the building in the file.
+ * @beta
+ */
+export declare class IFCSite {
+    /**
+     * Adds terrain to the site: the ground as an outline in the site's plan, with holes where the
+     * building or paving meets it, its top at `elevation` and `depth` deep.
+     * @param inputs - The model, the outline and its holes, the depth and elevation, and the ground's material
+     * @returns A new model with the terrain
+     * @group create
+     * @shortname add terrain
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.site.addTerrain({ model, outline: [[-30000, -30000], [30000, -30000], [30000, 30000], [-30000, 30000]], holes: [[[0, 0], [10000, 0], [10000, 8000], [0, 8000]]], material: "Lawn" });
+     * ```
+     */
+    addTerrain(inputs: Inputs.IFC.AddTerrainDto<IfcModel>): IfcModel;
+    /**
+     * Adds a tree to the site: a tapering trunk and a rounded crown at `position`, `height` tall,
+     * each part in its own material, with its species written as the element's object type.
+     * @param inputs - The model, where the tree stands, its sizes, its species and its materials
+     * @returns A new model with the tree
+     * @group create
+     * @shortname add tree
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.site.addTree({ model, species: "Silver birch", position: [-6000, -8000], height: 9000, crownRadius: 2200, crownMaterial: "Foliage", trunkMaterial: "Bark" });
+     * ```
+     */
+    addTree(inputs: Inputs.IFC.AddTreeDto<IfcModel>): IfcModel;
+}

package/lib/api/services/site.js

@@ -0,0 +1,80 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { requireFinite, requireOutline } from "../../build/checks";
+import { createTerrain, createTree } from "../../build/site";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, lengthTolerance, modelOf } from "./service-support";
+/**
+ * The site around the building: its terrain and its trees, written as geographic elements of the
+ * site, so the ground and planting travel with the building in the file.
+ * @beta
+ */
+export class IFCSite {
+    /**
+     * Adds terrain to the site: the ground as an outline in the site's plan, with holes where the
+     * building or paving meets it, its top at `elevation` and `depth` deep.
+     * @param inputs - The model, the outline and its holes, the depth and elevation, and the ground's material
+     * @returns A new model with the terrain
+     * @group create
+     * @shortname add terrain
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.site.addTerrain({ model, outline: [[-30000, -30000], [30000, -30000], [30000, 30000], [-30000, 30000]], holes: [[[0, 0], [10000, 0], [10000, 8000], [0, 8000]]], material: "Lawn" });
+     * ```
+     */
+    addTerrain(inputs) {
+        var _a;
+        const resolved = resolveDto(Inputs.IFC.AddTerrainDto, inputs);
+        const model = modelOf(resolved.model);
+        requireOutline(resolved.outline, "outline");
+        ((_a = resolved.holes) !== null && _a !== void 0 ? _a : []).forEach((hole, index) => requireOutline(hole, `hole ${index}`));
+        requireFinite(resolved.elevation, "elevation");
+        return editModel(model, (tx, writer) => {
+            var _a;
+            createTerrain(tx, writer, {
+                id: resolved.id,
+                name: resolved.name,
+                outline: resolved.outline,
+                holes: (_a = resolved.holes) !== null && _a !== void 0 ? _a : [],
+                depth: lengthIn(model, resolved.depth, DEFAULT_MILLIMETRES.terrainDepth),
+                elevation: resolved.elevation,
+                material: resolved.material,
+            }, lengthTolerance(model));
+        });
+    }
+    /**
+     * Adds a tree to the site: a tapering trunk and a rounded crown at `position`, `height` tall,
+     * each part in its own material, with its species written as the element's object type.
+     * @param inputs - The model, where the tree stands, its sizes, its species and its materials
+     * @returns A new model with the tree
+     * @group create
+     * @shortname add tree
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.site.addTree({ model, species: "Silver birch", position: [-6000, -8000], height: 9000, crownRadius: 2200, crownMaterial: "Foliage", trunkMaterial: "Bark" });
+     * ```
+     */
+    addTree(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddTreeDto, inputs);
+        const model = modelOf(resolved.model);
+        requireFinite(resolved.position[0], "position's x");
+        requireFinite(resolved.position[1], "position's y");
+        requireFinite(resolved.elevation, "elevation");
+        return editModel(model, (tx, writer) => {
+            createTree(tx, writer, {
+                id: resolved.id,
+                name: resolved.name,
+                species: resolved.species,
+                position: resolved.position,
+                elevation: resolved.elevation,
+                height: lengthIn(model, resolved.height, DEFAULT_MILLIMETRES.treeHeight),
+                crownRadius: lengthIn(model, resolved.crownRadius, DEFAULT_MILLIMETRES.crownRadius),
+                trunkRadius: lengthIn(model, resolved.trunkRadius, DEFAULT_MILLIMETRES.trunkRadius),
+                crownMaterial: resolved.crownMaterial,
+                trunkMaterial: resolved.trunkMaterial,
+            });
+        });
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Slabs: floors, roofs and landings, each an outline in a storey's plan with optional holes,
+ * extruded down from its top by its thickness or by the layer set it is made of.
+ * @beta
+ */
+export declare class IFCSlabs {
+    /**
+     * Adds a slab: an outline in a storey's plan, with optional holes, its top `topOffset` above the
+     * storey's floor and its thickness below that.
+     *
+     * The slab is made of the named `layerSet`, first layer at the top, or of one layer `thickness`
+     * thick. Outlines may wind either way.
+     * @param inputs - The model, the storey, the outline and holes, the thickness or layer set, and the slab's kind
+     * @returns A new model with the slab
+     * @group create
+     * @shortname add slab
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.slabs.add({
+     *     model,
+     *     storey: "ground",
+     *     outline: [[0, 0], [10000, 0], [10000, 8000], [0, 8000]],
+     *     thickness: 250,
+     * });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddSlabDto<IfcModel>): IfcModel;
+}

package/lib/api/services/slabs.js

@@ -0,0 +1,59 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { requireFinite, requireOutline } from "../../build/checks";
+import { layerSetFor } from "../../build/materials";
+import { createSlab } from "../../build/slabs-columns-beams";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, lengthTolerance, modelOf, oneOf, resolveId } from "./service-support";
+/**
+ * Slabs: floors, roofs and landings, each an outline in a storey's plan with optional holes,
+ * extruded down from its top by its thickness or by the layer set it is made of.
+ * @beta
+ */
+export class IFCSlabs {
+    /**
+     * Adds a slab: an outline in a storey's plan, with optional holes, its top `topOffset` above the
+     * storey's floor and its thickness below that.
+     *
+     * The slab is made of the named `layerSet`, first layer at the top, or of one layer `thickness`
+     * thick. Outlines may wind either way.
+     * @param inputs - The model, the storey, the outline and holes, the thickness or layer set, and the slab's kind
+     * @returns A new model with the slab
+     * @group create
+     * @shortname add slab
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.slabs.add({
+     *     model,
+     *     storey: "ground",
+     *     outline: [[0, 0], [10000, 0], [10000, 8000], [0, 8000]],
+     *     thickness: 250,
+     * });
+     * ```
+     */
+    add(inputs) {
+        var _a;
+        const resolved = resolveDto(Inputs.IFC.AddSlabDto, inputs);
+        const model = modelOf(resolved.model);
+        requireOutline(resolved.outline, "outline");
+        const holes = (_a = resolved.holes) !== null && _a !== void 0 ? _a : [];
+        holes.forEach((hole, index) => requireOutline(hole, `hole ${index}`));
+        requireFinite(resolved.topOffset, "slab's top offset");
+        const storey = resolveId(model, resolved.storey, "IfcBuildingStorey", "storey");
+        const predefinedType = oneOf(resolved.predefinedType, Inputs.IFC.slabPredefinedTypeEnum, "predefined type");
+        const thickness = lengthIn(model, resolved.thickness, DEFAULT_MILLIMETRES.slabThickness);
+        return editModel(model, (tx, writer) => {
+            createSlab(tx, writer, {
+                storey,
+                id: resolved.id,
+                name: resolved.name,
+                outline: resolved.outline,
+                holes,
+                layerSet: layerSetFor(tx, writer, resolved.layerSet, thickness, "Slab"),
+                topOffset: resolved.topOffset,
+                predefinedType,
+            }, lengthTolerance(model));
+        });
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * 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 declare 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: Inputs.IFC.AddSpaceDto<IfcModel>): IfcModel;
+    /**
+     * 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: Inputs.IFC.SpacesDto<IfcModel>): Inputs.IFC.SpaceInfoDto[];
+}