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

package/lib/api/services/geometry.js

@@ -0,0 +1,87 @@
+import { textValue } from "../../step/values";
+import { resolveDto } from "@bitbybit-dev/base";
+import { millimetresPerUnit } from "../../build/project";
+import { modelRecipe } from "../../geometry/elements";
+import * as Inputs from "../inputs";
+import { lengthTolerance, modelOf, resolveId } from "./service-support";
+function described(memo, inputs) {
+    var _a;
+    const model = modelOf(inputs.model);
+    const elements = inputs.elements;
+    if (elements !== undefined && !Array.isArray(elements)) {
+        throw new TypeError("Expected the elements as a list of GlobalIds or ids");
+    }
+    const key = JSON.stringify([elements !== null && elements !== void 0 ? elements : null, inputs.groupByClass]);
+    const last = memo.get(model);
+    if ((last === null || last === void 0 ? void 0 : last.key) === key) {
+        return last.described;
+    }
+    const globalIds = (_a = inputs.elements) === null || _a === void 0 ? void 0 : _a.map((element) => selectedGlobalId(model, element));
+    const result = modelRecipe(model, globalIds, millimetresPerUnit(model), lengthTolerance(model), inputs.groupByClass);
+    memo.set(model, { key, described: result });
+    return result;
+}
+const PRODUCT = "IfcProduct";
+function selectedGlobalId(model, element) {
+    var _a;
+    const owners = model.globalIdOwners(element);
+    if (owners.length > 1 && owners.every((owner) => { var _a; return model.schema.isSubtypeOf((_a = model.typeOf(owner)) !== null && _a !== void 0 ? _a : "", PRODUCT); })) {
+        return element;
+    }
+    return (_a = textValue(model.attribute(resolveId(model, element, PRODUCT, "element"), "GlobalId"))) !== null && _a !== void 0 ? _a : "";
+}
+/**
+ * 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 class IFCGeometry {
+    constructor() {
+        this.lastDescribed = new WeakMap();
+    }
+    /**
+     * 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) {
+        const resolved = resolveDto(Inputs.IFC.GeometryDto, inputs);
+        return described(this.lastDescribed, resolved).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) {
+        return described(this.lastDescribed, Object.assign(Object.assign({}, inputs), { groupByClass: true })).problems;
+    }
+}

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

@@ -0,0 +1,17 @@
+export * from "./model";
+export * from "./spatial";
+export * from "./spaces";
+export * from "./materials";
+export * from "./walls";
+export * from "./openings";
+export * from "./doors";
+export * from "./windows";
+export * from "./slabs";
+export * from "./roofs";
+export * from "./site";
+export * from "./columns";
+export * from "./beams";
+export * from "./members";
+export * from "./properties";
+export * from "./quantities";
+export * from "./geometry";

package/lib/api/services/index.js

@@ -0,0 +1,17 @@
+export * from "./model";
+export * from "./spatial";
+export * from "./spaces";
+export * from "./materials";
+export * from "./walls";
+export * from "./openings";
+export * from "./doors";
+export * from "./windows";
+export * from "./slabs";
+export * from "./roofs";
+export * from "./site";
+export * from "./columns";
+export * from "./beams";
+export * from "./members";
+export * from "./properties";
+export * from "./quantities";
+export * from "./geometry";

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

@@ -0,0 +1,46 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * The materials elements are made of: plain materials with an optional colour, and layer sets that
+ * stack materials into the thickness of a wall or slab. Materials and layer sets are referred to by
+ * their names, which are unique in a model.
+ * @beta
+ */
+export declare class IFCMaterials {
+    /**
+     * Adds a material, which layer sets, columns and beams then refer to by its name.
+     *
+     * With a `color`, the material carries a surface style that viewers show it in.
+     * @param inputs - The model, the material's name, category, colour and transparency
+     * @returns A new model with the material
+     * @group materials
+     * @shortname add material
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.materials.add({ model, name: "Brick", category: "brick", color: "#b5651d" });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddMaterialDto<IfcModel>): IfcModel;
+    /**
+     * Adds a layer set: materials stacked in order, each with its thickness, which walls, wall types,
+     * slabs and roofs are then made of.
+     *
+     * A wall's first layer is on its right face, looking from its start to its end; a slab's or a
+     * roof's first layer is at its top. A layer's material must have been added before, by name.
+     * @param inputs - The model, the layer set's name and its layers
+     * @returns A new model with the layer set
+     * @group materials
+     * @shortname add layer set
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.materials.addLayerSet({
+     *     model,
+     *     name: "Exterior wall",
+     *     layers: [{ material: "Brick", thickness: 115 }, { material: "Insulation", thickness: 100 }],
+     * });
+     * ```
+     */
+    addLayerSet(inputs: Inputs.IFC.AddLayerSetDto<IfcModel>): IfcModel;
+}

package/lib/api/services/materials.js

@@ -0,0 +1,86 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { createLayerSet, createMaterial } from "../../build/materials";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { editModel, lengthIn, modelOf } from "./service-support";
+const HEX_COLOUR = /^#?([0-9a-fA-F]{6})$/;
+const HEX_RADIX = 16;
+const CHANNEL_MAX = 255;
+const GREEN_AT = 2;
+const BLUE_AT = 4;
+function parseHexColour(color, transparency) {
+    const match = HEX_COLOUR.exec(color);
+    if (!match) {
+        throw new Error(`A colour is written as hex such as #b5651d, got '${color}'`);
+    }
+    const hex = match[1];
+    const channel = (at) => Number.parseInt(hex.slice(at, at + 2), HEX_RADIX) / CHANNEL_MAX;
+    return { red: channel(0), green: channel(GREEN_AT), blue: channel(BLUE_AT), transparency };
+}
+/**
+ * The materials elements are made of: plain materials with an optional colour, and layer sets that
+ * stack materials into the thickness of a wall or slab. Materials and layer sets are referred to by
+ * their names, which are unique in a model.
+ * @beta
+ */
+export class IFCMaterials {
+    /**
+     * Adds a material, which layer sets, columns and beams then refer to by its name.
+     *
+     * With a `color`, the material carries a surface style that viewers show it in.
+     * @param inputs - The model, the material's name, category, colour and transparency
+     * @returns A new model with the material
+     * @group materials
+     * @shortname add material
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.materials.add({ model, name: "Brick", category: "brick", color: "#b5651d" });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddMaterialDto, inputs);
+        const model = modelOf(resolved.model);
+        if (!(resolved.transparency >= 0 && resolved.transparency <= 1)) {
+            throw new RangeError(`Transparency goes from 0 to 1, got ${resolved.transparency}`);
+        }
+        const colour = resolved.color === undefined ? undefined : parseHexColour(resolved.color, resolved.transparency);
+        return editModel(model, (tx, writer) => {
+            createMaterial(tx, writer, resolved.name, resolved.category, colour);
+        });
+    }
+    /**
+     * Adds a layer set: materials stacked in order, each with its thickness, which walls, wall types,
+     * slabs and roofs are then made of.
+     *
+     * A wall's first layer is on its right face, looking from its start to its end; a slab's or a
+     * roof's first layer is at its top. A layer's material must have been added before, by name.
+     * @param inputs - The model, the layer set's name and its layers
+     * @returns A new model with the layer set
+     * @group materials
+     * @shortname add layer set
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.materials.addLayerSet({
+     *     model,
+     *     name: "Exterior wall",
+     *     layers: [{ material: "Brick", thickness: 115 }, { material: "Insulation", thickness: 100 }],
+     * });
+     * ```
+     */
+    addLayerSet(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddLayerSetDto, inputs);
+        const model = modelOf(resolved.model);
+        if (!Array.isArray(resolved.layers)) {
+            throw new TypeError("Expected the layers as a list");
+        }
+        const layers = resolved.layers.map((layer) => {
+            const full = resolveDto(Inputs.IFC.MaterialLayerDto, layer);
+            return { material: full.material, thickness: lengthIn(model, full.thickness, DEFAULT_MILLIMETRES.layerThickness), name: full.name };
+        });
+        return editModel(model, (tx, writer) => {
+            createLayerSet(tx, writer, resolved.name, layers);
+        });
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { ProfileSpec } from "../../build/build-types";
+import type { ModelSnapshot } from "../../model/snapshot";
+import type { IfcTransaction } from "../../model/transaction";
+import type * as Resolved from "../resolved-inputs";
+export declare function profileOf(model: ModelSnapshot, resolved: Resolved.IFC.AddColumnDto<unknown> | Resolved.IFC.AddBeamDto<unknown> | Resolved.IFC.AddMemberDto<unknown>): ProfileSpec;
+export declare function memberMaterial(tx: IfcTransaction, name: string | undefined): number | undefined;
+export declare function finiteRotation(rotation: number): void;

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

@@ -0,0 +1,29 @@
+import { requireFinite } from "../../build/checks";
+import { requireMaterial } from "../../build/materials";
+import * as Inputs from "../inputs";
+import { DEFAULT_MILLIMETRES } from "./defaults.constants";
+import { lengthIn, oneOf } from "./service-support";
+export function profileOf(model, resolved) {
+    const width = lengthIn(model, resolved.width, DEFAULT_MILLIMETRES.sectionWidth);
+    const depth = lengthIn(model, resolved.depth, DEFAULT_MILLIMETRES.sectionDepth);
+    switch (oneOf(resolved.profile, Inputs.IFC.profileKindEnum, "profile")) {
+        case Inputs.IFC.profileKindEnum.circle:
+            return { kind: Inputs.IFC.profileKindEnum.circle, radius: lengthIn(model, resolved.radius, DEFAULT_MILLIMETRES.sectionRadius) };
+        case Inputs.IFC.profileKindEnum.iShape:
+            return {
+                kind: Inputs.IFC.profileKindEnum.iShape,
+                width,
+                depth,
+                webThickness: lengthIn(model, resolved.webThickness, DEFAULT_MILLIMETRES.webThickness),
+                flangeThickness: lengthIn(model, resolved.flangeThickness, DEFAULT_MILLIMETRES.flangeThickness),
+            };
+        default:
+            return { kind: Inputs.IFC.profileKindEnum.rectangle, width, depth };
+    }
+}
+export function memberMaterial(tx, name) {
+    return name === undefined ? undefined : requireMaterial(tx, name);
+}
+export function finiteRotation(rotation) {
+    requireFinite(rotation, "rotation in degrees");
+}

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

@@ -0,0 +1,24 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Members: the linear parts of frames, roofs and facades that are neither columns nor beams, such as
+ * braces, rafters, studs and mullions, each a section swept straight between two points.
+ * @beta
+ */
+export declare class IFCMembers {
+    /**
+     * Adds a member from `start` to `end` in a storey, its section centred on the line between them,
+     * as a brace, a rafter, a stud, a mullion or another kind. The section is chosen by `profile` and
+     * turned by `rotation` as for beams.
+     * @param inputs - The model, the storey, the two ends, the section and the kind of member
+     * @returns A new model with the member
+     * @group create
+     * @shortname add member
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.members.add({ model, storey: "ground", start: [0, 0, 0], end: [4000, 0, 3000], predefinedType: Bit.Inputs.IFC.memberPredefinedTypeEnum.brace, width: 100, depth: 100 });
+     * ```
+     */
+    add(inputs: Inputs.IFC.AddMemberDto<IfcModel>): IfcModel;
+}

package/lib/api/services/members.js

@@ -0,0 +1,51 @@
+import { resolveDto } from "@bitbybit-dev/base";
+import { requirePoint } from "../../build/checks";
+import { POINT3_SIZE } from "../../build/constants";
+import { createMember } from "../../build/slabs-columns-beams";
+import * as Inputs from "../inputs";
+import { finiteRotation, memberMaterial, profileOf } from "./member-support";
+import { editModel, modelOf, oneOf, resolveId } from "./service-support";
+/**
+ * Members: the linear parts of frames, roofs and facades that are neither columns nor beams, such as
+ * braces, rafters, studs and mullions, each a section swept straight between two points.
+ * @beta
+ */
+export class IFCMembers {
+    /**
+     * Adds a member from `start` to `end` in a storey, its section centred on the line between them,
+     * as a brace, a rafter, a stud, a mullion or another kind. The section is chosen by `profile` and
+     * turned by `rotation` as for beams.
+     * @param inputs - The model, the storey, the two ends, the section and the kind of member
+     * @returns A new model with the member
+     * @group create
+     * @shortname add member
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.members.add({ model, storey: "ground", start: [0, 0, 0], end: [4000, 0, 3000], predefinedType: Bit.Inputs.IFC.memberPredefinedTypeEnum.brace, width: 100, depth: 100 });
+     * ```
+     */
+    add(inputs) {
+        const resolved = resolveDto(Inputs.IFC.AddMemberDto, 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");
+        const predefinedType = oneOf(resolved.predefinedType, Inputs.IFC.memberPredefinedTypeEnum, "predefined type");
+        return editModel(model, (tx, writer) => {
+            createMember(tx, writer, "IfcMember", {
+                storey,
+                id: resolved.id,
+                name: resolved.name,
+                start: resolved.start,
+                end: resolved.end,
+                profile,
+                rotation: resolved.rotation,
+                material: memberMaterial(tx, resolved.material),
+                predefinedType,
+            });
+        });
+    }
+}

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

@@ -0,0 +1,244 @@
+import type { IfcModel } from "../../model/model-types";
+import * as Inputs from "../inputs";
+/**
+ * Creates, reads, writes and inspects whole IFC models. A model is a value: every method that
+ * changes one returns a new model and leaves the one it was given as it was, so a change can be
+ * undone by keeping the earlier model.
+ *
+ * Objects are found by their GlobalId or by the id given when they were added, such as `north-wall`,
+ * which the model turns into a GlobalId of its own. Storeys are in `spatial`, building elements in
+ * `walls`, `slabs`, `doors` and the rest.
+ * @beta
+ */
+export declare class IFCModels {
+    /**
+     * Starts a new IFC4 model with a project, its site and one building, ready for storeys.
+     *
+     * Every length later given to the model is in `lengthUnit`, millimetres by default. With a
+     * `seed`, the same calls always write the same file; without one, the GlobalIds are random.
+     * @param inputs - The project's name, the site and building names, the length unit and a seed
+     * @returns A new model
+     * @group create
+     * @shortname create model
+     * @drawable false
+     * @example
+     * ```typescript
+     * let model = await bitbybit.ifc.model.create({ name: "House", seed: "house-1" });
+     * model = await bitbybit.ifc.spatial.addStorey({ model, id: "ground", name: "Ground floor", elevation: 0 });
+     * ```
+     */
+    create(inputs: Inputs.IFC.CreateModelDto): IfcModel;
+    /**
+     * Reads an IFC file into a model to inspect, change and write back.
+     *
+     * Entities are decoded only when asked for, and unchanged ones are written back exactly as read.
+     * An IFC2X3 file is read through IFC4, to be shown and queried; `upgradeToIfc4` makes it
+     * editable. An `.ifczip` archive is read from the `.ifc` file it holds.
+     * @param inputs - The file's text or bytes
+     * @returns The model the file holds
+     * @group io
+     * @shortname read ifc
+     * @drawable false
+     * @example
+     * ```typescript
+     * const model = await bitbybit.ifc.model.read({ data: ifcText });
+     * const summary = await bitbybit.ifc.model.summary({ model });
+     * ```
+     */
+    read(inputs: Inputs.IFC.ReadModelDto): IfcModel;
+    /**
+     * Turns a model read from an IFC2X3 file into an IFC4 model, which can be changed and is
+     * written as IFC4.
+     *
+     * New attributes stay unset, a newly required enumeration takes `NOTDEFINED`, sets lose repeats
+     * and a merged entity becomes its parent; other rows are written as read. Anything else stops
+     * the upgrade, naming the entity.
+     * @param inputs - The model
+     * @returns The upgraded model
+     * @group io
+     * @shortname upgrade to ifc4
+     * @drawable false
+     * @example
+     * ```typescript
+     * const old = await bitbybit.ifc.model.read({ data: ifc2x3Bytes });
+     * const model = await bitbybit.ifc.model.upgradeToIfc4({ model: old });
+     * ```
+     */
+    upgradeToIfc4(inputs: Inputs.IFC.ModelDto<IfcModel>): IfcModel;
+    /**
+     * Writes a model as the text of an `.ifc` file.
+     *
+     * The header records `fileName` and `timeStamp`; give a fixed `timeStamp` to write the same text
+     * every time. Entities read from a file and left unchanged are written as they were read, character
+     * for character.
+     * @param inputs - The model, the file name and the time stamp
+     * @returns The text of the IFC file
+     * @group io
+     * @shortname write ifc
+     * @drawable false
+     * @example
+     * ```typescript
+     * const text = await bitbybit.ifc.model.write({ model, fileName: "house.ifc" });
+     * ```
+     */
+    write(inputs: Inputs.IFC.WriteModelDto<IfcModel>): string;
+    /**
+     * Writes a model as the bytes of an `.ifc` file, at any size.
+     *
+     * The header records `fileName` and `timeStamp`, as `model.write`'s does. Entities read from a file
+     * and left unchanged are copied byte for byte, so a file of hundreds of megabytes writes in a moment,
+     * where its text would not fit one JavaScript string.
+     * @param inputs - The model, the file name and the time stamp
+     * @returns The bytes of the IFC file
+     * @group io
+     * @shortname write ifc bytes
+     * @drawable false
+     * @example
+     * ```typescript
+     * const bytes = await bitbybit.ifc.model.writeBytes({ model, fileName: "house.ifc" });
+     * ```
+     */
+    writeBytes(inputs: Inputs.IFC.WriteModelDto<IfcModel>): Uint8Array;
+    /**
+     * Describes what a model holds: its schema, its project, its unit, its storeys and how many
+     * elements of each type.
+     * @param inputs - The model
+     * @returns The model's summary
+     * @group query
+     * @shortname summary
+     * @drawable false
+     * @example
+     * ```typescript
+     * const summary = await bitbybit.ifc.model.summary({ model });
+     * console.log(summary.elementCounts.IfcWall);
+     * ```
+     */
+    summary(inputs: Inputs.IFC.ModelDto<IfcModel>): Inputs.IFC.ModelSummaryDto;
+    /**
+     * Reads where a model sits on the Earth: the map conversion that places its coordinates in a
+     * projected coordinate reference system, and its site's reference latitude, longitude and
+     * elevation. A file without them gives the defaults, with `mapped` and `located` false.
+     * @param inputs - The model
+     * @returns The model's georeference
+     * @group query
+     * @shortname georeference
+     * @drawable false
+     * @example
+     * ```typescript
+     * const georeference = await bitbybit.ifc.model.georeference({ model });
+     * console.log(georeference.crs, georeference.eastings, georeference.northings);
+     * ```
+     */
+    georeference(inputs: Inputs.IFC.ModelDto<IfcModel>): Inputs.IFC.GeoreferenceDto;
+    /**
+     * Lists the objects of one IFC type, its subtypes included, optionally only those standing in
+     * one storey or other spatial element. An aggregate's part stands where its whole stands.
+     *
+     * `type` is any type with a GlobalId, such as `IfcWall`, `IfcDoor` or `IfcElement` for every
+     * building element. The list is in the order the model holds them.
+     * @param inputs - The model, the type and an optional storey
+     * @returns Each object's GlobalId, type, name and the spatial element it stands in
+     * @group query
+     * @shortname elements
+     * @drawable false
+     * @example
+     * ```typescript
+     * const walls = await bitbybit.ifc.model.elements({ model, type: "IfcWall", storey: "ground" });
+     * ```
+     */
+    elements(inputs: Inputs.IFC.ElementsDto<IfcModel>): Inputs.IFC.ElementInfoDto[];
+    /**
+     * Describes one object of a model: its GlobalId, its type, its name and the spatial element it
+     * stands in.
+     * @param inputs - The model and the object
+     * @returns The object's GlobalId, type, name and the spatial element it stands in
+     * @group query
+     * @shortname element
+     * @drawable false
+     * @example
+     * ```typescript
+     * const wall = await bitbybit.ifc.model.element({ model, element: "north-wall" });
+     * ```
+     */
+    element(inputs: Inputs.IFC.ElementDto<IfcModel>): Inputs.IFC.ElementInfoDto;
+    /**
+     * Removes an element, an empty storey or space, or a type nothing is of, with what only it uses.
+     * A wall takes its openings with their doors and windows, and the walls it was joined to are
+     * trimmed again; a door or window leaves its opening; an opening takes its doors and windows.
+     * @param inputs - The model and the object
+     * @returns A new model without the object
+     * @group edit
+     * @shortname remove
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.model.remove({ model, element: "partition" });
+     * ```
+     */
+    remove(inputs: Inputs.IFC.ElementDto<IfcModel>): IfcModel;
+    /**
+     * Moves an element or a space, and turns it about the vertical through its own origin; what is
+     * placed on it, such as a wall's openings, moves with it. A joined wall moves with `walls.edit`,
+     * and an opening, door or window with `openings.edit`.
+     * @param inputs - The model, the element, how far to move it and how far to turn it
+     * @returns A new model with the element moved
+     * @group edit
+     * @shortname move
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.model.move({ model, element: "column-1", translation: [500, 0, 0], rotation: 45 });
+     * ```
+     */
+    move(inputs: Inputs.IFC.MoveElementDto<IfcModel>): IfcModel;
+    /**
+     * Sets one attribute of an object to a text, a number, true or false, such as a wall's `Name`,
+     * `Description` or `Tag`.
+     *
+     * The value is checked against the IFC schema, and an attribute that holds a reference, a derived
+     * attribute or the `GlobalId` cannot be set this way.
+     * @param inputs - The model, the object, the attribute's name and the new value
+     * @returns A new model with the attribute set
+     * @group edit
+     * @shortname set attribute
+     * @drawable false
+     * @example
+     * ```typescript
+     * model = await bitbybit.ifc.model.setAttribute({ model, element: "north-wall", attribute: "Description", value: "Load bearing" });
+     * ```
+     */
+    setAttribute(inputs: Inputs.IFC.SetAttributeDto<IfcModel>): IfcModel;
+    /**
+     * Reads one attribute of an object, such as a wall's `Name`, `Description` or `Tag`.
+     *
+     * The value comes back as the model holds it: a text, a number, true or false, `null` when the
+     * attribute is unset, `{ enum }` for an enumeration value, `{ type, value }` for a typed value,
+     * `{ ref }` for a reference to another entity, or a list of these.
+     * @param inputs - The model, the object and the attribute's name
+     * @returns The attribute's value
+     * @group query
+     * @shortname get attribute
+     * @drawable false
+     * @example
+     * ```typescript
+     * const description = await bitbybit.ifc.model.getAttribute({ model, element: "north-wall", attribute: "Description" });
+     * ```
+     */
+    getAttribute(inputs: Inputs.IFC.GetAttributeDto<IfcModel>): Inputs.IFC.IfcAttributeValue;
+    /**
+     * Says which GlobalId an id stands for in a model: the GlobalId itself, or the one the model
+     * derives from an id of your own such as `north-wall`.
+     *
+     * The answer does not depend on whether the model holds such an object yet.
+     * @param inputs - The model and the id
+     * @returns The GlobalId, 22 characters
+     * @group query
+     * @shortname global id of
+     * @drawable false
+     * @example
+     * ```typescript
+     * const globalId = await bitbybit.ifc.model.globalIdOf({ model, id: "north-wall" });
+     * ```
+     */
+    globalIdOf(inputs: Inputs.IFC.GlobalIdOfDto<IfcModel>): string;
+}