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

package/lib/api/inputs/ifc-inputs.js

@@ -0,0 +1,2498 @@
+// GENERATED by scripts/gen-inputs.mjs from the fragments in ./ifc/ - do not edit; edit a fragment and run `npm run gen:inputs`.
+/**
+ * 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 var IFC;
+(function (IFC) {
+    /**
+     * The length unit a new model is written in. Every length a method takes or returns is in this unit.
+     */
+    let lengthUnitEnum;
+    (function (lengthUnitEnum) {
+        /**
+         * Lengths in millimetres, as most building models are written.
+         */
+        lengthUnitEnum["millimetre"] = "millimetre";
+        /**
+         * Lengths in centimetres.
+         */
+        lengthUnitEnum["centimetre"] = "centimetre";
+        /**
+         * Lengths in metres.
+         */
+        lengthUnitEnum["metre"] = "metre";
+    })(lengthUnitEnum = IFC.lengthUnitEnum || (IFC.lengthUnitEnum = {}));
+    /**
+     * 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.
+     */
+    let wallAlignmentEnum;
+    (function (wallAlignmentEnum) {
+        /**
+         * The layers are centred on the axis.
+         */
+        wallAlignmentEnum["center"] = "center";
+        /**
+         * The layers lie to the left of the axis.
+         */
+        wallAlignmentEnum["left"] = "left";
+        /**
+         * The layers lie to the right of the axis.
+         */
+        wallAlignmentEnum["right"] = "right";
+    })(wallAlignmentEnum = IFC.wallAlignmentEnum || (IFC.wallAlignmentEnum = {}));
+    /**
+     * Where on a wall another wall meets it: at its start, at its end, or somewhere along its length.
+     */
+    let wallEndEnum;
+    (function (wallEndEnum) {
+        /**
+         * At the start of its axis.
+         */
+        wallEndEnum["start"] = "start";
+        /**
+         * At the end of its axis.
+         */
+        wallEndEnum["end"] = "end";
+        /**
+         * Somewhere along its length, as the stem of a T meets the wall it ends against.
+         */
+        wallEndEnum["along"] = "along";
+    })(wallEndEnum = IFC.wallEndEnum || (IFC.wallEndEnum = {}));
+    /**
+     * What kind of wall it is, as IFC classifies walls.
+     */
+    let wallPredefinedTypeEnum;
+    (function (wallPredefinedTypeEnum) {
+        /**
+         * A straight wall of constant thickness, the common case.
+         */
+        wallPredefinedTypeEnum["standard"] = "STANDARD";
+        /**
+         * A wall of solid construction, such as masonry.
+         */
+        wallPredefinedTypeEnum["solidWall"] = "SOLIDWALL";
+        /**
+         * A wall that divides a space without carrying load.
+         */
+        wallPredefinedTypeEnum["partitioning"] = "PARTITIONING";
+        /**
+         * A wall that resists lateral forces.
+         */
+        wallPredefinedTypeEnum["shear"] = "SHEAR";
+        /**
+         * A low wall along the edge of a roof or balcony.
+         */
+        wallPredefinedTypeEnum["parapet"] = "PARAPET";
+        /**
+         * A wall that can be moved, such as a folding partition.
+         */
+        wallPredefinedTypeEnum["movable"] = "MOVABLE";
+        /**
+         * A wall that carries pipes, such as a service wall.
+         */
+        wallPredefinedTypeEnum["plumbingWall"] = "PLUMBINGWALL";
+        /**
+         * No kind is given.
+         */
+        wallPredefinedTypeEnum["notDefined"] = "NOTDEFINED";
+    })(wallPredefinedTypeEnum = IFC.wallPredefinedTypeEnum || (IFC.wallPredefinedTypeEnum = {}));
+    /**
+     * 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.
+     */
+    let roofKindEnum;
+    (function (roofKindEnum) {
+        /**
+         * Flat, one level slab.
+         */
+        roofKindEnum["flat"] = "flat";
+        /**
+         * One slope, rising from the outline's first side to the opposite side.
+         */
+        roofKindEnum["monoPitch"] = "monoPitch";
+        /**
+         * Two slopes rising from the first side and the opposite side to a ridge between them.
+         */
+        roofKindEnum["gable"] = "gable";
+        /**
+         * Four slopes rising from every side, to a ridge along the longer sides or, over a square, to a
+         * point.
+         */
+        roofKindEnum["hip"] = "hip";
+    })(roofKindEnum = IFC.roofKindEnum || (IFC.roofKindEnum = {}));
+    /**
+     * What kind of member it is, as IFC classifies the linear parts of frames, roofs and facades.
+     */
+    let memberPredefinedTypeEnum;
+    (function (memberPredefinedTypeEnum) {
+        /**
+         * A diagonal that stiffens a frame.
+         */
+        memberPredefinedTypeEnum["brace"] = "BRACE";
+        /**
+         * The top or bottom edge of a truss.
+         */
+        memberPredefinedTypeEnum["chord"] = "CHORD";
+        /**
+         * A horizontal tie between two rafters.
+         */
+        memberPredefinedTypeEnum["collar"] = "COLLAR";
+        /**
+         * A member of no more particular kind.
+         */
+        memberPredefinedTypeEnum["member"] = "MEMBER";
+        /**
+         * A vertical between panes of a window or a curtain wall.
+         */
+        memberPredefinedTypeEnum["mullion"] = "MULLION";
+        /**
+         * A flat member, such as a gusset.
+         */
+        memberPredefinedTypeEnum["plate"] = "PLATE";
+        /**
+         * A vertical support, such as a fence post.
+         */
+        memberPredefinedTypeEnum["post"] = "POST";
+        /**
+         * A horizontal member that carries roof covering across rafters.
+         */
+        memberPredefinedTypeEnum["purlin"] = "PURLIN";
+        /**
+         * A sloping member that carries a roof.
+         */
+        memberPredefinedTypeEnum["rafter"] = "RAFTER";
+        /**
+         * A sloping member that carries the treads of a stair.
+         */
+        memberPredefinedTypeEnum["stringer"] = "STRINGER";
+        /**
+         * A member that takes compression along its length.
+         */
+        memberPredefinedTypeEnum["strut"] = "STRUT";
+        /**
+         * A vertical member of a framed wall.
+         */
+        memberPredefinedTypeEnum["stud"] = "STUD";
+        /**
+         * Not said.
+         */
+        memberPredefinedTypeEnum["notDefined"] = "NOTDEFINED";
+    })(memberPredefinedTypeEnum = IFC.memberPredefinedTypeEnum || (IFC.memberPredefinedTypeEnum = {}));
+    /**
+     * What kind of assembly it is, as IFC classifies elements made of other elements.
+     */
+    let elementAssemblyPredefinedTypeEnum;
+    (function (elementAssemblyPredefinedTypeEnum) {
+        /**
+         * Parts that support or connect others, such as a bracket with its fixings.
+         */
+        elementAssemblyPredefinedTypeEnum["accessoryAssembly"] = "ACCESSORY_ASSEMBLY";
+        /**
+         * An arch.
+         */
+        elementAssemblyPredefinedTypeEnum["arch"] = "ARCH";
+        /**
+         * Beams laid in a grid.
+         */
+        elementAssemblyPredefinedTypeEnum["beamGrid"] = "BEAM_GRID";
+        /**
+         * A frame stiffened by diagonal braces.
+         */
+        elementAssemblyPredefinedTypeEnum["bracedFrame"] = "BRACED_FRAME";
+        /**
+         * A girder built up of plates and members.
+         */
+        elementAssemblyPredefinedTypeEnum["girder"] = "GIRDER";
+        /**
+         * A cage of reinforcing bars placed as one.
+         */
+        elementAssemblyPredefinedTypeEnum["reinforcementUnit"] = "REINFORCEMENT_UNIT";
+        /**
+         * A frame whose joints hold it rigid without braces.
+         */
+        elementAssemblyPredefinedTypeEnum["rigidFrame"] = "RIGID_FRAME";
+        /**
+         * A field of slabs laid together.
+         */
+        elementAssemblyPredefinedTypeEnum["slabField"] = "SLAB_FIELD";
+        /**
+         * A truss.
+         */
+        elementAssemblyPredefinedTypeEnum["truss"] = "TRUSS";
+        /**
+         * A kind IFC does not name, such as a cladding of boards; `objectType` says what it is.
+         */
+        elementAssemblyPredefinedTypeEnum["userDefined"] = "USERDEFINED";
+        /**
+         * An assembly of no particular kind.
+         */
+        elementAssemblyPredefinedTypeEnum["notDefined"] = "NOTDEFINED";
+    })(elementAssemblyPredefinedTypeEnum = IFC.elementAssemblyPredefinedTypeEnum || (IFC.elementAssemblyPredefinedTypeEnum = {}));
+    /**
+     * What kind of space it is, as IFC classifies spaces.
+     */
+    let spacePredefinedTypeEnum;
+    (function (spacePredefinedTypeEnum) {
+        /**
+         * A room or an area of a storey.
+         */
+        spacePredefinedTypeEnum["space"] = "SPACE";
+        /**
+         * A parking bay.
+         */
+        spacePredefinedTypeEnum["parking"] = "PARKING";
+        /**
+         * The gross floor area of a storey, measured around its outside.
+         */
+        spacePredefinedTypeEnum["gfa"] = "GFA";
+        /**
+         * An enclosed space inside the building.
+         */
+        spacePredefinedTypeEnum["internal"] = "INTERNAL";
+        /**
+         * A space outside the building, such as a terrace.
+         */
+        spacePredefinedTypeEnum["external"] = "EXTERNAL";
+        /**
+         * Not said.
+         */
+        spacePredefinedTypeEnum["notDefined"] = "NOTDEFINED";
+    })(spacePredefinedTypeEnum = IFC.spacePredefinedTypeEnum || (IFC.spacePredefinedTypeEnum = {}));
+    /**
+     * What kind of slab it is, as IFC classifies slabs.
+     */
+    let slabPredefinedTypeEnum;
+    (function (slabPredefinedTypeEnum) {
+        /**
+         * A floor slab.
+         */
+        slabPredefinedTypeEnum["floor"] = "FLOOR";
+        /**
+         * A roof slab.
+         */
+        slabPredefinedTypeEnum["roof"] = "ROOF";
+        /**
+         * A landing of a stair.
+         */
+        slabPredefinedTypeEnum["landing"] = "LANDING";
+        /**
+         * A slab on the ground, at the base of the building.
+         */
+        slabPredefinedTypeEnum["baseSlab"] = "BASESLAB";
+        /**
+         * No kind is given.
+         */
+        slabPredefinedTypeEnum["notDefined"] = "NOTDEFINED";
+    })(slabPredefinedTypeEnum = IFC.slabPredefinedTypeEnum || (IFC.slabPredefinedTypeEnum = {}));
+    /**
+     * 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.
+     */
+    let doorOperationEnum;
+    (function (doorOperationEnum) {
+        /**
+         * One panel swinging, hinged on the left.
+         */
+        doorOperationEnum["singleSwingLeft"] = "SINGLE_SWING_LEFT";
+        /**
+         * One panel swinging, hinged on the right.
+         */
+        doorOperationEnum["singleSwingRight"] = "SINGLE_SWING_RIGHT";
+        /**
+         * One panel swinging both ways, hinged on the left.
+         */
+        doorOperationEnum["doubleSwingLeft"] = "DOUBLE_SWING_LEFT";
+        /**
+         * One panel swinging both ways, hinged on the right.
+         */
+        doorOperationEnum["doubleSwingRight"] = "DOUBLE_SWING_RIGHT";
+        /**
+         * One panel sliding to the left.
+         */
+        doorOperationEnum["slidingToLeft"] = "SLIDING_TO_LEFT";
+        /**
+         * One panel sliding to the right.
+         */
+        doorOperationEnum["slidingToRight"] = "SLIDING_TO_RIGHT";
+        /**
+         * One panel folding to the left.
+         */
+        doorOperationEnum["foldingToLeft"] = "FOLDING_TO_LEFT";
+        /**
+         * One panel folding to the right.
+         */
+        doorOperationEnum["foldingToRight"] = "FOLDING_TO_RIGHT";
+        /**
+         * A revolving door.
+         */
+        doorOperationEnum["revolving"] = "REVOLVING";
+        /**
+         * A door that rolls up.
+         */
+        doorOperationEnum["rollingUp"] = "ROLLINGUP";
+        /**
+         * No kind is given.
+         */
+        doorOperationEnum["notDefined"] = "NOTDEFINED";
+    })(doorOperationEnum = IFC.doorOperationEnum || (IFC.doorOperationEnum = {}));
+    /**
+     * The handle a door type carries on both faces of its panel, on the side away from its hinges.
+     */
+    let doorHandleEnum;
+    (function (doorHandleEnum) {
+        /**
+         * No handle.
+         */
+        doorHandleEnum["none"] = "none";
+        /**
+         * A lever handle at hand height.
+         */
+        doorHandleEnum["lever"] = "lever";
+        /**
+         * A long upright pull bar, as on an entrance door.
+         */
+        doorHandleEnum["pullBar"] = "pullBar";
+    })(doorHandleEnum = IFC.doorHandleEnum || (IFC.doorHandleEnum = {}));
+    /**
+     * The shape of the section a column or beam is extruded from: a rectangle, a circle or an I section.
+     */
+    let profileKindEnum;
+    (function (profileKindEnum) {
+        /**
+         * A rectangle of `width` by `depth`.
+         */
+        profileKindEnum["rectangle"] = "rectangle";
+        /**
+         * A circle of `radius`.
+         */
+        profileKindEnum["circle"] = "circle";
+        /**
+         * An I section of `width` and `depth`, with `webThickness` and `flangeThickness`.
+         */
+        profileKindEnum["iShape"] = "iShape";
+    })(profileKindEnum = IFC.profileKindEnum || (IFC.profileKindEnum = {}));
+    /**
+     * A model to read, for the methods that only look at it, such as `model.summary` and
+     * `spatial.storeys`.
+     */
+    class ModelDto {
+        constructor(model) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+        }
+    }
+    IFC.ModelDto = ModelDto;
+    /**
+     * 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, siteName, buildingName, lengthUnit, seed, author, organization) {
+            /**
+             * The project's name.
+             * @default Project
+             */
+            this.name = "Project";
+            /**
+             * The site's name.
+             * @default Site
+             */
+            this.siteName = "Site";
+            /**
+             * What the one building the model starts with is called.
+             * @default Building
+             */
+            this.buildingName = "Building";
+            /**
+             * The unit every length of the model is given and written in.
+             * @default millimetre
+             */
+            this.lengthUnit = lengthUnitEnum.millimetre;
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (siteName !== undefined) {
+                this.siteName = siteName;
+            }
+            if (buildingName !== undefined) {
+                this.buildingName = buildingName;
+            }
+            if (lengthUnit !== undefined) {
+                this.lengthUnit = lengthUnit;
+            }
+            if (seed !== undefined) {
+                this.seed = seed;
+            }
+            if (author !== undefined) {
+                this.author = author;
+            }
+            if (organization !== undefined) {
+                this.organization = organization;
+            }
+        }
+    }
+    IFC.CreateModelDto = CreateModelDto;
+    /**
+     * The contents of an IFC file for `model.read`, as text or bytes.
+     */
+    class ReadModelDto {
+        constructor(data) {
+            if (data !== undefined) {
+                this.data = data;
+            }
+        }
+    }
+    IFC.ReadModelDto = ReadModelDto;
+    /**
+     * A model to write for `model.write`, with the file name and time its header records.
+     */
+    class WriteModelDto {
+        constructor(model, fileName, timeStamp) {
+            /**
+             * The file name the header records.
+             * @default model.ifc
+             */
+            this.fileName = "model.ifc";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (fileName !== undefined) {
+                this.fileName = fileName;
+            }
+            if (timeStamp !== undefined) {
+                this.timeStamp = timeStamp;
+            }
+        }
+    }
+    IFC.WriteModelDto = WriteModelDto;
+    /**
+     * A model and a filter for `model.elements`, which lists the elements of one type, optionally on one
+     * storey.
+     */
+    class ElementsDto {
+        constructor(model, type, storey) {
+            /**
+             * 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
+             */
+            this.type = "IfcElement";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (type !== undefined) {
+                this.type = type;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+        }
+    }
+    IFC.ElementsDto = ElementsDto;
+    /**
+     * 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 {
+        constructor(model, element) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (element !== undefined) {
+                this.element = element;
+            }
+        }
+    }
+    IFC.ElementDto = ElementDto;
+    /**
+     * One attribute of an object to set for `model.setAttribute`, such as a wall's `Name` or `Tag`.
+     */
+    class SetAttributeDto {
+        constructor(model, element, attribute, value) {
+            /**
+             * The attribute's name, as the IFC schema spells it, such as `Name`, `Description` or `Tag`.
+             * @default Name
+             */
+            this.attribute = "Name";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (element !== undefined) {
+                this.element = element;
+            }
+            if (attribute !== undefined) {
+                this.attribute = attribute;
+            }
+            if (value !== undefined) {
+                this.value = value;
+            }
+        }
+    }
+    IFC.SetAttributeDto = SetAttributeDto;
+    /**
+     * An object's attribute to read for `model.getAttribute`.
+     */
+    class GetAttributeDto {
+        constructor(model, element, attribute) {
+            /**
+             * The attribute's name, as the IFC schema spells it, such as `Name`, `Description` or `Tag`.
+             * @default Name
+             */
+            this.attribute = "Name";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (element !== undefined) {
+                this.element = element;
+            }
+            if (attribute !== undefined) {
+                this.attribute = attribute;
+            }
+        }
+    }
+    IFC.GetAttributeDto = GetAttributeDto;
+    /**
+     * A model and an id for `model.globalIdOf`, which says which GlobalId the id stands for.
+     */
+    class GlobalIdOfDto {
+        constructor(model, id) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+        }
+    }
+    IFC.GlobalIdOfDto = GlobalIdOfDto;
+    /**
+     * How far to move an element and how far to turn it, for `model.move`.
+     */
+    class MoveElementDto {
+        constructor(model, element, translation, rotation) {
+            /**
+             * 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]
+             */
+            this.translation = [0, 0, 0];
+            /**
+             * 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
+             */
+            this.rotation = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (element !== undefined) {
+                this.element = element;
+            }
+            if (translation !== undefined) {
+                this.translation = translation;
+            }
+            if (rotation !== undefined) {
+                this.rotation = rotation;
+            }
+        }
+    }
+    IFC.MoveElementDto = MoveElementDto;
+    /**
+     * A storey to add to the model's building for `spatial.addStorey`, at its elevation above the
+     * building's origin.
+     */
+    class AddStoreyDto {
+        constructor(model, id, name, elevation) {
+            /**
+             * What the storey is called, such as `Ground floor`.
+             * @default Storey
+             */
+            this.name = "Storey";
+            /**
+             * How high the storey's floor is above the building's origin.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.elevation = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (elevation !== undefined) {
+                this.elevation = elevation;
+            }
+        }
+    }
+    IFC.AddStoreyDto = AddStoreyDto;
+    /**
+     * A material to add for `materials.add`, which layer sets, columns and beams then name.
+     */
+    class AddMaterialDto {
+        constructor(model, name, category, color, transparency) {
+            /**
+             * The material's name, unique in the model, by which layer sets and members refer to it.
+             * @default Material
+             */
+            this.name = "Material";
+            /**
+             * How see-through the material is shown, from 0 for opaque to 1 for invisible; used with
+             * `color`.
+             * @default 0
+             * @minimum 0
+             * @maximum 1
+             */
+            this.transparency = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (category !== undefined) {
+                this.category = category;
+            }
+            if (color !== undefined) {
+                this.color = color;
+            }
+            if (transparency !== undefined) {
+                this.transparency = transparency;
+            }
+        }
+    }
+    IFC.AddMaterialDto = AddMaterialDto;
+    /**
+     * One layer of a layer set: its material, by name, and its thickness. Used by `materials.addLayerSet`.
+     */
+    class MaterialLayerDto {
+        constructor(material, thickness, name) {
+            if (material !== undefined) {
+                this.material = material;
+            }
+            if (thickness !== undefined) {
+                this.thickness = thickness;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+        }
+    }
+    IFC.MaterialLayerDto = MaterialLayerDto;
+    /**
+     * 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 {
+        constructor(model, name, layers) {
+            /**
+             * The layer set's name, unique in the model, by which walls, wall types and slabs refer to it.
+             * @default Layers
+             */
+            this.name = "Layers";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (layers !== undefined) {
+                this.layers = layers;
+            }
+        }
+    }
+    IFC.AddLayerSetDto = AddLayerSetDto;
+    /**
+     * A storey as `spatial.storeys` and `model.summary` list it: its GlobalId, name and elevation.
+     */
+    class StoreyInfoDto {
+        constructor() {
+            /**
+             * The GlobalId that identifies the storey.
+             * @default ""
+             */
+            this.globalId = "";
+            /**
+             * What the storey is called.
+             * @default ""
+             */
+            this.name = "";
+            /**
+             * How high its floor is above the building's origin, in the model's length unit.
+             * @default 0
+             */
+            this.elevation = 0;
+        }
+    }
+    IFC.StoreyInfoDto = StoreyInfoDto;
+    /**
+     * A storey and its new elevation for `spatial.setElevation`.
+     */
+    class SetStoreyElevationDto {
+        constructor(model, storey, elevation) {
+            /**
+             * How high its floor is now above the building's origin; everything on the storey moves with it.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.elevation = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+            if (elevation !== undefined) {
+                this.elevation = elevation;
+            }
+        }
+    }
+    IFC.SetStoreyElevationDto = SetStoreyElevationDto;
+    /**
+     * 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 {
+        constructor(model, storey, id, name, longName, outline, height, baseOffset, predefinedType) {
+            /**
+             * How far above the storey's floor the space starts.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.baseOffset = 0;
+            /**
+             * What kind of space it is.
+             * @default space
+             */
+            this.predefinedType = spacePredefinedTypeEnum.space;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (longName !== undefined) {
+                this.longName = longName;
+            }
+            if (outline !== undefined) {
+                this.outline = outline;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+            if (baseOffset !== undefined) {
+                this.baseOffset = baseOffset;
+            }
+            if (predefinedType !== undefined) {
+                this.predefinedType = predefinedType;
+            }
+        }
+    }
+    IFC.AddSpaceDto = AddSpaceDto;
+    /**
+     * A model and, optionally, a storey, for `spaces.list`.
+     */
+    class SpacesDto {
+        constructor(model, storey) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+        }
+    }
+    IFC.SpacesDto = SpacesDto;
+    /**
+     * A space as `spaces.list` describes it: its number and name, its storey, and its area and height.
+     */
+    class SpaceInfoDto {
+        constructor() {
+            /**
+             * The GlobalId that identifies the space.
+             * @default ""
+             */
+            this.globalId = "";
+            /**
+             * Its short name or number, or an empty text when it has none.
+             * @default ""
+             */
+            this.name = "";
+            /**
+             * Its full name, or an empty text when it has none.
+             * @default ""
+             */
+            this.longName = "";
+            /**
+             * The GlobalId of the storey it belongs to, or an empty text when it belongs to none.
+             * @default ""
+             */
+            this.storey = "";
+            /**
+             * 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
+             */
+            this.area = 0;
+            /**
+             * How high it reaches; 0 when its body is not an outline extruded up.
+             * @default 0
+             */
+            this.height = 0;
+        }
+    }
+    IFC.SpaceInfoDto = SpaceInfoDto;
+    /**
+     * An element as `model.elements` and `model.element` describe it.
+     */
+    class ElementInfoDto {
+        constructor() {
+            /**
+             * The GlobalId that identifies the element.
+             * @default ""
+             */
+            this.globalId = "";
+            /**
+             * Its IFC type, such as `IfcWall`.
+             * @default ""
+             */
+            this.type = "";
+            /**
+             * Its name, or an empty text when it has none.
+             * @default ""
+             */
+            this.name = "";
+            /**
+             * 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 ""
+             */
+            this.storey = "";
+        }
+    }
+    IFC.ElementInfoDto = ElementInfoDto;
+    /**
+     * 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 {
+        constructor() {
+            /**
+             * Whether the model holds a map conversion; when it does not, the map fields keep their defaults.
+             * @default false
+             */
+            this.mapped = false;
+            /**
+             * The name of the projected coordinate reference system the map conversion targets, such as
+             * `EPSG:3301`.
+             * @default ""
+             */
+            this.crs = "";
+            /**
+             * How far east of the map's origin the model's origin lies, in the map's unit.
+             * @default 0
+             */
+            this.eastings = 0;
+            /**
+             * How far north of the map's origin the model's origin lies, in the map's unit.
+             * @default 0
+             */
+            this.northings = 0;
+            /**
+             * The height of the model's origin above the vertical datum, in the map's unit.
+             * @default 0
+             */
+            this.orthogonalHeight = 0;
+            /**
+             * The first map coordinate of the direction the model's X axis points in.
+             * @default 1
+             */
+            this.xAxisAbscissa = 1;
+            /**
+             * The second map coordinate of the direction the model's X axis points in.
+             * @default 0
+             */
+            this.xAxisOrdinate = 0;
+            /**
+             * The scale from the model's lengths to the map's.
+             * @default 1
+             */
+            this.scale = 1;
+            /**
+             * Whether the site records a latitude and a longitude.
+             * @default false
+             */
+            this.located = false;
+            /**
+             * The site's reference latitude in decimal degrees, negative to the south.
+             * @default 0
+             */
+            this.latitude = 0;
+            /**
+             * The site's reference longitude in decimal degrees, negative to the west.
+             * @default 0
+             */
+            this.longitude = 0;
+            /**
+             * The site's reference elevation above sea level, in the model's length unit.
+             * @default 0
+             */
+            this.elevation = 0;
+        }
+    }
+    IFC.GeoreferenceDto = GeoreferenceDto;
+    /**
+     * What a model holds, as `model.summary` describes it.
+     */
+    class ModelSummaryDto {
+        constructor() {
+            /**
+             * The schema the model's file names, such as `IFC4`.
+             * @default ""
+             */
+            this.schema = "";
+            /**
+             * Whether the model can be changed: false for an `IFC2X3` file, which is read through `IFC4`
+             * to be shown and queried.
+             * @default true
+             */
+            this.editable = true;
+            /**
+             * What the project is called.
+             * @default ""
+             */
+            this.project = "";
+            /**
+             * How many millimetres one length unit of the model is.
+             * @default 1
+             */
+            this.millimetresPerUnit = 1;
+            /**
+             * How many entities the model holds, geometry and relationships included.
+             * @default 0
+             */
+            this.entities = 0;
+            /**
+             * The storeys, lowest first.
+             * @default []
+             */
+            this.storeys = [];
+            /**
+             * How many elements of each IFC type the model holds, such as `{ IfcWall: 8 }`.
+             * @default {}
+             */
+            this.elementCounts = {};
+        }
+    }
+    IFC.ModelSummaryDto = ModelSummaryDto;
+    /**
+     * 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 {
+        constructor(model, storey, id, name, start, end, height, thickness, layerSet, alignment, baseOffset, wallType, predefinedType) {
+            /**
+             * 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
+             */
+            this.alignment = wallAlignmentEnum.center;
+            /**
+             * How far above the storey's floor the wall starts.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.baseOffset = 0;
+            /**
+             * 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
+             */
+            this.predefinedType = wallPredefinedTypeEnum.standard;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+            if (thickness !== undefined) {
+                this.thickness = thickness;
+            }
+            if (layerSet !== undefined) {
+                this.layerSet = layerSet;
+            }
+            if (alignment !== undefined) {
+                this.alignment = alignment;
+            }
+            if (baseOffset !== undefined) {
+                this.baseOffset = baseOffset;
+            }
+            if (wallType !== undefined) {
+                this.wallType = wallType;
+            }
+            if (predefinedType !== undefined) {
+                this.predefinedType = predefinedType;
+            }
+        }
+    }
+    IFC.AddWallDto = AddWallDto;
+    /**
+     * 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 {
+        constructor(model, wall, other) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (wall !== undefined) {
+                this.wall = wall;
+            }
+            if (other !== undefined) {
+                this.other = other;
+            }
+        }
+    }
+    IFC.ConnectWallsDto = ConnectWallsDto;
+    /**
+     * 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 {
+        constructor(model, wall, origin, normal) {
+            /**
+             * The plane's normal, pointing to the side that is removed; `[0, 0, 1]` cuts the top off level.
+             * @default [0, 0, 1]
+             */
+            this.normal = [0, 0, 1];
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (wall !== undefined) {
+                this.wall = wall;
+            }
+            if (origin !== undefined) {
+                this.origin = origin;
+            }
+            if (normal !== undefined) {
+                this.normal = normal;
+            }
+        }
+    }
+    IFC.ClipWallDto = ClipWallDto;
+    /**
+     * A wall and a roof to clip it under, for `walls.clipByRoof`.
+     */
+    class ClipWallByRoofDto {
+        constructor(model, wall, roof) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (wall !== undefined) {
+                this.wall = wall;
+            }
+            if (roof !== undefined) {
+                this.roof = roof;
+            }
+        }
+    }
+    IFC.ClipWallByRoofDto = ClipWallByRoofDto;
+    /**
+     * 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 {
+        constructor(model, id, name, layerSet, predefinedType) {
+            /**
+             * The type's name.
+             * @default Wall type
+             */
+            this.name = "Wall type";
+            /**
+             * What kind of wall the type is.
+             * @default standard
+             */
+            this.predefinedType = wallPredefinedTypeEnum.standard;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (layerSet !== undefined) {
+                this.layerSet = layerSet;
+            }
+            if (predefinedType !== undefined) {
+                this.predefinedType = predefinedType;
+            }
+        }
+    }
+    IFC.AddWallTypeDto = AddWallTypeDto;
+    /**
+     * A wall of a model, for `walls.parameters`.
+     */
+    class WallDto {
+        constructor(model, wall) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (wall !== undefined) {
+                this.wall = wall;
+            }
+        }
+    }
+    IFC.WallDto = WallDto;
+    /**
+     * What to change about a wall for `walls.edit`. Everything left out stays as it is.
+     */
+    class EditWallDto {
+        constructor(model, wall, start, end, height, baseOffset, thickness, layerSet, alignment) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (wall !== undefined) {
+                this.wall = wall;
+            }
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+            if (baseOffset !== undefined) {
+                this.baseOffset = baseOffset;
+            }
+            if (thickness !== undefined) {
+                this.thickness = thickness;
+            }
+            if (layerSet !== undefined) {
+                this.layerSet = layerSet;
+            }
+            if (alignment !== undefined) {
+                this.alignment = alignment;
+            }
+        }
+    }
+    IFC.EditWallDto = EditWallDto;
+    /**
+     * One join of a wall, as `walls.parameters` lists it.
+     */
+    class WallJoinInfoDto {
+        constructor() {
+            /**
+             * The GlobalId of the wall it is joined to.
+             * @default ""
+             */
+            this.other = "";
+            /**
+             * Where on this wall the join is.
+             * @default start
+             */
+            this.at = wallEndEnum.start;
+            /**
+             * Where on the other wall the join is.
+             * @default start
+             */
+            this.otherAt = wallEndEnum.start;
+        }
+    }
+    IFC.WallJoinInfoDto = WallJoinInfoDto;
+    /**
+     * 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 {
+        constructor() {
+            /**
+             * The GlobalId that identifies the wall.
+             * @default ""
+             */
+            this.globalId = "";
+            /**
+             * The wall's name, or an empty text when it has none.
+             * @default ""
+             */
+            this.name = "";
+            /**
+             * The GlobalId of the storey that contains the wall, or an empty text when none does.
+             * @default ""
+             */
+            this.storey = "";
+            /**
+             * The start of the wall's axis, as `[x, y]`.
+             * @default [0, 0]
+             */
+            this.start = [0, 0];
+            /**
+             * The end of the wall's axis, as `[x, y]`.
+             * @default [0, 0]
+             */
+            this.end = [0, 0];
+            /**
+             * The wall's height, up from its base.
+             * @default 0
+             */
+            this.height = 0;
+            /**
+             * How far above its storey's floor the wall starts.
+             * @default 0
+             */
+            this.baseOffset = 0;
+            /**
+             * The wall's thickness, all its layers together.
+             * @default 0
+             */
+            this.thickness = 0;
+            /**
+             * 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
+             */
+            this.offset = 0;
+            /**
+             * 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 ""
+             */
+            this.alignment = "";
+            /**
+             * The name of the layer set the wall is made of.
+             * @default ""
+             */
+            this.layerSet = "";
+            /**
+             * The GlobalId of the wall's type, or an empty text when it has none.
+             * @default ""
+             */
+            this.wallType = "";
+            /**
+             * Each join of the wall: the other wall, and where on each wall the join is.
+             * @default []
+             */
+            this.joins = [];
+            /**
+             * The GlobalIds of the openings cut through it, filled or not.
+             * @default []
+             */
+            this.openings = [];
+            /**
+             * How many planes clip the wall.
+             * @default 0
+             */
+            this.clippings = 0;
+        }
+    }
+    IFC.WallParametersDto = WallParametersDto;
+    /**
+     * A rectangular opening to cut through a wall for `openings.add`, measured along the wall from
+     * its start.
+     */
+    class AddOpeningDto {
+        constructor(model, wall, id, name, offset, sill, width, height) {
+            /**
+             * How high above the wall's base the opening's bottom is.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.sill = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (wall !== undefined) {
+                this.wall = wall;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (offset !== undefined) {
+                this.offset = offset;
+            }
+            if (sill !== undefined) {
+                this.sill = sill;
+            }
+            if (width !== undefined) {
+                this.width = width;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+        }
+    }
+    IFC.AddOpeningDto = AddOpeningDto;
+    /**
+     * Where to move an opening to, or what size to make it, for `openings.edit`. Everything left out stays
+     * as it is.
+     */
+    class EditOpeningDto {
+        constructor(model, opening, offset, sill, width, height) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (opening !== undefined) {
+                this.opening = opening;
+            }
+            if (offset !== undefined) {
+                this.offset = offset;
+            }
+            if (sill !== undefined) {
+                this.sill = sill;
+            }
+            if (width !== undefined) {
+                this.width = width;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+        }
+    }
+    IFC.EditOpeningDto = EditOpeningDto;
+    /**
+     * 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 {
+        constructor(model, slab, id, name, outline) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (slab !== undefined) {
+                this.slab = slab;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (outline !== undefined) {
+                this.outline = outline;
+            }
+        }
+    }
+    IFC.AddSlabOpeningDto = AddSlabOpeningDto;
+    /**
+     * 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 {
+        constructor(model, id, name, width, height, liningThickness, liningDepth, panelThickness, operation, liningMaterial, panelMaterial, handle, handleMaterial) {
+            /**
+             * The type's name.
+             * @default Door
+             */
+            this.name = "Door";
+            /**
+             * How the door opens, recorded for other tools to draw its swing.
+             * @default singleSwingLeft
+             */
+            this.operation = doorOperationEnum.singleSwingLeft;
+            /**
+             * The handle on both faces of the panel, near the edge away from the hinges that `operation`
+             * names.
+             * @default none
+             */
+            this.handle = doorHandleEnum.none;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (width !== undefined) {
+                this.width = width;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+            if (liningThickness !== undefined) {
+                this.liningThickness = liningThickness;
+            }
+            if (liningDepth !== undefined) {
+                this.liningDepth = liningDepth;
+            }
+            if (panelThickness !== undefined) {
+                this.panelThickness = panelThickness;
+            }
+            if (operation !== undefined) {
+                this.operation = operation;
+            }
+            if (liningMaterial !== undefined) {
+                this.liningMaterial = liningMaterial;
+            }
+            if (panelMaterial !== undefined) {
+                this.panelMaterial = panelMaterial;
+            }
+            if (handle !== undefined) {
+                this.handle = handle;
+            }
+            if (handleMaterial !== undefined) {
+                this.handleMaterial = handleMaterial;
+            }
+        }
+    }
+    IFC.AddDoorTypeDto = AddDoorTypeDto;
+    /**
+     * A window type to add for `windows.addType`: a frame around one pane of glass, which every window
+     * of the type shares.
+     */
+    class AddWindowTypeDto {
+        constructor(model, id, name, width, height, frameThickness, frameDepth, glassThickness, frameMaterial, glassMaterial) {
+            /**
+             * The type's name.
+             * @default Window
+             */
+            this.name = "Window";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (width !== undefined) {
+                this.width = width;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+            if (frameThickness !== undefined) {
+                this.frameThickness = frameThickness;
+            }
+            if (frameDepth !== undefined) {
+                this.frameDepth = frameDepth;
+            }
+            if (glassThickness !== undefined) {
+                this.glassThickness = glassThickness;
+            }
+            if (frameMaterial !== undefined) {
+                this.frameMaterial = frameMaterial;
+            }
+            if (glassMaterial !== undefined) {
+                this.glassMaterial = glassMaterial;
+            }
+        }
+    }
+    IFC.AddWindowTypeDto = AddWindowTypeDto;
+    /**
+     * 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 {
+        constructor(model, wall, doorType, id, name, offset, sill) {
+            /**
+             * How high above the wall's base the door's bottom is.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.sill = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (wall !== undefined) {
+                this.wall = wall;
+            }
+            if (doorType !== undefined) {
+                this.doorType = doorType;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (offset !== undefined) {
+                this.offset = offset;
+            }
+            if (sill !== undefined) {
+                this.sill = sill;
+            }
+        }
+    }
+    IFC.AddDoorDto = AddDoorDto;
+    /**
+     * 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 {
+        constructor(model, wall, windowType, id, name, offset, sill) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (wall !== undefined) {
+                this.wall = wall;
+            }
+            if (windowType !== undefined) {
+                this.windowType = windowType;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (offset !== undefined) {
+                this.offset = offset;
+            }
+            if (sill !== undefined) {
+                this.sill = sill;
+            }
+        }
+    }
+    IFC.AddWindowDto = AddWindowDto;
+    /**
+     * 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 {
+        constructor(model, storey, id, name, outline, holes, thickness, layerSet, topOffset, predefinedType) {
+            /**
+             * How high the slab's top is above the storey's floor.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.topOffset = 0;
+            /**
+             * What kind of slab it is.
+             * @default floor
+             */
+            this.predefinedType = slabPredefinedTypeEnum.floor;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (outline !== undefined) {
+                this.outline = outline;
+            }
+            if (holes !== undefined) {
+                this.holes = holes;
+            }
+            if (thickness !== undefined) {
+                this.thickness = thickness;
+            }
+            if (layerSet !== undefined) {
+                this.layerSet = layerSet;
+            }
+            if (topOffset !== undefined) {
+                this.topOffset = topOffset;
+            }
+            if (predefinedType !== undefined) {
+                this.predefinedType = predefinedType;
+            }
+        }
+    }
+    IFC.AddSlabDto = AddSlabDto;
+    /**
+     * 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`.
+     */
+    class MemberSharedDto {
+        constructor() {
+            /**
+             * The section's shape.
+             * @default rectangle
+             */
+            this.profile = profileKindEnum.rectangle;
+            /**
+             * How far the section turns about the member's own axis, in degrees.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.rotation = 0;
+        }
+    }
+    IFC.MemberSharedDto = MemberSharedDto;
+    /**
+     * A column to add for `columns.add`: a section standing upright on a point of a storey's plan.
+     */
+    class AddColumnDto extends MemberSharedDto {
+        constructor(model, storey, position, height, baseOffset, id, name, profile, width, depth, radius, webThickness, flangeThickness, rotation, material) {
+            super();
+            /**
+             * Where the column stands, as `[x, y]` in the storey's plan; the section is centred on it.
+             * @default [0, 0]
+             */
+            this.position = [0, 0];
+            /**
+             * How far above the storey's floor the column starts.
+             * @default 0
+             * @minimum -Infinity
+             * @maximum Infinity
+             */
+            this.baseOffset = 0;
+            if (position !== undefined) {
+                this.position = position;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+            if (baseOffset !== undefined) {
+                this.baseOffset = baseOffset;
+            }
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (profile !== undefined) {
+                this.profile = profile;
+            }
+            if (width !== undefined) {
+                this.width = width;
+            }
+            if (depth !== undefined) {
+                this.depth = depth;
+            }
+            if (radius !== undefined) {
+                this.radius = radius;
+            }
+            if (webThickness !== undefined) {
+                this.webThickness = webThickness;
+            }
+            if (flangeThickness !== undefined) {
+                this.flangeThickness = flangeThickness;
+            }
+            if (rotation !== undefined) {
+                this.rotation = rotation;
+            }
+            if (material !== undefined) {
+                this.material = material;
+            }
+        }
+    }
+    IFC.AddColumnDto = AddColumnDto;
+    /**
+     * 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 extends MemberSharedDto {
+        constructor(model, storey, start, end, id, name, profile, width, depth, radius, webThickness, flangeThickness, rotation, material) {
+            super();
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (profile !== undefined) {
+                this.profile = profile;
+            }
+            if (width !== undefined) {
+                this.width = width;
+            }
+            if (depth !== undefined) {
+                this.depth = depth;
+            }
+            if (radius !== undefined) {
+                this.radius = radius;
+            }
+            if (webThickness !== undefined) {
+                this.webThickness = webThickness;
+            }
+            if (flangeThickness !== undefined) {
+                this.flangeThickness = flangeThickness;
+            }
+            if (rotation !== undefined) {
+                this.rotation = rotation;
+            }
+            if (material !== undefined) {
+                this.material = material;
+            }
+        }
+    }
+    IFC.AddBeamDto = AddBeamDto;
+    /**
+     * 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 extends MemberSharedDto {
+        constructor(model, storey, start, end, id, name, profile, width, depth, radius, webThickness, flangeThickness, rotation, material, predefinedType) {
+            super();
+            /**
+             * What kind of member it is.
+             * @default member
+             */
+            this.predefinedType = memberPredefinedTypeEnum.member;
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (profile !== undefined) {
+                this.profile = profile;
+            }
+            if (width !== undefined) {
+                this.width = width;
+            }
+            if (depth !== undefined) {
+                this.depth = depth;
+            }
+            if (radius !== undefined) {
+                this.radius = radius;
+            }
+            if (webThickness !== undefined) {
+                this.webThickness = webThickness;
+            }
+            if (flangeThickness !== undefined) {
+                this.flangeThickness = flangeThickness;
+            }
+            if (rotation !== undefined) {
+                this.rotation = rotation;
+            }
+            if (material !== undefined) {
+                this.material = material;
+            }
+            if (predefinedType !== undefined) {
+                this.predefinedType = predefinedType;
+            }
+        }
+    }
+    IFC.AddMemberDto = AddMemberDto;
+    /**
+     * 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 {
+        constructor(model, storey, id, name, outline, kind, pitch, thickness, layerSet, overhang, baseOffset) {
+            /**
+             * The roof's shape.
+             * @default gable
+             */
+            this.kind = roofKindEnum.gable;
+            /**
+             * The slope of a sloping roof, in degrees from level, more than 0 and at most 89.
+             * @default 30
+             * @minimum 0
+             * @maximum 89
+             */
+            this.pitch = 30;
+            /**
+             * How far the roof reaches past the outline on every side, measured level.
+             * @default 0
+             * @minimum 0
+             * @maximum Infinity
+             */
+            this.overhang = 0;
+            /**
+             * 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
+             */
+            this.baseOffset = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (storey !== undefined) {
+                this.storey = storey;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (outline !== undefined) {
+                this.outline = outline;
+            }
+            if (kind !== undefined) {
+                this.kind = kind;
+            }
+            if (pitch !== undefined) {
+                this.pitch = pitch;
+            }
+            if (thickness !== undefined) {
+                this.thickness = thickness;
+            }
+            if (layerSet !== undefined) {
+                this.layerSet = layerSet;
+            }
+            if (overhang !== undefined) {
+                this.overhang = overhang;
+            }
+            if (baseOffset !== undefined) {
+                this.baseOffset = baseOffset;
+            }
+        }
+    }
+    IFC.AddRoofDto = AddRoofDto;
+    /**
+     * 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 {
+        constructor(model, parts, id, name, predefinedType, objectType) {
+            /**
+             * The kind of assembly, as IFC classifies them; `userDefined` for a kind it does not name, which
+             * `objectType` then says.
+             * @default notDefined
+             */
+            this.predefinedType = elementAssemblyPredefinedTypeEnum.notDefined;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (parts !== undefined) {
+                this.parts = parts;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (predefinedType !== undefined) {
+                this.predefinedType = predefinedType;
+            }
+            if (objectType !== undefined) {
+                this.objectType = objectType;
+            }
+        }
+    }
+    IFC.AddAssemblyDto = AddAssemblyDto;
+    /**
+     * 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 {
+        constructor(model, id, name, outline, holes, depth, elevation, material) {
+            /**
+             * A name for the terrain, which other tools show.
+             * @default Terrain
+             */
+            this.name = "Terrain";
+            /**
+             * How high the ground's top is above the site's origin.
+             * @default 0
+             */
+            this.elevation = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (outline !== undefined) {
+                this.outline = outline;
+            }
+            if (holes !== undefined) {
+                this.holes = holes;
+            }
+            if (depth !== undefined) {
+                this.depth = depth;
+            }
+            if (elevation !== undefined) {
+                this.elevation = elevation;
+            }
+            if (material !== undefined) {
+                this.material = material;
+            }
+        }
+    }
+    IFC.AddTerrainDto = AddTerrainDto;
+    /**
+     * 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 {
+        constructor(model, id, name, species, position, elevation, height, crownRadius, trunkRadius, crownMaterial, trunkMaterial) {
+            /**
+             * A name for the tree, which other tools show.
+             * @default Tree
+             */
+            this.name = "Tree";
+            /**
+             * What kind of tree it is, such as `Silver birch`, written as the element's object type.
+             * @default Tree
+             */
+            this.species = "Tree";
+            /**
+             * Where the trunk stands, as `[x, y]` in the site's plan.
+             * @default [0, 0]
+             */
+            this.position = [0, 0];
+            /**
+             * How high above the site's origin the trunk stands.
+             * @default 0
+             */
+            this.elevation = 0;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (id !== undefined) {
+                this.id = id;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (species !== undefined) {
+                this.species = species;
+            }
+            if (position !== undefined) {
+                this.position = position;
+            }
+            if (elevation !== undefined) {
+                this.elevation = elevation;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+            if (crownRadius !== undefined) {
+                this.crownRadius = crownRadius;
+            }
+            if (trunkRadius !== undefined) {
+                this.trunkRadius = trunkRadius;
+            }
+            if (crownMaterial !== undefined) {
+                this.crownMaterial = crownMaterial;
+            }
+            if (trunkMaterial !== undefined) {
+                this.trunkMaterial = trunkMaterial;
+            }
+        }
+    }
+    IFC.AddTreeDto = AddTreeDto;
+    /**
+     * 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, value, type) {
+            /**
+             * The property's name, such as `IsExternal` or `FireRating`.
+             * @default Property
+             */
+            this.name = "Property";
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (value !== undefined) {
+                this.value = value;
+            }
+            if (type !== undefined) {
+                this.type = type;
+            }
+        }
+    }
+    IFC.PropertyDto = PropertyDto;
+    /**
+     * A property set to attach to elements for `properties.addSet`, such as `Pset_WallCommon` with its
+     * `IsExternal` and `LoadBearing`.
+     */
+    class AddPropertySetDto {
+        constructor(model, elements, name, properties) {
+            /**
+             * The set's name. Names starting with `Pset_` are reserved for the sets the IFC standard defines.
+             * @default Properties
+             */
+            this.name = "Properties";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (elements !== undefined) {
+                this.elements = elements;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (properties !== undefined) {
+                this.properties = properties;
+            }
+        }
+    }
+    IFC.AddPropertySetDto = AddPropertySetDto;
+    /**
+     * 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 {
+        constructor(model, element, name, properties) {
+            /**
+             * The name of the property set, such as `Pset_WallCommon`.
+             * @default Properties
+             */
+            this.name = "Properties";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (element !== undefined) {
+                this.element = element;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (properties !== undefined) {
+                this.properties = properties;
+            }
+        }
+    }
+    IFC.SetPropertyValuesDto = SetPropertyValuesDto;
+    /**
+     * Properties to take out of one property set of one object for `properties.removeValues`.
+     */
+    class RemovePropertyValuesDto {
+        constructor(model, element, name, names) {
+            /**
+             * The name of the property set, such as `Pset_WallCommon`.
+             * @default Properties
+             */
+            this.name = "Properties";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (element !== undefined) {
+                this.element = element;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (names !== undefined) {
+                this.names = names;
+            }
+        }
+    }
+    IFC.RemovePropertyValuesDto = RemovePropertyValuesDto;
+    /**
+     * One property set of one object to take away, for `properties.removeSet`.
+     */
+    class RemovePropertySetDto {
+        constructor(model, element, name) {
+            /**
+             * The name of the property set, such as `Pset_WallCommon`.
+             * @default Properties
+             */
+            this.name = "Properties";
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (element !== undefined) {
+                this.element = element;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+        }
+    }
+    IFC.RemovePropertySetDto = RemovePropertySetDto;
+    /**
+     * A property set as `properties.getSets` reads it back.
+     */
+    class PropertySetInfoDto {
+        constructor() {
+            /**
+             * What the set is called, such as `Pset_WallCommon`.
+             * @default ""
+             */
+            this.name = "";
+            /**
+             * Its single values by property name, such as `{ IsExternal: true }`.
+             * @default {}
+             */
+            this.properties = {};
+        }
+    }
+    IFC.PropertySetInfoDto = PropertySetInfoDto;
+    /**
+     * The model and the elements to measure for `quantities.compute`, every one it can when left out.
+     */
+    class ComputeQuantitiesDto {
+        constructor(model, elements) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (elements !== undefined) {
+                this.elements = elements;
+            }
+        }
+    }
+    IFC.ComputeQuantitiesDto = ComputeQuantitiesDto;
+    /**
+     * 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 {
+        constructor() {
+            /**
+             * What the set is called, such as `Qto_WallBaseQuantities`.
+             * @default ""
+             */
+            this.name = "";
+            /**
+             * 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 {}
+             */
+            this.quantities = {};
+        }
+    }
+    IFC.QuantitySetInfoDto = QuantitySetInfoDto;
+    /**
+     * A model, the elements to describe and how to group them for `geometry.recipe`.
+     */
+    class GeometryDto {
+        constructor(model, elements, groupByClass) {
+            /**
+             * 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
+             */
+            this.groupByClass = true;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (elements !== undefined) {
+                this.elements = elements;
+            }
+            if (groupByClass !== undefined) {
+                this.groupByClass = groupByClass;
+            }
+        }
+    }
+    IFC.GeometryDto = GeometryDto;
+    /**
+     * A model and the elements to check for `geometry.unsupported`.
+     */
+    class GeometryElementsDto {
+        constructor(model, elements) {
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (elements !== undefined) {
+                this.elements = elements;
+            }
+        }
+    }
+    IFC.GeometryElementsDto = GeometryElementsDto;
+    /**
+     * 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 {
+        constructor(model, elements, adjustZtoY, emptyWhenFailed, facetedMeshes, maxTriangles) {
+            /**
+             * 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
+             */
+            this.adjustZtoY = true;
+            /**
+             * 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
+             */
+            this.emptyWhenFailed = true;
+            /**
+             * 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
+             */
+            this.facetedMeshes = false;
+            /**
+             * 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
+             */
+            this.maxTriangles = 100000;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (elements !== undefined) {
+                this.elements = elements;
+            }
+            if (adjustZtoY !== undefined) {
+                this.adjustZtoY = adjustZtoY;
+            }
+            if (emptyWhenFailed !== undefined) {
+                this.emptyWhenFailed = emptyWhenFailed;
+            }
+            if (facetedMeshes !== undefined) {
+                this.facetedMeshes = facetedMeshes;
+            }
+            if (maxTriangles !== undefined) {
+                this.maxTriangles = maxTriangles;
+            }
+        }
+    }
+    IFC.GeometryToShapesDto = GeometryToShapesDto;
+    /**
+     * 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 {
+        constructor(model, elements, name, emptyWhenFailed, facetedMeshes, maxTriangles, groupByClass) {
+            /**
+             * The name of the assembly at the top of the document, which holds every element.
+             * @default Model
+             */
+            this.name = "Model";
+            /**
+             * 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
+             */
+            this.emptyWhenFailed = true;
+            /**
+             * 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
+             */
+            this.facetedMeshes = false;
+            /**
+             * 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
+             */
+            this.maxTriangles = 100000;
+            /**
+             * 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
+             */
+            this.groupByClass = true;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (elements !== undefined) {
+                this.elements = elements;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (emptyWhenFailed !== undefined) {
+                this.emptyWhenFailed = emptyWhenFailed;
+            }
+            if (facetedMeshes !== undefined) {
+                this.facetedMeshes = facetedMeshes;
+            }
+            if (maxTriangles !== undefined) {
+                this.maxTriangles = maxTriangles;
+            }
+            if (groupByClass !== undefined) {
+                this.groupByClass = groupByClass;
+            }
+        }
+    }
+    IFC.GeometryToDocumentDto = GeometryToDocumentDto;
+    /**
+     * 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 {
+        constructor(model, elements, name, fileName, emptyWhenFailed, facetedMeshes, maxTriangles, compress, tryDownload, groupByClass) {
+            /**
+             * The name of the assembly at the top of the file, which holds every element.
+             * @default Model
+             */
+            this.name = "Model";
+            /**
+             * The file name, used for the download and written into the file's header.
+             * @default model.step
+             */
+            this.fileName = "model.step";
+            /**
+             * 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
+             */
+            this.emptyWhenFailed = true;
+            /**
+             * 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
+             */
+            this.facetedMeshes = false;
+            /**
+             * 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
+             */
+            this.maxTriangles = 100000;
+            /**
+             * When true, the file is written as gzip-compressed STEP-Z.
+             * @default false
+             */
+            this.compress = false;
+            /**
+             * When true, a browser download of the file is started where that is possible; the bytes are
+             * returned either way.
+             * @default false
+             */
+            this.tryDownload = false;
+            /**
+             * 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
+             */
+            this.groupByClass = true;
+            if (model !== undefined) {
+                this.model = model;
+            }
+            if (elements !== undefined) {
+                this.elements = elements;
+            }
+            if (name !== undefined) {
+                this.name = name;
+            }
+            if (fileName !== undefined) {
+                this.fileName = fileName;
+            }
+            if (emptyWhenFailed !== undefined) {
+                this.emptyWhenFailed = emptyWhenFailed;
+            }
+            if (facetedMeshes !== undefined) {
+                this.facetedMeshes = facetedMeshes;
+            }
+            if (maxTriangles !== undefined) {
+                this.maxTriangles = maxTriangles;
+            }
+            if (compress !== undefined) {
+                this.compress = compress;
+            }
+            if (tryDownload !== undefined) {
+                this.tryDownload = tryDownload;
+            }
+            if (groupByClass !== undefined) {
+                this.groupByClass = groupByClass;
+            }
+        }
+    }
+    IFC.GeometryToStepDto = GeometryToStepDto;
+    /**
+     * An element `geometry.recipe` had to leave out, as `geometry.unsupported` lists it.
+     */
+    class GeometryProblemDto {
+        constructor() {
+            /**
+             * The GlobalId of the element left out.
+             * @default ""
+             */
+            this.globalId = "";
+            /**
+             * Its IFC type, such as `IfcWall`.
+             * @default ""
+             */
+            this.type = "";
+            /**
+             * What could not be described, in a sentence.
+             * @default ""
+             */
+            this.message = "";
+        }
+    }
+    IFC.GeometryProblemDto = GeometryProblemDto;
+})(IFC || (IFC = {}));