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

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

@@ -0,0 +1,2727 @@
+import { Base } from "./base-inputs";
+import type { IfcValue } from "../../step/step-types";
+/**
+ * Every parameter object the IFC library accepts. IFC is the open BIM exchange format: a model is a
+ * graph of building elements, the storeys that contain them, their materials, types and properties,
+ * with geometry kept as parametric extrusions and clippings.
+ *
+ * Every method that changes a model takes one and returns a new one, leaving the one it was given
+ * as it was, so keep the result and pass it on. Lengths are in the model's length unit, millimetres
+ * unless the model was created with another; positions on a storey are in its plan, X and Y, with Z
+ * up from the storey's elevation. Experimental, as the IFC library is.
+ * @beta
+ */
+export declare namespace IFC {
+    /**
+     * A handle to an IFC model held by the library, not the model's data itself. Pass it to the next
+     * call that reads or changes the model; a change returns a new handle and leaves this one as it was.
+     */
+    type IfcModelPointer = {
+        hash: number;
+        type: "ifc-model";
+    };
+    /**
+     * One attribute value as a model holds it, as `model.getAttribute` returns 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.
+     */
+    type IfcAttributeValue = IfcValue;
+    /**
+     * The length unit a new model is written in. Every length a method takes or returns is in this unit.
+     */
+    enum lengthUnitEnum {
+        /**
+         * Lengths in millimetres, as most building models are written.
+         */
+        millimetre = "millimetre",
+        /**
+         * Lengths in centimetres.
+         */
+        centimetre = "centimetre",
+        /**
+         * Lengths in metres.
+         */
+        metre = "metre"
+    }
+    /**
+     * Which side of its axis a wall's layers lie on, looking from the wall's start to its end: centred on
+     * the axis, to its left, or to its right.
+     */
+    enum wallAlignmentEnum {
+        /**
+         * The layers are centred on the axis.
+         */
+        center = "center",
+        /**
+         * The layers lie to the left of the axis.
+         */
+        left = "left",
+        /**
+         * The layers lie to the right of the axis.
+         */
+        right = "right"
+    }
+    /**
+     * Where on a wall another wall meets it: at its start, at its end, or somewhere along its length.
+     */
+    enum wallEndEnum {
+        /**
+         * At the start of its axis.
+         */
+        start = "start",
+        /**
+         * At the end of its axis.
+         */
+        end = "end",
+        /**
+         * Somewhere along its length, as the stem of a T meets the wall it ends against.
+         */
+        along = "along"
+    }
+    /**
+     * What kind of wall it is, as IFC classifies walls.
+     */
+    enum wallPredefinedTypeEnum {
+        /**
+         * A straight wall of constant thickness, the common case.
+         */
+        standard = "STANDARD",
+        /**
+         * A wall of solid construction, such as masonry.
+         */
+        solidWall = "SOLIDWALL",
+        /**
+         * A wall that divides a space without carrying load.
+         */
+        partitioning = "PARTITIONING",
+        /**
+         * A wall that resists lateral forces.
+         */
+        shear = "SHEAR",
+        /**
+         * A low wall along the edge of a roof or balcony.
+         */
+        parapet = "PARAPET",
+        /**
+         * A wall that can be moved, such as a folding partition.
+         */
+        movable = "MOVABLE",
+        /**
+         * A wall that carries pipes, such as a service wall.
+         */
+        plumbingWall = "PLUMBINGWALL",
+        /**
+         * No kind is given.
+         */
+        notDefined = "NOTDEFINED"
+    }
+    /**
+     * The shape of a roof over a rectangle: flat, sloping one way, two slopes meeting at a ridge, or four
+     * slopes meeting at a ridge or a point.
+     */
+    enum roofKindEnum {
+        /**
+         * Flat, one level slab.
+         */
+        flat = "flat",
+        /**
+         * One slope, rising from the outline's first side to the opposite side.
+         */
+        monoPitch = "monoPitch",
+        /**
+         * Two slopes rising from the first side and the opposite side to a ridge between them.
+         */
+        gable = "gable",
+        /**
+         * Four slopes rising from every side, to a ridge along the longer sides or, over a square, to a
+         * point.
+         */
+        hip = "hip"
+    }
+    /**
+     * What kind of member it is, as IFC classifies the linear parts of frames, roofs and facades.
+     */
+    enum memberPredefinedTypeEnum {
+        /**
+         * A diagonal that stiffens a frame.
+         */
+        brace = "BRACE",
+        /**
+         * The top or bottom edge of a truss.
+         */
+        chord = "CHORD",
+        /**
+         * A horizontal tie between two rafters.
+         */
+        collar = "COLLAR",
+        /**
+         * A member of no more particular kind.
+         */
+        member = "MEMBER",
+        /**
+         * A vertical between panes of a window or a curtain wall.
+         */
+        mullion = "MULLION",
+        /**
+         * A flat member, such as a gusset.
+         */
+        plate = "PLATE",
+        /**
+         * A vertical support, such as a fence post.
+         */
+        post = "POST",
+        /**
+         * A horizontal member that carries roof covering across rafters.
+         */
+        purlin = "PURLIN",
+        /**
+         * A sloping member that carries a roof.
+         */
+        rafter = "RAFTER",
+        /**
+         * A sloping member that carries the treads of a stair.
+         */
+        stringer = "STRINGER",
+        /**
+         * A member that takes compression along its length.
+         */
+        strut = "STRUT",
+        /**
+         * A vertical member of a framed wall.
+         */
+        stud = "STUD",
+        /**
+         * Not said.
+         */
+        notDefined = "NOTDEFINED"
+    }
+    /**
+     * What kind of assembly it is, as IFC classifies elements made of other elements.
+     */
+    enum elementAssemblyPredefinedTypeEnum {
+        /**
+         * Parts that support or connect others, such as a bracket with its fixings.
+         */
+        accessoryAssembly = "ACCESSORY_ASSEMBLY",
+        /**
+         * An arch.
+         */
+        arch = "ARCH",
+        /**
+         * Beams laid in a grid.
+         */
+        beamGrid = "BEAM_GRID",
+        /**
+         * A frame stiffened by diagonal braces.
+         */
+        bracedFrame = "BRACED_FRAME",
+        /**
+         * A girder built up of plates and members.
+         */
+        girder = "GIRDER",
+        /**
+         * A cage of reinforcing bars placed as one.
+         */
+        reinforcementUnit = "REINFORCEMENT_UNIT",
+        /**
+         * A frame whose joints hold it rigid without braces.
+         */
+        rigidFrame = "RIGID_FRAME",
+        /**
+         * A field of slabs laid together.
+         */
+        slabField = "SLAB_FIELD",
+        /**
+         * A truss.
+         */
+        truss = "TRUSS",
+        /**
+         * A kind IFC does not name, such as a cladding of boards; `objectType` says what it is.
+         */
+        userDefined = "USERDEFINED",
+        /**
+         * An assembly of no particular kind.
+         */
+        notDefined = "NOTDEFINED"
+    }
+    /**
+     * What kind of space it is, as IFC classifies spaces.
+     */
+    enum spacePredefinedTypeEnum {
+        /**
+         * A room or an area of a storey.
+         */
+        space = "SPACE",
+        /**
+         * A parking bay.
+         */
+        parking = "PARKING",
+        /**
+         * The gross floor area of a storey, measured around its outside.
+         */
+        gfa = "GFA",
+        /**
+         * An enclosed space inside the building.
+         */
+        internal = "INTERNAL",
+        /**
+         * A space outside the building, such as a terrace.
+         */
+        external = "EXTERNAL",
+        /**
+         * Not said.
+         */
+        notDefined = "NOTDEFINED"
+    }
+    /**
+     * What kind of slab it is, as IFC classifies slabs.
+     */
+    enum slabPredefinedTypeEnum {
+        /**
+         * A floor slab.
+         */
+        floor = "FLOOR",
+        /**
+         * A roof slab.
+         */
+        roof = "ROOF",
+        /**
+         * A landing of a stair.
+         */
+        landing = "LANDING",
+        /**
+         * A slab on the ground, at the base of the building.
+         */
+        baseSlab = "BASESLAB",
+        /**
+         * No kind is given.
+         */
+        notDefined = "NOTDEFINED"
+    }
+    /**
+     * How a single-panel door opens, as IFC names its operation types. The door's geometry is the same
+     * panel for each; the operation is what other tools read to draw its swing. Left and right are as IFC
+     * defines them, seen looking along the door's Y axis, which points to its wall's left: standing on the
+     * wall's right side, with the wall's start on your left, a left door is hinged toward the wall's start
+     * and a right door toward its end. The handle is on the other edge.
+     */
+    enum doorOperationEnum {
+        /**
+         * One panel swinging, hinged on the left.
+         */
+        singleSwingLeft = "SINGLE_SWING_LEFT",
+        /**
+         * One panel swinging, hinged on the right.
+         */
+        singleSwingRight = "SINGLE_SWING_RIGHT",
+        /**
+         * One panel swinging both ways, hinged on the left.
+         */
+        doubleSwingLeft = "DOUBLE_SWING_LEFT",
+        /**
+         * One panel swinging both ways, hinged on the right.
+         */
+        doubleSwingRight = "DOUBLE_SWING_RIGHT",
+        /**
+         * One panel sliding to the left.
+         */
+        slidingToLeft = "SLIDING_TO_LEFT",
+        /**
+         * One panel sliding to the right.
+         */
+        slidingToRight = "SLIDING_TO_RIGHT",
+        /**
+         * One panel folding to the left.
+         */
+        foldingToLeft = "FOLDING_TO_LEFT",
+        /**
+         * One panel folding to the right.
+         */
+        foldingToRight = "FOLDING_TO_RIGHT",
+        /**
+         * A revolving door.
+         */
+        revolving = "REVOLVING",
+        /**
+         * A door that rolls up.
+         */
+        rollingUp = "ROLLINGUP",
+        /**
+         * No kind is given.
+         */
+        notDefined = "NOTDEFINED"
+    }
+    /**
+     * The handle a door type carries on both faces of its panel, on the side away from its hinges.
+     */
+    enum doorHandleEnum {
+        /**
+         * No handle.
+         */
+        none = "none",
+        /**
+         * A lever handle at hand height.
+         */
+        lever = "lever",
+        /**
+         * A long upright pull bar, as on an entrance door.
+         */
+        pullBar = "pullBar"
+    }
+    /**
+     * The shape of the section a column or beam is extruded from: a rectangle, a circle or an I section.
+     */
+    enum profileKindEnum {
+        /**
+         * A rectangle of `width` by `depth`.
+         */
+        rectangle = "rectangle",
+        /**
+         * A circle of `radius`.
+         */
+        circle = "circle",
+        /**
+         * An I section of `width` and `depth`, with `webThickness` and `flangeThickness`.
+         */
+        iShape = "iShape"
+    }
+    /**
+     * A model to read, for the methods that only look at it, such as `model.summary` and
+     * `spatial.storeys`.
+     */
+    class ModelDto<T> {
+        constructor(model?: T);
+        /**
+         * The model to read, as `model.create` or `model.read` returned it.
+         * @default undefined
+         */
+        model: T;
+    }
+    /**
+     * What `model.create` starts a new model with: a project, its site and one building, in the length
+     * unit every later length is given in.
+     */
+    class CreateModelDto {
+        constructor(name?: string, siteName?: string, buildingName?: string, lengthUnit?: lengthUnitEnum, seed?: string, author?: string, organization?: string);
+        /**
+         * The project's name.
+         * @default Project
+         */
+        name?: string | undefined;
+        /**
+         * The site's name.
+         * @default Site
+         */
+        siteName?: string | undefined;
+        /**
+         * What the one building the model starts with is called.
+         * @default Building
+         */
+        buildingName?: string | undefined;
+        /**
+         * The unit every length of the model is given and written in.
+         * @default millimetre
+         */
+        lengthUnit?: lengthUnitEnum | undefined;
+        /**
+         * Any text the model's GlobalIds are derived from, so running the same calls again writes the
+         * same file. Leave it out for random GlobalIds, unique to this model.
+         * @default undefined
+         * @optional true
+         */
+        seed?: string | undefined;
+        /**
+         * Who the file's header names as its author.
+         * @default undefined
+         * @optional true
+         */
+        author?: string | undefined;
+        /**
+         * The organization the file's header names.
+         * @default undefined
+         * @optional true
+         */
+        organization?: string | undefined;
+    }
+    /**
+     * The contents of an IFC file for `model.read`, as text or bytes.
+     */
+    class ReadModelDto {
+        constructor(data?: string | Uint8Array | ArrayBuffer);
+        /**
+         * The file's contents: the text of an `.ifc` file, or the bytes of an `.ifc` or `.ifczip`
+         * file, such as what `await file.arrayBuffer()` gives for a file a user picked.
+         * @default undefined
+         */
+        data: string | Uint8Array | ArrayBuffer;
+    }
+    /**
+     * A model to write for `model.write`, with the file name and time its header records.
+     */
+    class WriteModelDto<T> {
+        constructor(model?: T, fileName?: string, timeStamp?: string);
+        /**
+         * The model whose entities the file holds.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The file name the header records.
+         * @default model.ifc
+         */
+        fileName?: string | undefined;
+        /**
+         * When the file was written, as ISO 8601 such as `2026-10-06T12:00:00`. Left out, the current
+         * time; give one to write the same file every time.
+         * @default undefined
+         * @optional true
+         */
+        timeStamp?: string | undefined;
+    }
+    /**
+     * A model and a filter for `model.elements`, which lists the elements of one type, optionally on one
+     * storey.
+     */
+    class ElementsDto<T> {
+        constructor(model?: T, type?: string, storey?: string);
+        /**
+         * The model to list from.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The IFC type to list, its subtypes included, such as `IfcWall`, `IfcBuildingElement` for walls,
+         * slabs, doors and the like, or `IfcElement` for every element, openings included.
+         * @default IfcElement
+         */
+        type?: string | undefined;
+        /**
+         * Only the elements standing in this storey or other spatial element, by GlobalId or by the id
+         * it was added with. Leave it out for every one.
+         * @default undefined
+         * @optional true
+         */
+        storey?: string | undefined;
+    }
+    /**
+     * A model and one of its objects, by GlobalId or by the id it was added with, for `model.element`,
+     * `model.remove`, `properties.getSets` and `quantities.get`.
+     */
+    class ElementDto<T> {
+        constructor(model?: T, element?: string);
+        /**
+         * The model the object is in.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The object, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        element: string;
+    }
+    /**
+     * One attribute of an object to set for `model.setAttribute`, such as a wall's `Name` or `Tag`.
+     */
+    class SetAttributeDto<T> {
+        constructor(model?: T, element?: string, attribute?: string, value?: string | number | boolean);
+        /**
+         * The model the object is in.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The object, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        element: string;
+        /**
+         * The attribute's name, as the IFC schema spells it, such as `Name`, `Description` or `Tag`.
+         * @default Name
+         */
+        attribute?: string | undefined;
+        /**
+         * The new value: a text, a number, true or false, or the name of an enumeration value for an
+         * attribute that takes one.
+         * @default undefined
+         */
+        value: string | number | boolean;
+    }
+    /**
+     * An object's attribute to read for `model.getAttribute`.
+     */
+    class GetAttributeDto<T> {
+        constructor(model?: T, element?: string, attribute?: string);
+        /**
+         * The model the object is in.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The object, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        element: string;
+        /**
+         * The attribute's name, as the IFC schema spells it, such as `Name`, `Description` or `Tag`.
+         * @default Name
+         */
+        attribute?: string | undefined;
+    }
+    /**
+     * A model and an id for `model.globalIdOf`, which says which GlobalId the id stands for.
+     */
+    class GlobalIdOfDto<T> {
+        constructor(model?: T, id?: string);
+        /**
+         * The model the id belongs to; ids of different models stand for different GlobalIds.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * Any text used as an id, or a GlobalId, which stands for itself.
+         * @default undefined
+         */
+        id: string;
+    }
+    /**
+     * How far to move an element and how far to turn it, for `model.move`.
+     */
+    class MoveElementDto<T> {
+        constructor(model?: T, element?: string, translation?: Base.Vector3, rotation?: number);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The element or space, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        element: string;
+        /**
+         * How far to move it, as `[x, y, z]` in the plan of its storey: X and Y in plan, Z up.
+         * @default [0, 0, 0]
+         */
+        translation?: Base.Vector3 | undefined;
+        /**
+         * How far to turn it, in degrees counterclockwise seen from above, about the vertical through
+         * its own origin; it turns before it moves.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        rotation?: number | undefined;
+    }
+    /**
+     * A storey to add to the model's building for `spatial.addStorey`, at its elevation above the
+     * building's origin.
+     */
+    class AddStoreyDto<T> {
+        constructor(model?: T, id?: string, name?: string, elevation?: number);
+        /**
+         * The model to change, which must have exactly one building; it stays as it was, and the call
+         * returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * An id of your own, such as `ground`, by which later calls refer to the storey; the model turns
+         * it into a GlobalId. Left out, one is generated.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * What the storey is called, such as `Ground floor`.
+         * @default Storey
+         */
+        name?: string | undefined;
+        /**
+         * How high the storey's floor is above the building's origin.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        elevation?: number | undefined;
+    }
+    /**
+     * A material to add for `materials.add`, which layer sets, columns and beams then name.
+     */
+    class AddMaterialDto<T> {
+        constructor(model?: T, name?: string, category?: string, color?: string, transparency?: number);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The material's name, unique in the model, by which layer sets and members refer to it.
+         * @default Material
+         */
+        name?: string | undefined;
+        /**
+         * A broad category such as `concrete`, `steel`, `brick` or `timber`.
+         * @default undefined
+         * @optional true
+         */
+        category?: string | undefined;
+        /**
+         * The colour the material is shown with, as hex such as `#b5651d`. Leave it out for none.
+         * @default undefined
+         * @optional true
+         */
+        color?: string | undefined;
+        /**
+         * How see-through the material is shown, from 0 for opaque to 1 for invisible; used with
+         * `color`.
+         * @default 0
+         * @minimum 0
+         * @maximum 1
+         */
+        transparency?: number | undefined;
+    }
+    /**
+     * One layer of a layer set: its material, by name, and its thickness. Used by `materials.addLayerSet`.
+     */
+    class MaterialLayerDto {
+        constructor(material?: string, thickness?: number, name?: string);
+        /**
+         * The name of the layer's material, added before with `materials.add`. Leave it out for a layer
+         * without one.
+         * @default undefined
+         * @optional true
+         */
+        material?: string | undefined;
+        /**
+         * How thick the layer is, across the wall or down through the slab. Left out, 100 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         */
+        thickness?: number | undefined;
+        /**
+         * The layer's own name, such as `Insulation`.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+    }
+    /**
+     * A named stack of material layers for `materials.addLayerSet`, which walls, slabs and roofs are made
+     * of; a wall's first layer is on its right face, looking from start to end, a slab's or roof's at its
+     * top.
+     */
+    class AddLayerSetDto<T> {
+        constructor(model?: T, name?: string, layers?: MaterialLayerDto[]);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The layer set's name, unique in the model, by which walls, wall types and slabs refer to it.
+         * @default Layers
+         */
+        name?: string | undefined;
+        /**
+         * The layers, in order; their thicknesses add up to the thickness of what is made of them.
+         * @default undefined
+         */
+        layers: MaterialLayerDto[];
+    }
+    /**
+     * A storey as `spatial.storeys` and `model.summary` list it: its GlobalId, name and elevation.
+     */
+    class StoreyInfoDto {
+        /**
+         * The GlobalId that identifies the storey.
+         * @default ""
+         */
+        globalId: string;
+        /**
+         * What the storey is called.
+         * @default ""
+         */
+        name: string;
+        /**
+         * How high its floor is above the building's origin, in the model's length unit.
+         * @default 0
+         */
+        elevation: number;
+    }
+    /**
+     * A storey and its new elevation for `spatial.setElevation`.
+     */
+    class SetStoreyElevationDto<T> {
+        constructor(model?: T, storey?: string, elevation?: number);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The storey, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        storey: string;
+        /**
+         * How high its floor is now above the building's origin; everything on the storey moves with it.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        elevation?: number | undefined;
+    }
+    /**
+     * A space to add for `spaces.add`: a room or an area of a storey, an outline in the storey's plan
+     * extruded up to its height.
+     */
+    class AddSpaceDto<T> {
+        constructor(model?: T, storey?: string, id?: string, name?: string, longName?: string, outline?: Base.Point2[], height?: number, baseOffset?: number, predefinedType?: spacePredefinedTypeEnum);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The storey the space belongs to, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        storey: string;
+        /**
+         * An id of your own for the space. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * The space's short name or number, such as `1.04`.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * The space's full name, such as `Kitchen`.
+         * @default undefined
+         * @optional true
+         */
+        longName?: string | undefined;
+        /**
+         * The outline, as `[x, y]` points in the storey's plan, without the first repeated at the end;
+         * either winding works.
+         * @default undefined
+         */
+        outline: Base.Point2[];
+        /**
+         * How high the space reaches, up from its base. Left out, 3 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+        /**
+         * How far above the storey's floor the space starts.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        baseOffset?: number | undefined;
+        /**
+         * What kind of space it is.
+         * @default space
+         */
+        predefinedType?: spacePredefinedTypeEnum | undefined;
+    }
+    /**
+     * A model and, optionally, a storey, for `spaces.list`.
+     */
+    class SpacesDto<T> {
+        constructor(model?: T, storey?: string);
+        /**
+         * The model to list the spaces of.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * Only the spaces of this storey, by GlobalId or by the id it was added with. Leave it out for
+         * every storey.
+         * @default undefined
+         * @optional true
+         */
+        storey?: string | undefined;
+    }
+    /**
+     * A space as `spaces.list` describes it: its number and name, its storey, and its area and height.
+     */
+    class SpaceInfoDto {
+        /**
+         * The GlobalId that identifies the space.
+         * @default ""
+         */
+        globalId: string;
+        /**
+         * Its short name or number, or an empty text when it has none.
+         * @default ""
+         */
+        name: string;
+        /**
+         * Its full name, or an empty text when it has none.
+         * @default ""
+         */
+        longName: string;
+        /**
+         * The GlobalId of the storey it belongs to, or an empty text when it belongs to none.
+         * @default ""
+         */
+        storey: string;
+        /**
+         * The area of its outline, in the square of the model's length unit, so square millimetres in a
+         * millimetre model; 0 when its body is not an outline extruded up.
+         * @default 0
+         */
+        area: number;
+        /**
+         * How high it reaches; 0 when its body is not an outline extruded up.
+         * @default 0
+         */
+        height: number;
+    }
+    /**
+     * An element as `model.elements` and `model.element` describe it.
+     */
+    class ElementInfoDto {
+        /**
+         * The GlobalId that identifies the element.
+         * @default ""
+         */
+        globalId: string;
+        /**
+         * Its IFC type, such as `IfcWall`.
+         * @default ""
+         */
+        type: string;
+        /**
+         * Its name, or an empty text when it has none.
+         * @default ""
+         */
+        name: string;
+        /**
+         * The GlobalId of the spatial element it stands in: its storey, or a space, road, bridge or
+         * other facility part; an empty text when none contains it.
+         * @default ""
+         */
+        storey: string;
+    }
+    /**
+     * Where a model sits on the Earth, as `model.georeference` reads it: its map conversion and its
+     * site's reference latitude, longitude and elevation.
+     */
+    class GeoreferenceDto {
+        /**
+         * Whether the model holds a map conversion; when it does not, the map fields keep their defaults.
+         * @default false
+         */
+        mapped: boolean;
+        /**
+         * The name of the projected coordinate reference system the map conversion targets, such as
+         * `EPSG:3301`.
+         * @default ""
+         */
+        crs: string;
+        /**
+         * How far east of the map's origin the model's origin lies, in the map's unit.
+         * @default 0
+         */
+        eastings: number;
+        /**
+         * How far north of the map's origin the model's origin lies, in the map's unit.
+         * @default 0
+         */
+        northings: number;
+        /**
+         * The height of the model's origin above the vertical datum, in the map's unit.
+         * @default 0
+         */
+        orthogonalHeight: number;
+        /**
+         * The first map coordinate of the direction the model's X axis points in.
+         * @default 1
+         */
+        xAxisAbscissa: number;
+        /**
+         * The second map coordinate of the direction the model's X axis points in.
+         * @default 0
+         */
+        xAxisOrdinate: number;
+        /**
+         * The scale from the model's lengths to the map's.
+         * @default 1
+         */
+        scale: number;
+        /**
+         * Whether the site records a latitude and a longitude.
+         * @default false
+         */
+        located: boolean;
+        /**
+         * The site's reference latitude in decimal degrees, negative to the south.
+         * @default 0
+         */
+        latitude: number;
+        /**
+         * The site's reference longitude in decimal degrees, negative to the west.
+         * @default 0
+         */
+        longitude: number;
+        /**
+         * The site's reference elevation above sea level, in the model's length unit.
+         * @default 0
+         */
+        elevation: number;
+    }
+    /**
+     * What a model holds, as `model.summary` describes it.
+     */
+    class ModelSummaryDto {
+        /**
+         * The schema the model's file names, such as `IFC4`.
+         * @default ""
+         */
+        schema: string;
+        /**
+         * Whether the model can be changed: false for an `IFC2X3` file, which is read through `IFC4`
+         * to be shown and queried.
+         * @default true
+         */
+        editable: boolean;
+        /**
+         * What the project is called.
+         * @default ""
+         */
+        project: string;
+        /**
+         * How many millimetres one length unit of the model is.
+         * @default 1
+         */
+        millimetresPerUnit: number;
+        /**
+         * How many entities the model holds, geometry and relationships included.
+         * @default 0
+         */
+        entities: number;
+        /**
+         * The storeys, lowest first.
+         * @default []
+         */
+        storeys: StoreyInfoDto[];
+        /**
+         * How many elements of each IFC type the model holds, such as `{ IfcWall: 8 }`.
+         * @default {}
+         */
+        elementCounts: Record<string, number>;
+    }
+    /**
+     * A straight wall to add for `walls.add`: an axis from `start` to `end` on a storey, a height, and
+     * either a `thickness` or the layer set it is made of.
+     */
+    class AddWallDto<T> {
+        constructor(model?: T, storey?: string, id?: string, name?: string, start?: Base.Point2, end?: Base.Point2, height?: number, thickness?: number, layerSet?: string, alignment?: wallAlignmentEnum, baseOffset?: number, wallType?: string, predefinedType?: wallPredefinedTypeEnum);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The storey the wall stands on, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        storey: string;
+        /**
+         * An id of your own, such as `north-wall`, by which later calls refer to the wall; the model
+         * turns it into a GlobalId. Left out, one is generated.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the wall, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * The start of the wall's axis, as `[x, y]` in the storey's plan.
+         * @default undefined
+         */
+        start: Base.Point2;
+        /**
+         * The end of the wall's axis, as `[x, y]` in the storey's plan.
+         * @default undefined
+         */
+        end: Base.Point2;
+        /**
+         * The wall's height, up from its base. Left out, 3 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+        /**
+         * The wall's thickness, used when no `layerSet` is given; the wall is then one layer without a
+         * material. Left out, 200 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        thickness?: number | undefined;
+        /**
+         * The name of the layer set the wall is made of, added before with `materials.addLayerSet`; its
+         * layers set the thickness.
+         * @default undefined
+         * @optional true
+         */
+        layerSet?: string | undefined;
+        /**
+         * Which side of the axis the wall's layers lie on, looking from `start` to `end`. Walls drawn
+         * counterclockwise around a plan with `right` stand outside the outline.
+         * @default center
+         */
+        alignment?: wallAlignmentEnum | undefined;
+        /**
+         * How far above the storey's floor the wall starts.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        baseOffset?: number | undefined;
+        /**
+         * The wall type the wall is an occurrence of, by GlobalId or by the id it was added with.
+         * @default undefined
+         * @optional true
+         */
+        wallType?: string | undefined;
+        /**
+         * What kind of wall it is, for a wall without a `wallType`; a wall of a type is the kind its
+         * type says.
+         * @default standard
+         */
+        predefinedType?: wallPredefinedTypeEnum | undefined;
+    }
+    /**
+     * Two walls for `walls.connect`, which works out where they meet and trims both, or for
+     * `walls.disconnect`, which takes the join away.
+     */
+    class ConnectWallsDto<T> {
+        constructor(model?: T, wall?: string, other?: string);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * One wall, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        wall: string;
+        /**
+         * The other wall, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        other: string;
+    }
+    /**
+     * A wall and a plane to clip it with for `walls.clipByPlane`, which removes the part of the wall on
+     * the side the plane's normal points to.
+     */
+    class ClipWallDto<T> {
+        constructor(model?: T, wall?: string, origin?: Base.Point3, normal?: Base.Vector3);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The wall, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        wall: string;
+        /**
+         * A point on the plane, as `[x, y, z]` in the wall's storey: X and Y in plan, Z up from the
+         * storey's floor.
+         * @default undefined
+         */
+        origin: Base.Point3;
+        /**
+         * The plane's normal, pointing to the side that is removed; `[0, 0, 1]` cuts the top off level.
+         * @default [0, 0, 1]
+         */
+        normal?: Base.Vector3 | undefined;
+    }
+    /**
+     * A wall and a roof to clip it under, for `walls.clipByRoof`.
+     */
+    class ClipWallByRoofDto<T> {
+        constructor(model?: T, wall?: string, roof?: string);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The wall, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        wall: string;
+        /**
+         * The roof, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        roof: string;
+    }
+    /**
+     * A wall type to add for `walls.addType`: a named kind of wall made of a layer set, which walls are
+     * then occurrences of.
+     */
+    class AddWallTypeDto<T> {
+        constructor(model?: T, id?: string, name?: string, layerSet?: string, predefinedType?: wallPredefinedTypeEnum);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * An id of your own for the type, by which walls refer to it. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * The type's name.
+         * @default Wall type
+         */
+        name?: string | undefined;
+        /**
+         * The name of the layer set walls of this type are made of.
+         * @default undefined
+         */
+        layerSet: string;
+        /**
+         * What kind of wall the type is.
+         * @default standard
+         */
+        predefinedType?: wallPredefinedTypeEnum | undefined;
+    }
+    /**
+     * A wall of a model, for `walls.parameters`.
+     */
+    class WallDto<T> {
+        constructor(model?: T, wall?: string);
+        /**
+         * The model to read the wall from.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The wall, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        wall: string;
+    }
+    /**
+     * What to change about a wall for `walls.edit`. Everything left out stays as it is.
+     */
+    class EditWallDto<T> {
+        constructor(model?: T, wall?: string, start?: Base.Point2, end?: Base.Point2, height?: number, baseOffset?: number, thickness?: number, layerSet?: string, alignment?: wallAlignmentEnum);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The wall, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        wall: string;
+        /**
+         * The new start of the wall's axis, as `[x, y]` in its storey's plan. Openings keep their offset
+         * from the start.
+         * @default undefined
+         * @optional true
+         */
+        start?: Base.Point2 | undefined;
+        /**
+         * The new end of the wall's axis, as `[x, y]` in its storey's plan.
+         * @default undefined
+         * @optional true
+         */
+        end?: Base.Point2 | undefined;
+        /**
+         * The new height, up from the wall's base.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+        /**
+         * How far above its storey's floor the wall now starts; openings keep their sill above the
+         * wall's base.
+         * @default undefined
+         * @optional true
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        baseOffset?: number | undefined;
+        /**
+         * A new thickness, as one layer without a material; used when no `layerSet` is given.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        thickness?: number | undefined;
+        /**
+         * The name of the layer set the wall is now made of. A wall of a type keeps its type's layers.
+         * @default undefined
+         * @optional true
+         */
+        layerSet?: string | undefined;
+        /**
+         * Which side of the axis the layers now lie on. Left out, a wall keeps its side as its thickness
+         * changes: a wall aligned right stays aligned right.
+         * @default undefined
+         * @optional true
+         */
+        alignment?: wallAlignmentEnum | undefined;
+    }
+    /**
+     * One join of a wall, as `walls.parameters` lists it.
+     */
+    class WallJoinInfoDto {
+        /**
+         * The GlobalId of the wall it is joined to.
+         * @default ""
+         */
+        other: string;
+        /**
+         * Where on this wall the join is.
+         * @default start
+         */
+        at: wallEndEnum;
+        /**
+         * Where on the other wall the join is.
+         * @default start
+         */
+        otherAt: wallEndEnum;
+    }
+    /**
+     * A wall's parameters as `walls.parameters` reads them back from the model, whichever tool wrote it.
+     * Lengths are in the model's length unit, and points in the plan of the wall's storey.
+     */
+    class WallParametersDto {
+        /**
+         * The GlobalId that identifies the wall.
+         * @default ""
+         */
+        globalId: string;
+        /**
+         * The wall's name, or an empty text when it has none.
+         * @default ""
+         */
+        name: string;
+        /**
+         * The GlobalId of the storey that contains the wall, or an empty text when none does.
+         * @default ""
+         */
+        storey: string;
+        /**
+         * The start of the wall's axis, as `[x, y]`.
+         * @default [0, 0]
+         */
+        start: Base.Point2;
+        /**
+         * The end of the wall's axis, as `[x, y]`.
+         * @default [0, 0]
+         */
+        end: Base.Point2;
+        /**
+         * The wall's height, up from its base.
+         * @default 0
+         */
+        height: number;
+        /**
+         * How far above its storey's floor the wall starts.
+         * @default 0
+         */
+        baseOffset: number;
+        /**
+         * The wall's thickness, all its layers together.
+         * @default 0
+         */
+        thickness: number;
+        /**
+         * How far the layers' first face lies left of the axis, looking from start to end: 0 aligned left,
+         * minus the thickness aligned right.
+         * @default 0
+         */
+        offset: number;
+        /**
+         * Which side of the axis the layers lie on, or an empty text when they lie at an offset none of
+         * the alignments describe.
+         * @default ""
+         */
+        alignment: wallAlignmentEnum | "";
+        /**
+         * The name of the layer set the wall is made of.
+         * @default ""
+         */
+        layerSet: string;
+        /**
+         * The GlobalId of the wall's type, or an empty text when it has none.
+         * @default ""
+         */
+        wallType: string;
+        /**
+         * Each join of the wall: the other wall, and where on each wall the join is.
+         * @default []
+         */
+        joins: WallJoinInfoDto[];
+        /**
+         * The GlobalIds of the openings cut through it, filled or not.
+         * @default []
+         */
+        openings: string[];
+        /**
+         * How many planes clip the wall.
+         * @default 0
+         */
+        clippings: number;
+    }
+    /**
+     * A rectangular opening to cut through a wall for `openings.add`, measured along the wall from
+     * its start.
+     */
+    class AddOpeningDto<T> {
+        constructor(model?: T, wall?: string, id?: string, name?: string, offset?: number, sill?: number, width?: number, height?: number);
+        /**
+         * The model the wall is in.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The wall to cut, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        wall: string;
+        /**
+         * An id of your own for the opening. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the opening, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * How far along the wall's axis, from its start, the opening begins. Left out, 1 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         */
+        offset?: number | undefined;
+        /**
+         * How high above the wall's base the opening's bottom is.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        sill?: number | undefined;
+        /**
+         * The opening's width, along the wall. Left out, 1 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        width?: number | undefined;
+        /**
+         * How high the opening is, from its sill up. Left out, 2 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+    }
+    /**
+     * Where to move an opening to, or what size to make it, for `openings.edit`. Everything left out stays
+     * as it is.
+     */
+    class EditOpeningDto<T> {
+        constructor(model?: T, opening?: string, offset?: number, sill?: number, width?: number, height?: number);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The opening, or the door or window in it, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        opening: string;
+        /**
+         * How far along the wall's axis, from its start, the opening now begins.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         */
+        offset?: number | undefined;
+        /**
+         * How high above the wall's base the opening's bottom now is.
+         * @default undefined
+         * @optional true
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        sill?: number | undefined;
+        /**
+         * The opening's new width, along the wall; an opening with a door or window in it keeps their size.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        width?: number | undefined;
+        /**
+         * The opening's new height; an opening with a door or window in it keeps their size.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+    }
+    /**
+     * An opening to cut through a slab for `openings.addInSlab`: an outline in the plan of the slab's
+     * storey, cut through the slab's whole thickness.
+     */
+    class AddSlabOpeningDto<T> {
+        constructor(model?: T, slab?: string, id?: string, name?: string, outline?: Base.Point2[]);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The slab to cut, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        slab: string;
+        /**
+         * An id of your own for the opening. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the opening, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * The opening's outline, as `[x, y]` points in the storey's plan, inside the slab's outline or on
+         * it; either winding works.
+         * @default undefined
+         */
+        outline: Base.Point2[];
+    }
+    /**
+     * A door type to add for `doors.addType`: a lining around one panel, which every door of the type
+     * shares, so the geometry is written once however many doors there are.
+     */
+    class AddDoorTypeDto<T> {
+        constructor(model?: T, id?: string, name?: string, width?: number, height?: number, liningThickness?: number, liningDepth?: number, panelThickness?: number, operation?: doorOperationEnum, liningMaterial?: string, panelMaterial?: string, handle?: doorHandleEnum, handleMaterial?: string);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * An id of your own for the type, by which doors refer to it. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * The type's name.
+         * @default Door
+         */
+        name?: string | undefined;
+        /**
+         * The overall width, lining included; the opening a door of this type cuts is this wide. Left out, 900 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        width?: number | undefined;
+        /**
+         * The overall height, lining included. Left out, 2.1 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+        /**
+         * The width of the lining's sides and head; twice it must be less than `width`. Left out, 50 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        liningThickness?: number | undefined;
+        /**
+         * How deep the lining is, across the wall; the door is centred in the wall's thickness. Left out, 100 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        liningDepth?: number | undefined;
+        /**
+         * The panel's thickness, no more than `liningDepth`. Left out, 40 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        panelThickness?: number | undefined;
+        /**
+         * How the door opens, recorded for other tools to draw its swing.
+         * @default singleSwingLeft
+         */
+        operation?: doorOperationEnum | undefined;
+        /**
+         * The material the lining is made of, added before with `materials.add`; the lining shows its
+         * colour.
+         * @default undefined
+         * @optional true
+         */
+        liningMaterial?: string | undefined;
+        /**
+         * The material the panel is made of, added before with `materials.add`, such as glass for a
+         * sliding glass door; the panel shows its colour.
+         * @default undefined
+         * @optional true
+         */
+        panelMaterial?: string | undefined;
+        /**
+         * The handle on both faces of the panel, near the edge away from the hinges that `operation`
+         * names.
+         * @default none
+         */
+        handle?: doorHandleEnum | undefined;
+        /**
+         * The material the handle is made of, added before with `materials.add`; the handle shows its
+         * colour.
+         * @default undefined
+         * @optional true
+         */
+        handleMaterial?: string | undefined;
+    }
+    /**
+     * A window type to add for `windows.addType`: a frame around one pane of glass, which every window
+     * of the type shares.
+     */
+    class AddWindowTypeDto<T> {
+        constructor(model?: T, id?: string, name?: string, width?: number, height?: number, frameThickness?: number, frameDepth?: number, glassThickness?: number, frameMaterial?: string, glassMaterial?: string);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * An id of your own for the type, by which windows refer to it. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * The type's name.
+         * @default Window
+         */
+        name?: string | undefined;
+        /**
+         * The overall width, frame included; the opening a window of this type cuts is this wide. Left out, 1.2 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        width?: number | undefined;
+        /**
+         * The overall height, frame included. Left out, 1.2 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+        /**
+         * The width of the frame's members; twice it must be less than both `width` and `height`. Left out, 60 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        frameThickness?: number | undefined;
+        /**
+         * How deep the frame is, across the wall; the window is centred in the wall's thickness. Left out, 80 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        frameDepth?: number | undefined;
+        /**
+         * The thickness of the glass, no more than `frameDepth`. Left out, 24 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        glassThickness?: number | undefined;
+        /**
+         * The material the frame is made of, added before with `materials.add`; the frame shows its
+         * colour.
+         * @default undefined
+         * @optional true
+         */
+        frameMaterial?: string | undefined;
+        /**
+         * The material of the glass, added before with `materials.add`, usually with a `transparency`;
+         * the glass shows its colour.
+         * @default undefined
+         * @optional true
+         */
+        glassMaterial?: string | undefined;
+    }
+    /**
+     * A door to place in a wall for `doors.add`: a door type and where along the wall it goes. The door
+     * cuts its own opening, as wide and high as its type.
+     */
+    class AddDoorDto<T> {
+        constructor(model?: T, wall?: string, doorType?: string, id?: string, name?: string, offset?: number, sill?: number);
+        /**
+         * The model the wall is in.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The wall the door goes into, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        wall: string;
+        /**
+         * The door type, added before with `doors.addType`, by GlobalId or by its id.
+         * @default undefined
+         */
+        doorType: string;
+        /**
+         * An id of your own for the door. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the door, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * How far along the wall's axis, from its start, the door begins. Left out, 1 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         */
+        offset?: number | undefined;
+        /**
+         * How high above the wall's base the door's bottom is.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        sill?: number | undefined;
+    }
+    /**
+     * A window to place in a wall for `windows.add`: a window type and where along the wall it goes.
+     * The window cuts its own opening, as wide and high as its type.
+     */
+    class AddWindowDto<T> {
+        constructor(model?: T, wall?: string, windowType?: string, id?: string, name?: string, offset?: number, sill?: number);
+        /**
+         * The model the wall is in.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The wall the window goes into, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        wall: string;
+        /**
+         * The window type, added before with `windows.addType`, by GlobalId or by its id.
+         * @default undefined
+         */
+        windowType: string;
+        /**
+         * An id of your own for the window. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the window, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * How far along the wall's axis, from its start, the window begins. Left out, 1 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         */
+        offset?: number | undefined;
+        /**
+         * How high above the wall's base the window's bottom is. Left out, 900 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        sill?: number | undefined;
+    }
+    /**
+     * A slab to add for `slabs.add`: an outline in a storey's plan, with optional holes, extruded down
+     * from its top by its thickness.
+     */
+    class AddSlabDto<T> {
+        constructor(model?: T, storey?: string, id?: string, name?: string, outline?: Base.Point2[], holes?: Base.Point2[][], thickness?: number, layerSet?: string, topOffset?: number, predefinedType?: slabPredefinedTypeEnum);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The storey the slab belongs to, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        storey: string;
+        /**
+         * An id of your own for the slab. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the slab, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * The outline, as `[x, y]` points in the storey's plan, without the first repeated at the end;
+         * either winding works.
+         * @default undefined
+         */
+        outline: Base.Point2[];
+        /**
+         * Holes through the slab, each an outline like `outline`, inside it.
+         * @default undefined
+         * @optional true
+         */
+        holes?: Base.Point2[][] | undefined;
+        /**
+         * The slab's thickness, used when no `layerSet` is given. Left out, 200 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        thickness?: number | undefined;
+        /**
+         * The name of the layer set the slab is made of, its first layer at the top; its layers set the
+         * thickness.
+         * @default undefined
+         * @optional true
+         */
+        layerSet?: string | undefined;
+        /**
+         * How high the slab's top is above the storey's floor.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        topOffset?: number | undefined;
+        /**
+         * What kind of slab it is.
+         * @default floor
+         */
+        predefinedType?: slabPredefinedTypeEnum | undefined;
+    }
+    /**
+     * The section shared by `columns.add`, `beams.add` and `members.add`: its kind and the sizes that kind reads, a
+     * rectangle's `width` and `depth`, a circle's `radius`, or an I section's `width`, `depth`,
+     * `webThickness` and `flangeThickness`.
+     */
+    abstract class MemberSharedDto<T> {
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The storey the member belongs to, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        storey: string;
+        /**
+         * An id of your own for the member. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the column, beam or member, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * The section's shape.
+         * @default rectangle
+         */
+        profile?: profileKindEnum | undefined;
+        /**
+         * The section's size along its X: a rectangle's width, or an I section's flange width. Left out, 300 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        width?: number | undefined;
+        /**
+         * The section's size along its Y: a rectangle's depth, or an I section's overall depth. Left out, 300 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        depth?: number | undefined;
+        /**
+         * A circular section's radius. Left out, 150 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        radius?: number | undefined;
+        /**
+         * An I section's web thickness. Left out, 10 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        webThickness?: number | undefined;
+        /**
+         * An I section's flange thickness. Left out, 15 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        flangeThickness?: number | undefined;
+        /**
+         * How far the section turns about the member's own axis, in degrees.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        rotation?: number | undefined;
+        /**
+         * The name of the member's material, added before with `materials.add`.
+         * @default undefined
+         * @optional true
+         */
+        material?: string | undefined;
+    }
+    /**
+     * A column to add for `columns.add`: a section standing upright on a point of a storey's plan.
+     */
+    class AddColumnDto<T> extends MemberSharedDto<T> {
+        constructor(model?: T, storey?: string, position?: Base.Point2, height?: number, baseOffset?: number, id?: string, name?: string, profile?: profileKindEnum, width?: number, depth?: number, radius?: number, webThickness?: number, flangeThickness?: number, rotation?: number, material?: string);
+        /**
+         * Where the column stands, as `[x, y]` in the storey's plan; the section is centred on it.
+         * @default [0, 0]
+         */
+        position?: Base.Point2 | undefined;
+        /**
+         * How tall the column is, from its base up. Left out, 3 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+        /**
+         * How far above the storey's floor the column starts.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        baseOffset?: number | undefined;
+    }
+    /**
+     * A beam to add for `beams.add`: a section swept straight from `start` to `end`, centred on that
+     * line, with its Y up when the beam is not vertical.
+     */
+    class AddBeamDto<T> extends MemberSharedDto<T> {
+        constructor(model?: T, storey?: string, start?: Base.Point3, end?: Base.Point3, id?: string, name?: string, profile?: profileKindEnum, width?: number, depth?: number, radius?: number, webThickness?: number, flangeThickness?: number, rotation?: number, material?: string);
+        /**
+         * Where the beam's axis starts, as `[x, y, z]` in the storey: X and Y in plan, Z up from the
+         * storey's floor.
+         * @default undefined
+         */
+        start: Base.Point3;
+        /**
+         * Where the beam's axis ends.
+         * @default undefined
+         */
+        end: Base.Point3;
+    }
+    /**
+     * A member to add for `members.add`: a section swept straight from `start` to `end`, such as a brace,
+     * a rafter, a stud or a mullion.
+     */
+    class AddMemberDto<T> extends MemberSharedDto<T> {
+        constructor(model?: T, storey?: string, start?: Base.Point3, end?: Base.Point3, id?: string, name?: string, profile?: profileKindEnum, width?: number, depth?: number, radius?: number, webThickness?: number, flangeThickness?: number, rotation?: number, material?: string, predefinedType?: memberPredefinedTypeEnum);
+        /**
+         * Where the member's axis starts, as `[x, y, z]` in the storey: X and Y in plan, Z up from the
+         * storey's floor.
+         * @default undefined
+         */
+        start: Base.Point3;
+        /**
+         * Where the member's axis ends.
+         * @default undefined
+         */
+        end: Base.Point3;
+        /**
+         * What kind of member it is.
+         * @default member
+         */
+        predefinedType?: memberPredefinedTypeEnum | undefined;
+    }
+    /**
+     * A roof to add for `roofs.add`: a flat, mono-pitch, gable or hip roof over a rectangle in a storey's
+     * plan, written as an `IfcRoof` whose parts are sloping slabs.
+     */
+    class AddRoofDto<T> {
+        constructor(model?: T, storey?: string, id?: string, name?: string, outline?: Base.Point2[], kind?: roofKindEnum, pitch?: number, thickness?: number, layerSet?: string, overhang?: number, baseOffset?: number);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The storey the roof stands on, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        storey: string;
+        /**
+         * An id of your own for the roof. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the roof, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * The rectangle's four corners in the storey's plan, such as the walls' outer faces. A mono-pitch
+         * roof rises from the first side; a gable's ridge runs along it.
+         * @default undefined
+         */
+        outline: Base.Point2[];
+        /**
+         * The roof's shape.
+         * @default gable
+         */
+        kind?: roofKindEnum | undefined;
+        /**
+         * The slope of a sloping roof, in degrees from level, more than 0 and at most 89.
+         * @default 30
+         * @minimum 0
+         * @maximum 89
+         */
+        pitch?: number | undefined;
+        /**
+         * The roof's thickness, used when no `layerSet` is given. Left out, 200 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        thickness?: number | undefined;
+        /**
+         * The name of the layer set the roof is made of, its first layer at the top, as a slab's is; its
+         * layers set the thickness.
+         * @default undefined
+         * @optional true
+         */
+        layerSet?: string | undefined;
+        /**
+         * How far the roof reaches past the outline on every side, measured level.
+         * @default 0
+         * @minimum 0
+         * @maximum Infinity
+         */
+        overhang?: number | undefined;
+        /**
+         * How high above the storey's floor the roof's underside meets the outline, such as the height of
+         * the walls under it.
+         * @default 0
+         * @minimum -Infinity
+         * @maximum Infinity
+         */
+        baseOffset?: number | undefined;
+    }
+    /**
+     * An assembly to make for `assemblies.add`: an element made of other elements of the model, such as
+     * a facade's cladding boards or a truss's members, which then stand in the model through it.
+     */
+    class AddAssemblyDto<T> {
+        constructor(model?: T, parts?: string[], id?: string, name?: string, predefinedType?: elementAssemblyPredefinedTypeEnum, objectType?: string);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The elements the assembly is made of, by GlobalId or id. They must stand in one storey, or
+         * other part of the structure, and belong to no other assembly.
+         * @default undefined
+         */
+        parts: string[];
+        /**
+         * An id of your own for the assembly. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the assembly, which other tools show; it need not be unique.
+         * @default undefined
+         * @optional true
+         */
+        name?: string | undefined;
+        /**
+         * The kind of assembly, as IFC classifies them; `userDefined` for a kind it does not name, which
+         * `objectType` then says.
+         * @default notDefined
+         */
+        predefinedType?: elementAssemblyPredefinedTypeEnum | undefined;
+        /**
+         * What kind of assembly it is, in words, such as `Cladding`. Required when `predefinedType` is
+         * `userDefined`.
+         * @default undefined
+         * @optional true
+         */
+        objectType?: string | undefined;
+    }
+    /**
+     * Terrain to add for `site.addTerrain`: the ground of the site as an outline in the site's plan, with
+     * holes where a building or paving meets it, its top at `elevation` and reaching `depth` down.
+     */
+    class AddTerrainDto<T> {
+        constructor(model?: T, id?: string, name?: string, outline?: Base.Point2[], holes?: Base.Point2[][], depth?: number, elevation?: number, material?: string);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * An id of your own for the terrain. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the terrain, which other tools show.
+         * @default Terrain
+         */
+        name?: string | undefined;
+        /**
+         * The outline, as `[x, y]` points in the site's plan, without the first repeated at the end;
+         * either winding works.
+         * @default undefined
+         */
+        outline: Base.Point2[];
+        /**
+         * Holes in the ground, each an outline like `outline`, inside it, such as a building's footprint
+         * or paving that lies flush with the ground.
+         * @default undefined
+         * @optional true
+         */
+        holes?: Base.Point2[][] | undefined;
+        /**
+         * How far the ground reaches down from its top. Left out, 1 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        depth?: number | undefined;
+        /**
+         * How high the ground's top is above the site's origin.
+         * @default 0
+         */
+        elevation?: number | undefined;
+        /**
+         * The material of the ground, added before with `materials.add`, such as lawn or soil.
+         * @default undefined
+         * @optional true
+         */
+        material?: string | undefined;
+    }
+    /**
+     * A tree to add for `site.addTree`: a trunk and a rounded crown standing on the site at `position`,
+     * `height` tall overall, written as a geographic element of the site.
+     */
+    class AddTreeDto<T> {
+        constructor(model?: T, id?: string, name?: string, species?: string, position?: Base.Point2, elevation?: number, height?: number, crownRadius?: number, trunkRadius?: number, crownMaterial?: string, trunkMaterial?: string);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * An id of your own for the tree. Leave it out for a generated one.
+         * @default undefined
+         * @optional true
+         */
+        id?: string | undefined;
+        /**
+         * A name for the tree, which other tools show.
+         * @default Tree
+         */
+        name?: string | undefined;
+        /**
+         * What kind of tree it is, such as `Silver birch`, written as the element's object type.
+         * @default Tree
+         */
+        species?: string | undefined;
+        /**
+         * Where the trunk stands, as `[x, y]` in the site's plan.
+         * @default [0, 0]
+         */
+        position?: Base.Point2 | undefined;
+        /**
+         * How high above the site's origin the trunk stands.
+         * @default 0
+         */
+        elevation?: number | undefined;
+        /**
+         * The tree's height from the ground to the top of its crown. Left out, 8 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        height?: number | undefined;
+        /**
+         * How far the crown spreads from the trunk. Left out, 2.5 m, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        crownRadius?: number | undefined;
+        /**
+         * The trunk's radius at the ground; it narrows towards the crown. Left out, 150 mm, in the model's length unit.
+         * @default undefined
+         * @optional true
+         * @minimum 0
+         * @maximum Infinity
+         * @exclusiveMinimum true
+         */
+        trunkRadius?: number | undefined;
+        /**
+         * The material of the crown, added before with `materials.add`.
+         * @default undefined
+         * @optional true
+         */
+        crownMaterial?: string | undefined;
+        /**
+         * The material of the trunk, added before with `materials.add`.
+         * @default undefined
+         * @optional true
+         */
+        trunkMaterial?: string | undefined;
+    }
+    /**
+     * One property of a property set: its name, its value and, when the value needs one, its IFC type.
+     * Used by `properties.addSet` and `properties.setValues`. A type outside `IfcValue`, or a value it
+     * cannot hold, is refused.
+     */
+    class PropertyDto {
+        constructor(name?: string, value?: string | number | boolean, type?: string);
+        /**
+         * The property's name, such as `IsExternal` or `FireRating`.
+         * @default Property
+         */
+        name?: string | undefined;
+        /**
+         * The property's value: a text, a number, or true or false.
+         * @default undefined
+         */
+        value: string | number | boolean;
+        /**
+         * The IFC type of the value, any in IFC4's `IfcValue` select, such as `IfcText` or
+         * `IfcThermalTransmittanceMeasure`. Left out, a label, boolean, integer or real, as the value is.
+         * @default undefined
+         * @optional true
+         */
+        type?: string | undefined;
+    }
+    /**
+     * A property set to attach to elements for `properties.addSet`, such as `Pset_WallCommon` with its
+     * `IsExternal` and `LoadBearing`.
+     */
+    class AddPropertySetDto<T> {
+        constructor(model?: T, elements?: string[], name?: string, properties?: PropertyDto[]);
+        /**
+         * The model the elements are in.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The elements, types or other objects the set describes, each by GlobalId or by the id it was
+         * added with; one set is shared by all of them.
+         * @default undefined
+         */
+        elements: string[];
+        /**
+         * The set's name. Names starting with `Pset_` are reserved for the sets the IFC standard defines.
+         * @default Properties
+         */
+        name?: string | undefined;
+        /**
+         * The properties, each name once.
+         * @default undefined
+         */
+        properties: PropertyDto[];
+    }
+    /**
+     * Values to set in one property set of one object for `properties.setValues`; the set is made when
+     * the object has none of that name.
+     */
+    class SetPropertyValuesDto<T> {
+        constructor(model?: T, element?: string, name?: string, properties?: PropertyDto[]);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The element, type or other object, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        element: string;
+        /**
+         * The name of the property set, such as `Pset_WallCommon`.
+         * @default Properties
+         */
+        name?: string | undefined;
+        /**
+         * The properties to set, each name once; a property the set already holds takes the new value.
+         * @default undefined
+         */
+        properties: PropertyDto[];
+    }
+    /**
+     * Properties to take out of one property set of one object for `properties.removeValues`.
+     */
+    class RemovePropertyValuesDto<T> {
+        constructor(model?: T, element?: string, name?: string, names?: string[]);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The element, type or other object, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        element: string;
+        /**
+         * The name of the property set, such as `Pset_WallCommon`.
+         * @default Properties
+         */
+        name?: string | undefined;
+        /**
+         * The names of the properties to take out; the set goes when none are left.
+         * @default undefined
+         */
+        names: string[];
+    }
+    /**
+     * One property set of one object to take away, for `properties.removeSet`.
+     */
+    class RemovePropertySetDto<T> {
+        constructor(model?: T, element?: string, name?: string);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The element, type or other object, by GlobalId or by the id it was added with.
+         * @default undefined
+         */
+        element: string;
+        /**
+         * The name of the property set, such as `Pset_WallCommon`.
+         * @default Properties
+         */
+        name?: string | undefined;
+    }
+    /**
+     * A property set as `properties.getSets` reads it back.
+     */
+    class PropertySetInfoDto {
+        /**
+         * What the set is called, such as `Pset_WallCommon`.
+         * @default ""
+         */
+        name: string;
+        /**
+         * Its single values by property name, such as `{ IsExternal: true }`.
+         * @default {}
+         */
+        properties: Record<string, string | number | boolean>;
+    }
+    /**
+     * The model and the elements to measure for `quantities.compute`, every one it can when left out.
+     */
+    class ComputeQuantitiesDto<T> {
+        constructor(model?: T, elements?: string[]);
+        /**
+         * The model to change; it stays as it was, and the call returns the changed model.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The elements to measure, each by GlobalId or by the id it was added with. Left out, every element
+         * of a kind this library measures.
+         * @default undefined
+         * @optional true
+         */
+        elements?: string[] | undefined;
+    }
+    /**
+     * A quantity set as `quantities.get` reads it back: its name and each quantity's value by name.
+     * Areas and volumes are in the model's area and volume units, square and cubic metres in a model
+     * `model.create` made.
+     */
+    class QuantitySetInfoDto {
+        /**
+         * What the set is called, such as `Qto_WallBaseQuantities`.
+         * @default ""
+         */
+        name: string;
+        /**
+         * Each quantity's value by its name, such as `{ NetVolume: 5.2 }`: lengths in the model's length
+         * unit, areas and volumes in its area and volume units.
+         * @default {}
+         */
+        quantities: Record<string, number>;
+    }
+    /**
+     * A model, the elements to describe and how to group them for `geometry.recipe`.
+     */
+    class GeometryDto<T> {
+        constructor(model?: T, elements?: string[], groupByClass?: boolean);
+        /**
+         * The model whose elements are described.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The elements to describe, each by GlobalId or by the id it was added with. Leave it out for
+         * every element with a body.
+         * @default undefined
+         * @optional true
+         */
+        elements?: string[] | undefined;
+        /**
+         * When true, the elements of each storey, or other part of the structure, are grouped by IFC
+         * class, such as `Walls`; when false they lie in the structure's group.
+         * @default true
+         */
+        groupByClass?: boolean | undefined;
+    }
+    /**
+     * A model and the elements to check for `geometry.unsupported`.
+     */
+    class GeometryElementsDto<T> {
+        constructor(model?: T, elements?: string[]);
+        /**
+         * The model whose elements are checked.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The elements to check, each by GlobalId or by the id it was added with. Leave it out for
+         * every element with a body.
+         * @default undefined
+         * @optional true
+         */
+        elements?: string[] | undefined;
+    }
+    /**
+     * A model, the elements to build, and how to build them for `geometry.toShapes`, which builds the
+     * model's recipe as OpenCascade shapes.
+     */
+    class GeometryToShapesDto<T> {
+        constructor(model?: T, elements?: string[], adjustZtoY?: boolean, emptyWhenFailed?: boolean, facetedMeshes?: boolean, maxTriangles?: number);
+        /**
+         * The model whose elements are built.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The elements to build, each by GlobalId or by the id it was added with. Leave it out for
+         * every element with a body.
+         * @default undefined
+         * @optional true
+         */
+        elements?: string[] | undefined;
+        /**
+         * When true, the shapes turn a quarter turn about X so the model's Z points along Y, which is up
+         * when drawn: `(x, y, z)` becomes `(x, z, -y)`.
+         * @default true
+         */
+        adjustZtoY?: boolean | undefined;
+        /**
+         * When true, an element that cannot be built comes back as an empty compound and the others are
+         * built; when false, it stops the build.
+         * @default true
+         */
+        emptyWhenFailed?: boolean | undefined;
+        /**
+         * When true, elements stored as triangle meshes become faceted solids that cut and fillet like
+         * any shape; when false they keep their triangles, which draw and export faster.
+         * @default false
+         */
+        facetedMeshes?: boolean | undefined;
+        /**
+         * The most triangles a mesh built as a faceted solid may hold; a larger one is not built and
+         * counts as an element that failed.
+         * @default 100000
+         * @minimum 0
+         * @maximum Infinity
+         * @step 10000
+         */
+        maxTriangles?: number | undefined;
+    }
+    /**
+     * A model, the elements to build, and how to build them for `geometry.toDocument`, which builds the
+     * model's recipe into an OpenCascade assembly document.
+     */
+    class GeometryToDocumentDto<T> {
+        constructor(model?: T, elements?: string[], name?: string, emptyWhenFailed?: boolean, facetedMeshes?: boolean, maxTriangles?: number, groupByClass?: boolean);
+        /**
+         * The model whose elements are built.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The elements to build, each by GlobalId or by the id it was added with. Leave it out for
+         * every element with a body.
+         * @default undefined
+         * @optional true
+         */
+        elements?: string[] | undefined;
+        /**
+         * The name of the assembly at the top of the document, which holds every element.
+         * @default Model
+         */
+        name?: string | undefined;
+        /**
+         * When true, an element that cannot be built is left out of the document and the others are
+         * built; when false, it stops the build.
+         * @default true
+         */
+        emptyWhenFailed?: boolean | undefined;
+        /**
+         * When true, elements stored as triangle meshes become faceted solids that cut and fillet like
+         * any shape; when false STEP carries their triangles as tessellated geometry, smaller and faster.
+         * @default false
+         */
+        facetedMeshes?: boolean | undefined;
+        /**
+         * The most triangles a mesh built as a faceted solid may hold; a larger one is not built and
+         * counts as an element that failed.
+         * @default 100000
+         * @minimum 0
+         * @maximum Infinity
+         * @step 10000
+         */
+        maxTriangles?: number | undefined;
+        /**
+         * When true, each storey's elements are gathered in assemblies by IFC class, such as `Walls`
+         * and `Slabs`; when false they lie in the storey's assembly directly.
+         * @default true
+         */
+        groupByClass?: boolean | undefined;
+    }
+    /**
+     * A model, the elements to write, and the file options for `geometry.toStep`, which writes the
+     * model's elements as a STEP file of OpenCascade shapes.
+     */
+    class GeometryToStepDto<T> {
+        constructor(model?: T, elements?: string[], name?: string, fileName?: string, emptyWhenFailed?: boolean, facetedMeshes?: boolean, maxTriangles?: number, compress?: boolean, tryDownload?: boolean, groupByClass?: boolean);
+        /**
+         * The model whose elements are written.
+         * @default undefined
+         */
+        model: T;
+        /**
+         * The elements to write, each by GlobalId or by the id it was added with. Leave it out for
+         * every element with a body.
+         * @default undefined
+         * @optional true
+         */
+        elements?: string[] | undefined;
+        /**
+         * The name of the assembly at the top of the file, which holds every element.
+         * @default Model
+         */
+        name?: string | undefined;
+        /**
+         * The file name, used for the download and written into the file's header.
+         * @default model.step
+         */
+        fileName?: string | undefined;
+        /**
+         * When true, an element that cannot be built is left out of the file and the others are
+         * written; when false, it stops the export.
+         * @default true
+         */
+        emptyWhenFailed?: boolean | undefined;
+        /**
+         * When true, elements stored as triangle meshes are written as faceted solids; when false they
+         * are written as tessellated geometry, which is faster and smaller.
+         * @default false
+         */
+        facetedMeshes?: boolean | undefined;
+        /**
+         * The most triangles a mesh built as a faceted solid may hold; a larger one is not built and
+         * counts as an element that failed.
+         * @default 100000
+         * @minimum 0
+         * @maximum Infinity
+         * @step 10000
+         */
+        maxTriangles?: number | undefined;
+        /**
+         * When true, the file is written as gzip-compressed STEP-Z.
+         * @default false
+         */
+        compress?: boolean | undefined;
+        /**
+         * When true, a browser download of the file is started where that is possible; the bytes are
+         * returned either way.
+         * @default false
+         */
+        tryDownload?: boolean | undefined;
+        /**
+         * When true, each storey's elements are gathered in assemblies by IFC class, such as `Walls`
+         * and `Slabs`; when false they lie in the storey's assembly directly.
+         * @default true
+         */
+        groupByClass?: boolean | undefined;
+    }
+    /**
+     * An element `geometry.recipe` had to leave out, as `geometry.unsupported` lists it.
+     */
+    class GeometryProblemDto {
+        /**
+         * The GlobalId of the element left out.
+         * @default ""
+         */
+        globalId: string;
+        /**
+         * Its IFC type, such as `IfcWall`.
+         * @default ""
+         */
+        type: string;
+        /**
+         * What could not be described, in a sentence.
+         * @default ""
+         */
+        message: string;
+    }
+}