@snaptrude/plugin-core 0.0.0-bimsvg-20260928124803

package/dist/api/design/create/index.d.ts

@@ -0,0 +1,1747 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../types";
+import { BrepHandle, ComponentHandle, ContourHandle, CurveHandle, ProfileHandle, Vec3Handle } from "../../../handles";
+import { PluginGridStyleOptions } from "./grids";
+import { PluginSpaceType, PluginMassType, PluginDepartmentId } from "../../entity/space";
+import { PluginBuildableEnvelopePolygonVertex, PluginBuildableEnvelopeSetbackTier, PluginBuildableEnvelopeVerticalCap, PluginBuildableEnvelopeCreateResult } from "../../entity/buildableEnvelope";
+import type { PluginCreateDoorItem, PluginCreateFloorItem, PluginCreateFurnitureItem, PluginCreateWallRunItem, PluginCreateWindowItem } from "./bulk-items";
+/**
+ * `design.create.*` — author new scene-committed BIM entities.
+ *
+ * Every creator takes geometry handles + scalars and returns a
+ * {@linkcode ComponentHandle} (or `ComponentHandle[]` for plural creators;
+ * `wallRuns` returns one `ComponentHandle[]` per run) — the
+ * `Component.id` of the created entity, resolvable across the rest of the
+ * `design.*` surface. Creation is an undoable host call; it **throws** on failure
+ * (no `Result` wrapper — consistent with `core.geom.create.*`).
+ *
+ * Footprint objects take a {@linkcode ContourHandle} (outer profile + holes);
+ * build one with `snaptrude.core.geom.create.contourFromProfile(s)`.
+ *
+ * `door`/`window` place a catalog item into a host wall (the world point is
+ * projected onto the wall face to locate the opening; the wall is re-cut in one
+ * undo entry) and throw if the point projects outside the wall. `smartLayout` is
+ * the one creator returning a grouped {@linkcode PluginSmartLayoutResult} rather
+ * than a handle — it clones an in-scene template into one or more target spaces,
+ * merging every target into a single undo batch (see its JSDoc).
+ *
+ * Accessed via `snaptrude.design.create`.
+ */
+export declare abstract class PluginDesignCreateApi {
+    constructor();
+    /**
+     * Create a **space** (a room / mass) by extruding a footprint contour upward.
+     *
+     * The `contour` is the bottom footprint (outer profile + optional holes); it
+     * is extruded by `height` along +Y. The space is placed on the active story
+     * and assigned a default department unless overridden.
+     *
+     * @param contour - Bottom footprint (outer + holes)
+     * @param height - Extrusion height (Snaptrude units, > 0)
+     * @param label - Room label (maps to the space's `room_type`)
+     * @param position - Offset from origin (default origin)
+     * @param spaceType - Space-type classification (default `Room`)
+     * @param massType - Mass-type classification (default `Room`)
+     * @param departmentId - Department assignment (default department)
+     * @param storey - Target storey number to place the space on — the same integer
+     *   `entity.story` uses (`1` ground, `2` first floor, `-1` basement). Default:
+     *   the active storey. Folds a `core.storeys.setActive` call into the create,
+     *   placing the space at that storey's floor elevation (any `position` offset is
+     *   applied on top). Throws if no storey has that value.
+     * @returns the {@linkcode ComponentHandle} of the created space
+     * @throws if the contour is invalid, the height is not positive, or the target
+     *   storey does not exist
+     *
+     * @examplePrompt Create a room called Living Room that's 3m tall from this outline
+     * @examplePrompt Add a new space on the current storey using this footprint
+     * @examplePrompt Make a bedroom here and assign it to the Residential department
+     * @examplePrompt Extrude this closed outline into a 10 foot high room
+     * @examplePrompt Can you create a Kitchen space from the sketch I just drew?
+     * @examplePrompt Create a bedroom on the second floor from this outline
+     *
+     * @performance For MORE THAN ONE space, call `design.create.spaces(items[])` — the whole
+     *   batch is one host round-trip. Looping this single-space creator is N round-trips (slow,
+     *   and a large loop can trip the plugin rate limit).
+     *
+     * # Example
+     * ```ts
+     * const v = snaptrude.core.math.vec3
+     * const outer = await snaptrude.core.geom.create.profileFromLinePoints([
+     *   await v.new(0, 0, 0),
+     *   await v.new(10, 0, 0),
+     *   await v.new(10, 0, 8),
+     *   await v.new(0, 0, 8),
+     * ])
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(outer)
+     * const space = await snaptrude.design.create.space(contour, 3, "Living")
+     * // …place one directly on the second floor (no setActive dance):
+     * const upstairs = await snaptrude.design.create.space(
+     *   contour, 3, "Bedroom", undefined, undefined, undefined, undefined, 2,
+     * )
+     * ```
+     */
+    abstract space(contour: ContourHandle, height: number, label?: string, position?: Vec3Handle, spaceType?: PluginSpaceType, massType?: PluginMassType, departmentId?: PluginDepartmentId, storey?: number): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a **mass** — a generic extruded prism (default `massType` "Generic mass").
+     * Same footprint-extrude path as {@linkcode PluginDesignCreateApi.space}.
+     *
+     * @param contour - Footprint (outer + holes)
+     * @param height - Extrusion height (> 0)
+     * @param label - Label (maps to `room_type`)
+     * @param position - Offset from origin
+     * @param massType - Mass type (default `Generic mass`)
+     * @returns the {@linkcode ComponentHandle} of the created mass
+     * @throws if the contour is invalid or the height is not positive
+     *
+     * @examplePrompt Create a generic mass 30m tall from this footprint
+     * @examplePrompt Block out a conceptual massing volume for the site
+     * @examplePrompt Extrude this shape into a building mass
+     * @examplePrompt Add a simple study-model volume at the origin
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(20, 15)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const tower = await snaptrude.design.create.mass(contour, 30, "Tower A", undefined, "Building")
+     * ```
+     */
+    abstract mass(contour: ContourHandle, height: number, label?: string, position?: Vec3Handle, massType?: PluginMassType): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a **mass** from a custom solid built with a `core.geom.create` brep
+     * constructor (`brepFromFaces`, `brepFromExtrusion`, `brepFromLoft`,
+     * `brepFromMesh`, or a brep boolean) — the free-form counterpart of
+     * {@linkcode PluginDesignCreateApi.mass}, for solids that are not simple
+     * footprint extrusions (pyramids, wedges, faceted volumes).
+     *
+     * Only accepts breps **minted by a `core.geom.create` brep constructor** —
+     * scene-derived breps from `design.query.geometry.getBrep` are read-only and
+     * throw. The mass is created as a generic mass (`massType` "Generic mass") at
+     * the exact coordinates the solid was authored in, committed as a single
+     * undo step, and synced to collaborators like any other creator.
+     *
+     * @param brep - A solid from a `core.geom.create` brep constructor
+     * @param label - Label (maps to `room_type`)
+     * @returns the {@linkcode ComponentHandle} of the created mass
+     * @throws if the brep handle is invalid, or the brep was not created by a
+     *   `core.geom.create` brep constructor
+     *
+     * @examplePrompt Create a mass from these faces
+     * @examplePrompt Turn this custom brep into a scene mass
+     * @examplePrompt Add a pyramid-shaped mass to the model
+     *
+     * # Example
+     * ```ts
+     * const apex = { x: 0, y: 4, z: 0 }
+     * const a = { x: -2, y: 0, z: -2 }
+     * const b = { x: 2, y: 0, z: -2 }
+     * const c = { x: 2, y: 0, z: 2 }
+     * const d = { x: -2, y: 0, z: 2 }
+     * const brep = await snaptrude.core.geom.create.brepFromFaces([
+     *   [a, d, c, b],
+     *   [a, b, apex],
+     *   [b, c, apex],
+     *   [c, d, apex],
+     *   [d, a, apex],
+     * ])
+     * const pyramid = await snaptrude.design.create.massFromBrep(brep, "Pavilion")
+     * ```
+     */
+    abstract massFromBrep(brep: BrepHandle, label?: string): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a **slab** by extruding a footprint contour by `thickness`
+     * (default direction: down).
+     *
+     * @param contour - Footprint (outer + holes)
+     * @param thickness - Slab thickness (> 0)
+     * @param direction - Extrusion direction (default `"down"`)
+     * @param slabType - Slab-type classification
+     * @returns the {@linkcode ComponentHandle} of the created slab
+     * @throws if the contour is invalid or the thickness is not positive
+     *
+     * @examplePrompt Add a 150mm thick slab under this footprint
+     * @examplePrompt Create a floor slab from this outline
+     * @examplePrompt Pour a plinth slab over the building footprint
+     * @examplePrompt Make a basement slab that extrudes downward
+     * @examplePrompt Give this room outline a 6 inch slab
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(12, 10)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const slab = await snaptrude.design.create.slab(contour, 0.15, "down", "Plinth")
+     * ```
+     */
+    abstract slab(contour: ContourHandle, thickness: number, direction?: "up" | "down", slabType?: PluginSlabType): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a **floor** by extruding a footprint contour by `thickness`
+     * (extruded upward).
+     *
+     * @param contour - Footprint (outer + holes)
+     * @param thickness - Floor thickness (> 0)
+     * @param position - Offset from origin
+     * @returns the {@linkcode ComponentHandle} of the created floor
+     * @throws if the contour is invalid or the thickness is not positive
+     *
+     * @examplePrompt Create a floor from this room outline
+     * @examplePrompt Add a 100mm thick floor over the footprint
+     * @examplePrompt Lay flooring across the selected outline
+     * @examplePrompt Put a floor at this position with 150mm thickness
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(5, 4)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const floor = await snaptrude.design.create.floor(contour, 0.1)
+     * ```
+     *
+     * @performance For MORE THAN ONE floor, call `design.create.floors(items[])` — one
+     *   host round-trip and ONE undo entry for the whole batch. Looping this single-floor
+     *   creator is N round-trips and N undo entries.
+     */
+    abstract floor(contour: ContourHandle, thickness: number, position?: Vec3Handle): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create **many floors** in one undoable operation (bulk plural of
+     * {@linkcode floor}). Each item extrudes its own footprint contour (outer
+     * profile + holes) upward by its own `thickness`, at its own optional
+     * position offset. Validate-all-or-throw; one command.
+     *
+     * @param items - One {@linkcode PluginCreateFloorItem} per floor to create
+     *   (≥1, ≤1000)
+     * @returns the created floors as {@linkcode ComponentHandle}`[]`, in input order
+     * @throws `VALIDATION` if the items fail the schema (empty array, more than
+     *   1000 items, a non-positive thickness) or a contour is degenerate;
+     *   `HANDLE_INVALID` if a `contour` or `position` handle is unknown or
+     *   released; `OPERATION_FAILED` if extrusion fails (nothing is created —
+     *   `details.itemIndex` is the failing item); `METHOD_NOT_PERMITTED` if the
+     *   plugin may not write.
+     *
+     * @examplePrompt Create floors for all these room outlines at once
+     * @examplePrompt Add a floor to every space in one operation
+     * @examplePrompt Bulk create the floor plates for this building
+     * @examplePrompt Lay 100mm floors across these five footprints in one undo step
+     * @examplePrompt Create the ground and first floor slabs together
+     *
+     * @performance Bulk creator — the whole batch is ONE host round-trip and ONE undo
+     *   entry. Always prefer this over calling `design.create.floor` in a loop: build the
+     *   full `items[]` array first (all contours and offsets up front), then make one call.
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(5, 4)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const [ground, upper] = await snaptrude.design.create.floors([
+     *   { contour, thickness: 0.1 },
+     *   { contour, thickness: 0.1, position: await snaptrude.core.math.vec3.new(0, 3, 0) },
+     * ])
+     * ```
+     */
+    abstract floors(items: PluginCreateFloorItem[]): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Create a **roof** by extruding a footprint contour by `thickness`. Created
+     * flat (extruded downward); pitch/slope is a separate post-creation edit.
+     *
+     * @param contour - Footprint (outer + holes)
+     * @param thickness - Roof-slab thickness (> 0)
+     * @returns the {@linkcode ComponentHandle} of the created roof
+     * @throws if the contour is invalid or the thickness is not positive
+     *
+     * @examplePrompt Add a flat roof over the building footprint
+     * @examplePrompt Create a roof 200mm thick from this outline
+     * @examplePrompt Cover the top storey with a roof slab
+     * @examplePrompt Put a roof on this building
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(12, 10)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const roof = await snaptrude.design.create.roof(contour, 0.2)
+     * ```
+     */
+    abstract roof(contour: ContourHandle, thickness: number): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a **ceiling** by extruding a footprint contour by `thickness`, lifted
+     * `heightFromFloor` above the floor.
+     *
+     * @param contour - Footprint (outer + holes)
+     * @param thickness - Ceiling thickness (> 0)
+     * @param heightFromFloor - Lift above the floor (default 0)
+     * @returns the {@linkcode ComponentHandle} of the created ceiling
+     * @throws if the contour is invalid or the thickness is not positive
+     *
+     * @examplePrompt Add a false ceiling 2.7m above the floor
+     * @examplePrompt Create a ceiling over this room footprint
+     * @examplePrompt Put a dropped ceiling in the living room at 3 metres
+     * @examplePrompt Add a 50mm thick ceiling lifted 2800mm from floor level
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(5, 4)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const ceiling = await snaptrude.design.create.ceiling(contour, 0.05, 2.8)
+     * ```
+     */
+    abstract ceiling(contour: ContourHandle, thickness: number, heightFromFloor?: number): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a **column** by extruding a cross-section contour upward by `height`
+     * from a base `position`. The column is built to EXACTLY `height` — unlike
+     * the interactive draw tool, no slab-thickness deduction is applied.
+     *
+     * @param position - Base point
+     * @param crossSection - Column cross-section footprint
+     * @param height - Column height (> 0), built exactly
+     * @param directionUp - Up axis (default world up); normalized by the host, so
+     * magnitude does not scale the height
+     * @returns the {@linkcode ComponentHandle} of the created column
+     * @throws if the cross-section is invalid, the height is not positive, or the
+     * direction is zero / lies in the cross-section plane (degenerate extrusion)
+     *
+     * @examplePrompt Add a 3m tall column at this point
+     * @examplePrompt Place a column at the grid intersection
+     * @examplePrompt Create a 450mm square concrete column 4 metres high
+     * @examplePrompt Stand a column up from this base point
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(0.45, 0.45)
+     * const crossSection = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const base = await snaptrude.core.math.vec3.new(4, 0, 4)
+     * const column = await snaptrude.design.create.column(base, crossSection, 3)
+     * ```
+     */
+    abstract column(position: Vec3Handle, crossSection: ContourHandle, height: number, directionUp?: Vec3Handle): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a **beam** by extruding a cross-section contour along `direction` by
+     * `length`. Matches the Snaptrude beam tool's semantics: the beam body hangs
+     * BELOW the plane the section is authored on.
+     *
+     * For a **horizontal** `direction` (the common spanning beam), author the
+     * section as an axis-aligned plan rectangle: its X extent is the beam's
+     * width, its Z extent is the beam's depth (the vertical drop). The beam runs
+     * `length` along `direction` starting at the section's centre, hanging below
+     * the authoring plane by its depth — exactly like an interactively drawn
+     * beam. Only axis-aligned rectangular sections are supported horizontally.
+     *
+     * For a **vertical** `direction` (the default), the section itself is
+     * extruded by `length`, again hanging below the authoring plane. Diagonal
+     * directions are rejected.
+     *
+     * @param section - Beam cross-section, an axis-aligned rectangle in plan
+     * (X extent = width, Z extent = depth)
+     * @param length - Beam length along `direction` (> 0); direction is
+     * normalized by the host, so magnitude does not scale the length
+     * @param direction - Beam axis: horizontal for a spanning beam, or vertical
+     * (default world up). Diagonal directions throw.
+     * @returns the {@linkcode ComponentHandle} of the created beam
+     * @throws if the section is invalid (horizontal beams: not an axis-aligned
+     * plan rectangle), the length is not positive, or the direction is zero or
+     * diagonal
+     *
+     * @examplePrompt Add a beam spanning 6 metres between the columns
+     * @examplePrompt Create a horizontal beam along the X axis
+     * @examplePrompt Run a 300x600 beam across the room
+     * @examplePrompt Extrude this cross-section into a 5m long beam
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(0.3, 0.6)
+     * const section = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const alongX = await snaptrude.core.math.vec3.new(1, 0, 0)
+     * const beam = await snaptrude.design.create.beam(section, 6, alongX)
+     * ```
+     */
+    abstract beam(section: ContourHandle, length: number, direction?: Vec3Handle): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a connected run of **walls** from a profile — one wall per curve in
+     * the profile's chain, with mitred corners at shared endpoints.
+     *
+     * @param profile - Ordered curve chain (wall centerlines)
+     * @param height - Wall height (default engine default)
+     * @param thickness - Wall thickness (default: the `wallType`'s total layer
+     *   thickness when `wallType` is given, else the engine default)
+     * @param wallType - Wall type to build with — the same searchable list the
+     *   Draw tab's Wall Type dropdown offers. Pass a name from
+     *   `design.types.list("wall")` (the summary's `label`, or its `"wall:…"` id).
+     *   Drives the wall's construction layers and default material, and — when
+     *   `thickness` is omitted — its total layer thickness. Default: the engine's
+     *   generic wall.
+     * @param storey - Target storey (integer: `1` ground, `2` first floor, `-1`
+     *   basement — same convention as `design.create.space`). The walls are
+     *   assigned to it and lifted to its base elevation, all inside the same
+     *   single undo entry. The storey must already exist
+     *   (`core.storeys.create` first). Default: geometry-derived — a profile
+     *   drawn at y = 0 lands on storey 1; the ACTIVE storey is NOT consulted.
+     * @returns a {@linkcode ComponentHandle}`[]` (one per wall), in profile order
+     * @throws if the profile is empty, `wallType` names no wall type in the
+     *   project, `storey` does not exist, or wall creation fails
+     *
+     * @examplePrompt Draw walls along this centerline
+     * @examplePrompt Create 3m high, 200mm thick walls from these points
+     * @examplePrompt Build a wall run around the room outline
+     * @examplePrompt Turn this polyline sketch into walls
+     * @examplePrompt Add walls with mitred corners along the path
+     * @examplePrompt Draw brick walls with plaster along this outline
+     * @examplePrompt Build the perimeter in exposed concrete walls
+     *
+     * # Example
+     * ```ts
+     * const v = snaptrude.core.math.vec3
+     * const centerlines = await snaptrude.core.geom.create.profileFromLinePoints([
+     *   await v.new(0, 0, 0),
+     *   await v.new(8, 0, 0),
+     *   await v.new(8, 0, 6),
+     * ])
+     * const walls = await snaptrude.design.create.walls(centerlines, 3, 0.2)
+     * // …built as a specific wall type (layers/material/thickness from the type):
+     * const [brick] = await snaptrude.design.types.list("wall")
+     * const brickWalls = await snaptrude.design.create.walls(
+     *   centerlines, 3, undefined, brick.label,
+     * )
+     * ```
+     *
+     * @performance For MORE THAN ONE run, call `design.create.wallRuns(items[])` — one
+     *   host round-trip and ONE undo entry for every run in the batch. Looping this
+     *   single-run creator is N round-trips and N undo entries.
+     */
+    abstract walls(profile: ProfileHandle, height?: number, thickness?: number, wallType?: string, storey?: number): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Create **many wall runs** in one undoable operation (bulk plural of
+     * {@linkcode walls}). Each item is one full run — a wall per curve in that
+     * item's profile chain, mitred at shared endpoints. Junctions resolve within a
+     * run, not between runs. Each item carries its own
+     * dimensions, `wallType` and `storey`, so a single call can build a whole
+     * floor plate or several storeys at once. Validate-all-or-throw; one command.
+     *
+     * @param items - One {@linkcode PluginCreateWallRunItem} per run to create
+     *   (≥1, ≤1000)
+     * @returns one {@linkcode ComponentHandle}`[]` per item, in input order —
+     *   each inner array holding that run's walls in profile-curve order
+     * @throws `VALIDATION` if the items fail the schema (empty array, more than
+     *   1000 items, a non-positive height or thickness, a zero-length curve);
+     *   `HANDLE_INVALID` if a `profile` handle is unknown or released;
+     *   `PRECONDITION_FAILED` if a profile has no curves, `wallType` names no
+     *   wall type in the project, or `storey` does not exist;
+     *   `OPERATION_FAILED` if wall creation fails (nothing is created —
+     *   `details.itemIndex` is the failing item); `METHOD_NOT_PERMITTED` if the
+     *   plugin may not write.
+     *
+     * @examplePrompt Draw all the walls of this floor plan at once
+     * @examplePrompt Build every room's perimeter in one operation
+     * @examplePrompt Bulk create wall runs from these centerlines
+     * @examplePrompt Create the walls for both storeys in a single undo step
+     * @examplePrompt Turn these polylines into 200mm brick walls together
+     *
+     * @performance Bulk creator — the whole batch is ONE host round-trip and ONE undo
+     *   entry. Always prefer this over calling `design.create.walls` in a loop: build the
+     *   full `items[]` array first (all profiles up front), then make one call.
+     *
+     * # Example
+     * ```ts
+     * const v = snaptrude.core.math.vec3
+     * const ground = await snaptrude.core.geom.create.profileFromLinePoints([
+     *   await v.new(0, 0, 0),
+     *   await v.new(8, 0, 0),
+     *   await v.new(8, 0, 6),
+     * ])
+     * const upper = await snaptrude.core.geom.create.profileFromLinePoints([
+     *   await v.new(0, 0, 0),
+     *   await v.new(8, 0, 0),
+     * ])
+     * const [groundWalls, upperWalls] = await snaptrude.design.create.wallRuns([
+     *   { profile: ground, height: 3, thickness: 0.2 },
+     *   { profile: upper, height: 3, storey: 2 },
+     * ])
+     * console.log(groundWalls.length, "walls on the ground floor")
+     * ```
+     */
+    abstract wallRuns(items: PluginCreateWallRunItem[]): PluginApiReturn<ComponentHandle[][]>;
+    /**
+     * Create a **staircase** from a parametric preset, placed at a point.
+     *
+     * Geometry is procedurally generated from the chosen `preset`; there is no
+     * footprint input. Placed on the active structure/story unless overridden.
+     * The promise resolves only after the staircase's asynchronous geometry union
+     * and creation-command capture settle; a union failure rejects the call.
+     *
+     * @param preset - The parametric preset to generate
+     * @param position - Placement point
+     * @param label - Optional label
+     * @param structureId - Target structure (default active)
+     * @param level - Target level name (default active/`"01"`)
+     * @param dimensions - Optional positive dimension overrides in Snaptrude engine
+     *   units, plus a placement angle in 90-degree increments. Overrides are
+     *   applied to the staircase parameters before the creation command runs.
+     * @returns the {@linkcode ComponentHandle} of the created staircase
+     * @throws if the preset is unknown or placement fails
+     *
+     * @examplePrompt Add a dog-legged staircase at this location
+     * @examplePrompt Place a straight stair on level 01
+     * @examplePrompt Create an L-shaped staircase in the lobby
+     * @examplePrompt Insert a staircase near the entrance
+     * @examplePrompt Put amphitheatre steps at these coordinates
+     *
+     * # Example
+     * ```ts
+     * const stair = await snaptrude.design.create.staircase(
+     *   "dogLegged",
+     *   await snaptrude.core.math.vec3.new(5, 0, 5),
+     * )
+     * ```
+     */
+    abstract staircase(preset: PluginStaircasePreset, position: Vec3Handle, label?: string, structureId?: string, level?: string, dimensions?: PluginStaircaseDimensions): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create **reference lines** from a profile — one reference line per curve in
+     * the profile's ordered chain. Returns a handle per created line.
+     *
+     * Optional style (`color`, `thickness`, `style`, `gridTag`) applies to
+     * every created line.
+     *
+     * @param profile - Ordered curve chain (centerlines)
+     * @param color - Hex color `"#RRGGBB"` (default white)
+     * @param thickness - Line thickness (default 1)
+     * @param style - Line style (default `SOLID`)
+     * @param gridTag - Grid tag label (default `"A"`)
+     * @returns a {@linkcode ComponentHandle}`[]` (one per curve), in profile order
+     * @throws if the profile is empty or creation fails
+     *
+     * @examplePrompt Draw a reference line between these two points
+     * @examplePrompt Add dashed guide lines along this path
+     * @examplePrompt Create grid lines tagged A through the plan
+     * @examplePrompt Set up construction lines for the column grid
+     * @examplePrompt Mark a red reference line across the site
+     *
+     * # Example
+     * ```ts
+     * const v = snaptrude.core.math.vec3
+     * const profile = await snaptrude.core.geom.create.profileFromLinePoints([
+     *   await v.new(0, 0, 0),
+     *   await v.new(10, 0, 0),
+     * ])
+     * const lines = await snaptrude.design.create.referenceLines(
+     *   profile,
+     *   undefined,
+     *   undefined,
+     *   "DASHED",
+     * )
+     * ```
+     */
+    abstract referenceLines(profile: ProfileHandle, color?: string, thickness?: number, style?: PluginReferenceLineStyle, gridTag?: string): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Create a free rectangular **structural grid** — one grid group with two
+     * perpendicular line families (`linesX` lines spaced `spacingX` apart, and
+     * `linesY` lines spaced `spacingY` apart) on the active storey. One undoable
+     * creation.
+     *
+     * Units: spacings in Snaptrude units; `angle` in degrees (CCW about +Y,
+     * default 0). Without `center` the grid is centred on the current viewport
+     * (the native tool's behavior) — pass `center` for deterministic placement.
+     *
+     * @param linesX - Line count of the first family (integer ≥ 1)
+     * @param linesY - Line count of the second family (integer ≥ 1)
+     * @param spacingX - First-family spacing (Snaptrude units, > 0)
+     * @param spacingY - Second-family spacing (Snaptrude units, > 0)
+     * @param options - `angle`, `center`, and {@linkcode PluginGridStyleOptions}
+     * @returns the created grid group's {@linkcode ComponentHandle}
+     *
+     * @examplePrompt Create a 5 by 8 structural grid with 6 metre spacing
+     * @examplePrompt Add a column grid rotated 30 degrees
+     * @examplePrompt Set up a structural grid at the site origin
+     *
+     * # Example
+     * ```ts
+     * const centre = await snaptrude.core.math.vec3.new(0, 0, 0)
+     * const grid = await snaptrude.design.create.grid(5, 8, 6, 6, { center: centre })
+     * ```
+     */
+    abstract grid(linesX: number, linesY: number, spacingX: number, spacingY: number, options?: {
+        angle?: number;
+        center?: Vec3Handle;
+    } & PluginGridStyleOptions): PluginApiReturn<ComponentHandle>;
+    /**
+     * Create a **structural grid from a single curve** — one grid group holding
+     * one wing with one line (the draw tool's output). The curve may be a line
+     * or an arc; circles are rejected with `VALIDATION`. Undoable.
+     *
+     * @param curve - The grid line's geometry ({@linkcode CurveHandle}, world space)
+     * @param options - `tag` (defaults to the draw tool's next tag) and
+     *   {@linkcode PluginGridStyleOptions}
+     * @returns the created grid group's {@linkcode ComponentHandle}
+     *
+     * @examplePrompt Draw a grid line from A to B
+     * @examplePrompt Add a curved grid line through these points
+     * @examplePrompt Create grid line "C" along this wall
+     *
+     * # Example
+     * ```ts
+     * const { vec3 } = snaptrude.core.math
+     * const from = await vec3.new(0, 0, 0)
+     * const to = await vec3.new(30, 0, 0)
+     * const curve = await snaptrude.core.geom.create.line(from, to)
+     * const grid = await snaptrude.design.create.gridFromCurve(curve, { tag: "A" })
+     * ```
+     */
+    abstract gridFromCurve(curve: CurveHandle, options?: {
+        tag?: string;
+    } & PluginGridStyleOptions): PluginApiReturn<ComponentHandle>;
+    /**
+     * Generate **structural grids fitted to mass footprints** — one grid group
+     * per footprint cluster, with counts and orientation derived from each
+     * footprint's geometry and the given spacings. All created groups commit as
+     * ONE undoable unit.
+     *
+     * Lenient like the native tool: masses without an extractable footprint
+     * (no B-rep, degenerate top face) are skipped; throws `VALIDATION` only when
+     * NONE of the given masses yields a footprint.
+     *
+     * @param masses - Masses whose footprints seat the grids
+     * @param spacingX - First-family spacing (Snaptrude units, > 0)
+     * @param spacingY - Second-family spacing (Snaptrude units, > 0)
+     * @param options - {@linkcode PluginGridStyleOptions}
+     * @returns the created grid groups' {@linkcode ComponentHandle}`[]`
+     *
+     * @examplePrompt Generate grids for the selected masses
+     * @examplePrompt Auto-generate a 6m structural grid on this building
+     * @examplePrompt Fit column grids to every mass on this storey
+     *
+     * # Example
+     * ```ts
+     * const masses = await snaptrude.design.query.listMasses({ storeys: [1] })
+     * const grids = await snaptrude.design.create.gridsFromMasses(masses, 6, 6)
+     * ```
+     */
+    abstract gridsFromMasses(masses: ComponentHandle[], spacingX: number, spacingY: number, options?: PluginGridStyleOptions): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Create **columns at every grid-line intersection** of the given grid
+     * groups, sized `width` × `depth` and oriented to the grid axes, on the
+     * grids' storey. All columns commit as ONE undoable unit.
+     *
+     * @param grids - Grid groups whose intersections seat the columns
+     * @param width - Column width (Snaptrude units, > 0)
+     * @param depth - Column depth (Snaptrude units, > 0)
+     * @returns the created columns' {@linkcode ComponentHandle}`[]`
+     * @throws `VALIDATION` when an id does not resolve to a grid group;
+     *   `OPERATION_FAILED` when the grids have no line intersections
+     *
+     * @examplePrompt Generate columns on this grid
+     * @examplePrompt Place 450mm square columns at every grid intersection
+     *
+     * # Example
+     * ```ts
+     * const grids = await snaptrude.design.query.listGrids()
+     * const columns = await snaptrude.design.create.columnsFromGrids(grids, 0.45, 0.45)
+     * ```
+     */
+    abstract columnsFromGrids(grids: ComponentHandle[], width: number, depth: number): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Place a **furniture** item from the project library at a world position.
+     *
+     * Identified by a **catalog (library) id** — the team object's stable `_id` for
+     * project uploads, or the item's `fullName` for the general library. Discover ids
+     * with {@linkcode PluginDesignFurnitureApi.listCatalog}. Placement is asynchronous
+     * (the source mesh is fetched if not cached) and creates one undo entry.
+     *
+     * Placed at the item's default rotation unless `angleInDegrees` is given, which
+     * rotates it about the vertical axis at creation time (baked into the same undo
+     * entry). To rotate an existing instance instead, use `design.transform.rotate`.
+     *
+     * @param catalogId - Library id: team `_id` or general `fullName`
+     * @param position - Absolute world placement point. `position.y` is the REST
+     *   elevation: the item is grounded so its bounding-box base sits exactly at
+     *   `position.y` (the same surface-flush contract as interactive drag-drop) —
+     *   pass the floor/storey elevation to stand furniture on it; never add half
+     *   the item's height yourself.
+     * @param options - Optional placement options: `label` — instance name and
+     *   readable label (`design.query.getLabel`; default auto `${name}Ins${n}`);
+     *   `createNewSourceMesh` — legacy flag, kept for compatibility. The host owns
+     *   source-mesh persistence: a catalog source is recorded exactly once, by the
+     *   first placement that brings it in, and this flag cannot skip that record.
+     * @param angleInDegrees - Optional signed rotation about the vertical axis, in
+     *   degrees (same convention as {@linkcode PluginDesignTransformApi.rotate}).
+     *   Applied at creation time so it is part of the placement's single undo entry.
+     *   Default: the item's own (unrotated) orientation.
+     * @returns the {@linkcode ComponentHandle} of the placed furniture instance
+     * @throws if the catalog id is unknown, the source mesh fails to load, or placement fails;
+     *   `PRECONDITION_FAILED` (`details.engineCode: "TOOL_ACTIVE"`) while the interactive
+     *   furniture tool is active — finish or cancel it first
+     *
+     * @examplePrompt Place a chair from the library at this spot
+     * @examplePrompt Add a sofa from the furniture catalog to the living room
+     * @examplePrompt Drop a desk into the scene at 3, 0, 5
+     * @examplePrompt Insert the uploaded bed model in the bedroom
+     * @examplePrompt Put a table from my project library here and name it Table-01
+     * @examplePrompt Place a chair here rotated 90 degrees
+     *
+     * # Example
+     * ```ts
+     * const chair = await snaptrude.design.create.furniture(
+     *   "6620f1a…",             // from design.furniture.listCatalog()
+     *   await snaptrude.core.math.vec3.new(3, 0, 5),
+     *   { label: "Chair-01" },
+     * )
+     * // …placed already turned 90° about the vertical axis:
+     * const turned = await snaptrude.design.create.furniture(
+     *   "6620f1a…",
+     *   await snaptrude.core.math.vec3.new(3, 0, 5),
+     *   undefined,
+     *   90,
+     * )
+     * ```
+     *
+     * @performance For MORE THAN ONE item, call `design.create.furnitureItems(items[])` —
+     *   one host round-trip and ONE undo entry, and a catalog source shared by several
+     *   items is fetched once. Looping this single-item creator is N round-trips.
+     */
+    abstract furniture(catalogId: string, position: Vec3Handle, options?: {
+        label?: string;
+        createNewSourceMesh?: boolean;
+    }, angleInDegrees?: number): PluginApiReturn<ComponentHandle>;
+    /**
+     * Place **many furniture items** in one undoable operation (bulk plural of
+     * {@linkcode furniture}). Each item names a catalog id and an absolute world
+     * position (`position.y` is the REST elevation — the same grounding contract
+     * as the singular creator), with optional label and rotation. A catalog
+     * source shared by several items is fetched and recorded once for the whole
+     * batch, so the host — not the caller — owns source persistence (there is no
+     * per-item `createNewSourceMesh`). Validate-all-or-throw; one command.
+     *
+     * @param items - One {@linkcode PluginCreateFurnitureItem} per instance to
+     *   place (≥1, ≤1000)
+     * @returns the placed instances as {@linkcode ComponentHandle}`[]`, in input order
+     * @throws `VALIDATION` if the items fail the schema (empty array, more than
+     *   1000 items); `HANDLE_INVALID` if a `position` handle is unknown or
+     *   released; `PRECONDITION_FAILED` if a catalog id is unknown, a furniture
+     *   tool is active, or a parametric group is active (exit it first, or place
+     *   items one at a time with `furniture`); `OPERATION_FAILED` if a source
+     *   mesh fails to load or placement fails (nothing is created —
+     *   `details.itemIndex` is the failing item); `METHOD_NOT_PERMITTED` if the plugin may not write.
+     *
+     * @examplePrompt Place all the desks for this office at once
+     * @examplePrompt Furnish every bedroom in one operation
+     * @examplePrompt Bulk place these chairs around the table
+     * @examplePrompt Add the whole furniture layout in a single undo step
+     * @examplePrompt Drop twenty copies of this chair at these positions
+     *
+     * @performance Bulk creator — the whole batch is ONE host round-trip and ONE undo
+     *   entry, and each distinct catalog source loads once. Always prefer this over
+     *   calling `design.create.furniture` in a loop: build the full `items[]` array
+     *   first (all positions and angles up front), then make one call.
+     *
+     * # Example
+     * ```ts
+     * const v = snaptrude.core.math.vec3
+     * const [chair] = await snaptrude.design.furniture.listCatalog()
+     * const placed = await snaptrude.design.create.furnitureItems([
+     *   { catalogId: chair.id, position: await v.new(3, 0, 5), label: "Chair-01" },
+     *   { catalogId: chair.id, position: await v.new(4, 0, 5), angleInDegrees: 90 },
+     *   { catalogId: chair.id, position: await v.new(5, 0, 5), angleInDegrees: 180 },
+     * ])
+     * ```
+     */
+    abstract furnitureItems(items: PluginCreateFurnitureItem[]): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Place a **door** from the catalog into a host wall.
+     *
+     * Identified by a **catalog (library) id** — the team object's stable `_id`
+     * or the general library's `fullName`. Discover ids with
+     * {@linkcode PluginDesignDoorsApi.listCatalog}. The world `position` is
+     * projected onto the host wall's face to locate the opening; the wall is
+     * re-cut and the door hosted in a single undo entry. Placement is
+     * asynchronous (the source mesh is fetched if not cached).
+     *
+     * @param catalogId - Library id: team `_id` or general `fullName`
+     * @param hostWall - The wall to host the door
+     * @param position - World point projected onto the wall to locate the opening
+     * @param options - Optional placement options: `label` — instance name;
+     *   `hinge` — world point near the jamb the door is hinged on (the door is
+     *   reflected along the wall so its hinged jamb is the one nearer this
+     *   point; default the catalog item's authored hinge side)
+     * @param facing - World point on the side of the wall the door swings open
+     *   to (the room it opens into — where the plan symbol draws the swing arc).
+     *   Any point clearly on that side works (e.g. the room's center). Default:
+     *   the engine picks a side (nondeterministic when `position` sits on the
+     *   wall centerline).
+     * @returns the {@linkcode ComponentHandle} of the placed door
+     * @throws if the catalog id is unknown, the host is not a wall, the source
+     *   mesh fails to load, or the projected point falls **outside** the host wall
+     *
+     * @examplePrompt Add a door to this wall here
+     * @examplePrompt Place a sliding door on the selected wall
+     * @examplePrompt Put a door from the catalog at this point on the wall
+     * @examplePrompt Insert the entrance door into this wall
+     * @examplePrompt Add a door to the wall and call it Entry-01
+     * @examplePrompt Add a door that opens into the living room
+     * @examplePrompt Put a door here hinged on the north jamb
+     *
+     * # Example
+     * ```ts
+     * const [wall] = await snaptrude.design.query.listWalls({ isSelected: true })
+     * const [entry] = await snaptrude.design.doors.listCatalog()
+     * const door = await snaptrude.design.create.door(
+     *   entry.id,
+     *   wall,
+     *   await snaptrude.core.math.vec3.new(3, 0, 5),
+     *   { label: "Entry-01" },
+     * )
+     * // …facing a specific side of the wall (pass a point inside that room):
+     * const intoKitchen = await snaptrude.design.create.door(
+     *   entry.id,
+     *   wall,
+     *   await snaptrude.core.math.vec3.new(3, 0, 5),
+     *   undefined,
+     *   await snaptrude.core.math.vec3.new(3, 0, 9),
+     * )
+     * // …and hinged on the jamb nearest a point (here the +x end of the opening):
+     * const hingedRight = await snaptrude.design.create.door(
+     *   entry.id,
+     *   wall,
+     *   await snaptrude.core.math.vec3.new(3, 0, 5),
+     *   { hinge: await snaptrude.core.math.vec3.new(3.5, 0, 5) },
+     *   await snaptrude.core.math.vec3.new(3, 0, 9),
+     * )
+     * ```
+     *
+     * @performance For MORE THAN ONE door, call `design.create.doors(items[])` — one host
+     *   round-trip and ONE undo entry, with each host wall re-cut once per opening inside
+     *   that single call. Looping this single-door creator is N round-trips.
+     */
+    abstract door(catalogId: string, hostWall: ComponentHandle, position: Vec3Handle, options?: {
+        label?: string;
+        hinge?: Vec3Handle;
+    }, facing?: Vec3Handle): PluginApiReturn<ComponentHandle>;
+    /**
+     * Place **many doors** into host walls in one undoable operation (bulk plural
+     * of {@linkcode door}). Each item carries its own catalog id, host wall,
+     * world position, and optional `facing`, `label`, `width` and `height` — the
+     * same fields as a `"door"` {@linkcode PluginDesignCreateOpeningOptions}.
+     * Validate-all-or-throw; one command.
+     *
+     * As with the singular creator, placing an opening **re-cuts its host wall**:
+     * the wall you passed as `hostWall` stops resolving once the call returns.
+     * Several items MAY name the same original wall handle in one call — the host
+     * chains the re-cuts internally — but after the call recover the surviving
+     * wall with `design.query.getHost(opening)`, never by reusing the handle you
+     * passed in.
+     *
+     * @param items - One {@linkcode PluginCreateDoorItem} per door to place
+     *   (≥1, ≤1000)
+     * @returns the placed doors as {@linkcode ComponentHandle}`[]`, in input order
+     * @throws `VALIDATION` if the items fail the schema (empty array, more than
+     *   1000 items, unknown fields, a non-positive `width`/`height`);
+     *   `HANDLE_INVALID` if a `position`, `facing` or `hinge` handle is unknown
+     *   or released; `PRECONDITION_FAILED` if a catalog id is unknown, a `hostWall`
+     *   is not a wall / is locked / is not in the active proposal, the projected
+     *   point falls outside its host wall, or a door tool is active;
+     *   `OPERATION_FAILED` if a source mesh fails to load or placement fails
+     *   (nothing is created — `details.itemIndex` is the failing item);
+     *   `METHOD_NOT_PERMITTED` if the plugin may not write.
+     *
+     * @examplePrompt Add doors to all of these walls at once
+     * @examplePrompt Place a door in every room in one operation
+     * @examplePrompt Bulk add the entrance doors from this schedule
+     * @examplePrompt Put three doors on this wall in a single undo step
+     * @examplePrompt Add all the doors for this floor plan together
+     *
+     * @performance Bulk creator — the whole batch is ONE host round-trip and ONE undo
+     *   entry, and each distinct catalog source loads once. Always prefer this over
+     *   calling `design.create.door` in a loop: build the full `items[]` array first
+     *   (all host walls and points up front), then make one call.
+     *
+     * # Example
+     * ```ts
+     * const v = snaptrude.core.math.vec3
+     * const [wall] = await snaptrude.design.query.listWalls({ isSelected: true })
+     * const [entry] = await snaptrude.design.doors.listCatalog()
+     * const [front, side] = await snaptrude.design.create.doors([
+     *   { catalogId: entry.id, hostWall: wall, position: await v.new(2, 0, 5), label: "D-01" },
+     *   { catalogId: entry.id, hostWall: wall, position: await v.new(6, 0, 5), width: 1.2 },
+     * ])
+     * // `wall` was re-cut twice and no longer resolves — ask the opening for its host:
+     * const currentWall = await snaptrude.design.query.getHost(front)
+     * ```
+     */
+    abstract doors(items: PluginCreateDoorItem[]): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Place a **window** from the catalog into a host wall.
+     *
+     * Identified by a **catalog (library) id** — the team object's stable `_id`
+     * or the general library's `fullName`. Discover ids with
+     * {@linkcode PluginDesignWindowsApi.listCatalog}. The world `position` is
+     * projected onto the host wall's face to locate the opening; the wall is
+     * re-cut and the window hosted in a single undo entry. Placement is
+     * asynchronous (the source mesh is fetched if not cached).
+     *
+     * @param catalogId - Library id: team `_id` or general `fullName`
+     * @param hostWall - The wall to host the window
+     * @param position - World point projected onto the wall to locate the opening
+     * @param options - Optional placement options: `label` — instance name;
+     *   `hinge` — world point near the jamb the window is hinged on (same rule
+     *   as {@linkcode PluginDesignCreateApi.door}; default the catalog item's
+     *   authored side)
+     * @param facing - World point on the side of the wall the window opens to
+     *   (matters for asymmetric windows, e.g. casement swing) — same convention
+     *   as {@linkcode PluginDesignCreateApi.door}. Default: the engine picks a
+     *   side (nondeterministic when `position` sits on the centerline).
+     * @returns the {@linkcode ComponentHandle} of the placed window
+     * @throws if the catalog id is unknown, the host is not a wall, the source
+     *   mesh fails to load, or the projected point falls **outside** the host wall
+     *
+     * @examplePrompt Add a window to this wall here
+     * @examplePrompt Place a casement window on the selected wall
+     * @examplePrompt Put a window from the catalog at this point on the wall
+     * @examplePrompt Insert a window into the living room wall
+     * @examplePrompt Add a window to the wall and name it Win-01
+     * @examplePrompt Add a casement window opening toward the garden side
+     *
+     * # Example
+     * ```ts
+     * const [wall] = await snaptrude.design.query.listWalls({ isSelected: true })
+     * const [entry] = await snaptrude.design.windows.listCatalog()
+     * const window = await snaptrude.design.create.window(
+     *   entry.id,
+     *   wall,
+     *   await snaptrude.core.math.vec3.new(3, 0, 5),
+     *   { label: "Win-01" },
+     * )
+     * ```
+     *
+     * @performance For MORE THAN ONE window, call `design.create.windows(items[])` — one
+     *   host round-trip and ONE undo entry, with each host wall re-cut once per opening
+     *   inside that single call. Looping this single-window creator is N round-trips.
+     */
+    abstract window(catalogId: string, hostWall: ComponentHandle, position: Vec3Handle, options?: {
+        label?: string;
+        hinge?: Vec3Handle;
+    }, facing?: Vec3Handle): PluginApiReturn<ComponentHandle>;
+    /**
+     * Place **many windows** into host walls in one undoable operation (bulk
+     * plural of {@linkcode window}). Each item carries its own catalog id, host
+     * wall, world position, and optional `facing`, `label`, `width`, `height` and
+     * `sillHeight` — the same fields as a `"window"`
+     * {@linkcode PluginDesignCreateOpeningOptions}. `sillHeight` is measured from
+     * the host wall base to the BOTTOM of the window. Validate-all-or-throw; one
+     * command.
+     *
+     * As with the singular creator, placing an opening **re-cuts its host wall**:
+     * the wall you passed as `hostWall` stops resolving once the call returns.
+     * Several items MAY name the same original wall handle in one call — the host
+     * chains the re-cuts internally — but after the call recover the surviving
+     * wall with `design.query.getHost(opening)`, never by reusing the handle you
+     * passed in.
+     *
+     * @param items - One {@linkcode PluginCreateWindowItem} per window to place
+     *   (≥1, ≤1000)
+     * @returns the placed windows as {@linkcode ComponentHandle}`[]`, in input order
+     * @throws `VALIDATION` if the items fail the schema (empty array, more than
+     *   1000 items, unknown fields, a non-positive `width`/`height`, a negative
+     *   `sillHeight`); `HANDLE_INVALID` if a `position`, `facing` or `hinge`
+     *   handle is unknown or released; `PRECONDITION_FAILED` if a catalog id is unknown, a
+     *   `hostWall` is not a wall / is locked / is not in the active proposal, the
+     *   projected point falls outside its host wall, or a window tool is active;
+     *   `OPERATION_FAILED` if a source mesh fails to load or placement fails
+     *   (nothing is created — `details.itemIndex` is the failing item);
+     *   `METHOD_NOT_PERMITTED` if the plugin may not write.
+     *
+     * @examplePrompt Add windows along this whole facade at once
+     * @examplePrompt Place a window in every bedroom in one operation
+     * @examplePrompt Bulk add the windows from this schedule
+     * @examplePrompt Put four windows on this wall in a single undo step
+     * @examplePrompt Add all the windows with a 0.9m sill height together
+     *
+     * @performance Bulk creator — the whole batch is ONE host round-trip and ONE undo
+     *   entry, and each distinct catalog source loads once. Always prefer this over
+     *   calling `design.create.window` in a loop: build the full `items[]` array first
+     *   (all host walls and points up front), then make one call.
+     *
+     * # Example
+     * ```ts
+     * const v = snaptrude.core.math.vec3
+     * const [wall] = await snaptrude.design.query.listWalls({ isSelected: true })
+     * const [casement] = await snaptrude.design.windows.listCatalog()
+     * const placed = await snaptrude.design.create.windows([
+     *   { catalogId: casement.id, hostWall: wall, position: await v.new(2, 0, 5), sillHeight: 0.9 },
+     *   { catalogId: casement.id, hostWall: wall, position: await v.new(5, 0, 5), sillHeight: 0.9 },
+     * ])
+     * const currentWall = await snaptrude.design.query.getHost(placed[0])
+     * ```
+     */
+    abstract windows(items: PluginCreateWindowItem[]): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Place a catalog **door or window** into a host wall with optional size overrides.
+     *
+     * The world `position` is projected onto the host wall to locate the opening.
+     * All supplied dimensions use Snaptrude engine units. Window `sillHeight` is
+     * measured from the host wall base to the bottom of the window, not to
+     * its center. Placement is asynchronous and committed as one undoable creation.
+     *
+     * @param options - Opening kind, catalog and host references, placement, and
+     *   optional facing (swing side), hinge (hinged jamb), label, and dimensions
+     * @returns the {@linkcode ComponentHandle} of the placed door or window
+     * @throws if the options are invalid, the catalog id is unknown, the host is
+     *   not a wall, loading fails, or the opening cannot be placed on the host
+     *
+     * @examplePrompt Add a 1m wide door to this wall here
+     * @examplePrompt Place a window with a 0.9m sill height on the selected wall
+     *
+     * @performance Single-opening creator — use it for one hosted opening. For MORE
+     *   THAN ONE, call `design.create.doors(items[])` / `design.create.windows(items[])`:
+     *   the same per-item fields, one host round-trip, ONE undo entry.
+     *
+     * # Example
+     * ```ts
+     * const opening = await snaptrude.design.create.opening({
+     *   kind: "window",
+     *   catalogId: windowType.id,
+     *   hostWall: wall,
+     *   position: await snaptrude.core.math.vec3.new(3, 0, 5),
+     *   width: 1.2,
+     *   height: 1.5,
+     *   sillHeight: 0.9,
+     * })
+     * ```
+     */
+    abstract opening(options: PluginDesignCreateOpeningOptions): PluginApiReturn<ComponentHandle>;
+    /**
+     * Place a **smart layout** — clone an in-scene template cluster (walls,
+     * furniture, doors, windows, floors) into one or more target ROOM/DEPARTMENT
+     * spaces, adapting orientation and fit to each target.
+     *
+     * Supply the template as **exactly one** of `templateGroup` (a group **id**
+     * from `snaptrude.core.groups.list` — groups are string-id entities, not
+     * component handles) or
+     * `templateComponents` (an explicit component set); every target in `targets`
+     * (≥1) receives its own placement. By default the target spaces are hidden
+     * after placement (`hideTargets`, mirroring the product) — pass `false` to keep
+     * them visible.
+     *
+     * The whole operation — every wall/opening/furniture/floor across every target,
+     * plus the target-hide — is committed as a **single undo step**. Because all
+     * targets merge into one creation batch, the created entities are returned
+     * **flat, grouped by kind** ({@linkcode PluginSmartLayoutResult}), NOT attributed
+     * per target (per-target attribution would break the single-undo guarantee).
+     * `skippedWalls` is the interior-optimizer's best-candidate count of walls it
+     * could not place. Synchronous and heavy — many targets can jank the main thread.
+     *
+     * @param options - {@linkcode PluginSmartLayoutArgs}: template source, targets, and `hideTargets`
+     * @returns a {@linkcode PluginSmartLayoutResult} — created entities grouped by kind + `skippedWalls`
+     * @throws if smart layout is not enabled, the template group is invalid, there
+     *   is no template / no targets / no valid mappings, or component creation fails
+     *
+     * @examplePrompt Copy this room's layout into the selected rooms
+     * @examplePrompt Apply this furniture arrangement to the other offices
+     * @examplePrompt Replicate this template into these two spaces
+     * @examplePrompt Place this desk cluster into every meeting room
+     * @examplePrompt Use this room as a template for the rooms I selected but keep them visible
+     *
+     * # Example
+     * ```ts
+     * const [templateRoom, ...targets] = await snaptrude.design.query.listSpaces({ isSelected: true })
+     * const result = await snaptrude.design.create.smartLayout({
+     *   templateComponents: [templateRoom],
+     *   targets,
+     * })
+     * console.log("placed walls:", result.created.walls.length, "skipped:", result.skippedWalls)
+     *
+     * // …or clone a saved group by its id (from core.groups.list)
+     * const { groups } = await snaptrude.core.groups.list()
+     * await snaptrude.design.create.smartLayout({ templateGroup: groups[0].id, targets })
+     * ```
+     */
+    abstract smartLayout(options: PluginSmartLayoutArgs): PluginApiReturn<PluginSmartLayoutResult>;
+    /**
+     * **Copy** existing entities, offsetting each copy by `displacement * i` (i = 1…count),
+     * source positions preserved. Migrated from the removed `tools.copy`. In `"instance"`
+     * mode copies stay in the source's instance family where possible; `"unique"` makes
+     * independent geometry. The created copies become the active selection. Undoable.
+     *
+     * Runs on the engine's array-copy tool, so its semantics carry over: an
+     * `"instance"` copy of a source that is not yet an instance **replaces that
+     * source** with a fresh instance component — the handle you passed in stops
+     * resolving after the call. Re-query (e.g. `design.query.listSpaces`) to pick
+     * up the replacement before operating on that entity again; copying the stale
+     * handle throws. `"unique"` mode never replaces sources.
+     *
+     * @param components - Entities to copy (≥1)
+     * @param displacement - Per-copy offset as a {@linkcode Vec3Handle} (copy `i` at `displacement * i`)
+     * @param options - `count` (copies per component, default 1), `mode` (`"instance"` | `"unique"`, default `"instance"`)
+     * @returns the created copies as {@linkcode ComponentHandle}`[]`
+     * @throws if a component handle is unknown or stale (replaced by an earlier
+     *   `"instance"` copy), `count` is not a positive integer, or the engine fails
+     *
+     * @examplePrompt Copy this room 3 times spaced 6m apart
+     * @examplePrompt Duplicate the selected furniture along the X axis
+     * @examplePrompt Make 5 copies of this column at 4 metre intervals
+     * @examplePrompt Array these walls with a 3m offset
+     * @examplePrompt Clone the desk as a unique copy, not an instance
+     *
+     * @performance To place N repeats of the same geometry, bulk-create the seed(s) once then
+     *   call this ONCE with `{ count: N - 1 }` — one host round-trip for all copies. Never
+     *   reproduce geometry by looping `design.create.*` N times. Copy only after the create
+     *   that mints the seed ids.
+     *
+     * # Example
+     * ```ts
+     * const { vec3 } = snaptrude.core.math
+     * const copies = await snaptrude.design.create.copy(["space-id"], vec3.new(6, 0, 0), { count: 3 })
+     * ```
+     */
+    abstract copy(components: ComponentHandle[], displacement: Vec3Handle, options?: {
+        count?: number;
+        mode?: PluginCopyMode;
+    }): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Create **many spaces** in one undoable operation (bulk plural of {@linkcode space}).
+     * Migrated from the removed `entity.space.bulkCreate`. Each item extrudes a contour
+     * footprint up `height`. Validate-all-or-throw; one command. For a rectangular
+     * (box) space, build the footprint with `core.geom.create.profileRect` →
+     * `contourFromProfile`, then pass it as an item. Each item may carry its own
+     * `storey` (see {@linkcode PluginCreateSpaceItem}) so a single call can populate
+     * several floors at once.
+     *
+     * @param items - One {@linkcode PluginCreateSpaceItem} per space to create (≥1)
+     * @returns the created spaces as {@linkcode ComponentHandle}`[]`, in input order
+     * @throws if any item's contour is invalid, its height is not positive, or its
+     *   target `storey` does not exist (all-or-nothing — nothing is created)
+     *
+     * @examplePrompt Create several rooms at once from these footprints
+     * @examplePrompt Generate all the bedrooms in one operation
+     * @examplePrompt Bulk create the spaces for this floor plan
+     * @examplePrompt Add three rooms with different heights in a single undo step
+     * @examplePrompt Create one room on the ground floor and one on the first floor
+     *
+     * @performance Bulk creator — the whole batch is ONE host round-trip. Always prefer this
+     *   over calling `design.create.space` in a loop: build the full `items[]` array first
+     *   (all per-item math and geometry up front), then make one call.
+     *
+     * # Example
+     * ```ts
+     * const rect = await snaptrude.core.geom.create.profileRect(4, 3)
+     * const contour = await snaptrude.core.geom.create.contourFromProfile(rect)
+     * const [a, b] = await snaptrude.design.create.spaces([
+     *   { contour, height: 3, label: "R1" },
+     *   { contour, height: 4, label: "R2", position: await vec3.new(10, 0, 0) },
+     * ])
+     * ```
+     */
+    abstract spaces(items: PluginCreateSpaceItem[]): PluginApiReturn<ComponentHandle[]>;
+    /**
+     * Create a new parametric buildable envelope — the zoning-regulated volume a
+     * building may occupy — generated from a site polygon, tiered setbacks, a
+     * height or floor-count cap, and optional FAR and lot-coverage limits. The host
+     * mints the envelope id and returns it. Canonical home of the create formerly
+     * at `entity.buildableEnvelope.create` (now deprecated).
+     *
+     * @param sitePolygon - Site polygon vertices in `lengthUnit`; minimum 3 vertices.
+     * @param lengthUnit - Unit used by all length fields (`"ft" | "m"`).
+     * @param setbacks - Setback profile, ground tier first; minimum 1 tier.
+     * @param verticalCap - Maximum height or floor count.
+     * @param floorToFloor - Required floor-to-floor height in `lengthUnit`.
+     * @param farRatio - Optional FAR value, positive when provided.
+     * @param lotCoverageMaxPct - Optional lot coverage cap, `0..100`.
+     * @returns A {@linkcode PluginBuildableEnvelopeCreateResult} with the
+     *   `buildableEnvelopeId` of the created envelope.
+     * @throws If validation fails or generation produces no renderable geometry.
+     *
+     * @examplePrompt Create a buildable envelope for my site
+     * @examplePrompt Generate the zoning envelope with 10ft front setbacks
+     * @examplePrompt Show the maximum buildable volume with a 150ft height limit
+     * @examplePrompt Create a zoning envelope capped at 12 floors with FAR 3
+     *
+     * # Example
+     * ```ts
+     * const { buildableEnvelopeId } = await snaptrude.design.create.buildableEnvelope(
+     *   [
+     *     { x: 0, z: 0 },
+     *     { x: 100, z: 0 },
+     *     { x: 100, z: 80 },
+     *     { x: 0, z: 80 },
+     *   ],
+     *   "ft",
+     *   [
+     *     { aboveHeight: 0, front: 10, side: 5, rear: 10 },
+     *     { aboveHeight: 100, front: 20, side: 10, rear: 20 },
+     *   ],
+     *   { kind: "max_height", maxHeight: 150 },
+     *   12,
+     * )
+     * ```
+     */
+    abstract buildableEnvelope(sitePolygon: PluginBuildableEnvelopePolygonVertex[], lengthUnit: "ft" | "m", setbacks: PluginBuildableEnvelopeSetbackTier[], verticalCap: PluginBuildableEnvelopeVerticalCap, floorToFloor: number, farRatio?: number, lotCoverageMaxPct?: number): PluginApiReturn<PluginBuildableEnvelopeCreateResult>;
+}
+/**
+ * Line style of a reference line (mirrors the engine `ReferenceLineMode` verbatim).
+ *
+ * | Value | Description |
+ * |---|---|
+ * | `"SOLID"` | Solid line (default) |
+ * | `"DASHED"` | Dashed line |
+ * | `"DOT_DASH"` | Dot-dash line |
+ */
+export declare const PluginReferenceLineStyle: z.ZodEnum<{
+    SOLID: "SOLID";
+    DASHED: "DASHED";
+    DOT_DASH: "DOT_DASH";
+}>;
+export type PluginReferenceLineStyle = z.infer<typeof PluginReferenceLineStyle>;
+/**
+ * Slab type (mirrors the engine `SLAB_TYPES` values verbatim).
+ *
+ * | Value | Description |
+ * |---|---|
+ * | `"Intermediate Slab"` | Intermediate floor slab (default) |
+ * | `"Basement Slab"` | Basement slab |
+ * | `"Plinth"` | Plinth slab |
+ * | `"Roof"` | Roof slab |
+ */
+export declare const PluginSlabType: z.ZodEnum<{
+    Plinth: "Plinth";
+    "Intermediate Slab": "Intermediate Slab";
+    "Basement Slab": "Basement Slab";
+    Roof: "Roof";
+}>;
+export type PluginSlabType = z.infer<typeof PluginSlabType>;
+/**
+ * A staircase preset — a base type or a named parametric preset. Mirrors the
+ * engine `STAIRCASE_PRESETS` / `StaircaseType`. Use the value that matches the
+ * shape you want (e.g. `"straight"`, `"dogLegged"`, `"lShaped"`).
+ */
+export declare const PluginStaircasePreset: z.ZodEnum<{
+    custom: "custom";
+    straight: "straight";
+    straightWoLanding: "straightWoLanding";
+    straightFlightWoMidLanding: "straightFlightWoMidLanding";
+    dogLegged: "dogLegged";
+    openWell: "openWell";
+    lShaped: "lShaped";
+    "3StepLShaped": "3StepLShaped";
+    square: "square";
+    singleStep: "singleStep";
+    plinthLevel: "plinthLevel";
+    amphitheatre: "amphitheatre";
+    connectingStepsToAmphitheatre: "connectingStepsToAmphitheatre";
+    mezzanineFloorStraight: "mezzanineFloorStraight";
+    mezzanineFloorDogLegged: "mezzanineFloorDogLegged";
+    mezzanineFloorLShaped: "mezzanineFloorLShaped";
+}>;
+export type PluginStaircasePreset = z.infer<typeof PluginStaircasePreset>;
+/**
+ * Optional staircase dimension overrides. Lengths use Snaptrude engine units
+ * and must be positive. `angleInDegrees` controls placement about the vertical
+ * axis and must be a multiple of 90 degrees.
+ */
+export declare const PluginStaircaseDimensions: z.ZodObject<{
+    width: z.ZodOptional<z.ZodNumber>;
+    tread: z.ZodOptional<z.ZodNumber>;
+    riser: z.ZodOptional<z.ZodNumber>;
+    landingWidth: z.ZodOptional<z.ZodNumber>;
+    angleInDegrees: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type PluginStaircaseDimensions = z.infer<typeof PluginStaircaseDimensions>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.space}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | Bottom footprint (outer + holes) |
+ * | `height` | `number` | Extrusion height (Snaptrude units, > 0) |
+ * | `label` | `string`? | Room label (maps to the space's `room_type`) |
+ * | `position` | {@linkcode Vec3Handle}? | Offset from origin (default origin) |
+ * | `spaceType` | {@linkcode PluginSpaceType}? | Space-type classification (default `Room`) |
+ * | `massType` | {@linkcode PluginMassType}? | Mass-type classification (default `Room`) |
+ * | `departmentId` | {@linkcode PluginDepartmentId}? | Department assignment (default department) |
+ * | `storey` | `number`? (int) | Target storey number (default active storey) |
+ */
+export declare const PluginDesignCreateSpaceArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    height: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    spaceType: z.ZodOptional<z.ZodEnum<{
+        Room: "Room";
+        "Program Block": "Program Block";
+        Balcony: "Balcony";
+        Road: "Road";
+        Garden: "Garden";
+        Deck: "Deck";
+        Pool: "Pool";
+        Walkway: "Walkway";
+        Envelope: "Envelope";
+        Parking: "Parking";
+    }>>;
+    massType: z.ZodOptional<z.ZodEnum<{
+        Room: "Room";
+        Plinth: "Plinth";
+        Void: "Void";
+        Pergola: "Pergola";
+        Furniture: "Furniture";
+        "Facade element": "Facade element";
+        "Generic mass": "Generic mass";
+        Department: "Department";
+        Building: "Building";
+        "Revit Import": "Revit Import";
+        Mass: "Mass";
+        Site: "Site";
+    }>>;
+    departmentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        DEFAULT: "DEFAULT";
+        SITE: "SITE";
+        ENVELOPE: "ENVELOPE";
+        CORE: "CORE";
+    }>, z.ZodUUID]>>;
+    storey: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginDesignCreateSpaceArgs = z.infer<typeof PluginDesignCreateSpaceArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.mass}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | Footprint (outer + holes) |
+ * | `height` | `number` | Extrusion height (> 0) |
+ * | `label` | `string`? | Label (maps to `room_type`) |
+ * | `position` | {@linkcode Vec3Handle}? | Offset from origin |
+ * | `massType` | {@linkcode PluginMassType}? | Mass type (default `Generic mass`) |
+ */
+export declare const PluginDesignCreateMassArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    height: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    massType: z.ZodOptional<z.ZodEnum<{
+        Room: "Room";
+        Plinth: "Plinth";
+        Void: "Void";
+        Pergola: "Pergola";
+        Furniture: "Furniture";
+        "Facade element": "Facade element";
+        "Generic mass": "Generic mass";
+        Department: "Department";
+        Building: "Building";
+        "Revit Import": "Revit Import";
+        Mass: "Mass";
+        Site: "Site";
+    }>>;
+}, z.core.$strip>;
+export type PluginDesignCreateMassArgs = z.infer<typeof PluginDesignCreateMassArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.massFromBrep}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `brep` | {@linkcode BrepHandle} | A solid from a `core.geom.create` brep constructor |
+ * | `label` | `string`? | Label (maps to `room_type`) |
+ */
+export declare const PluginDesignCreateMassFromBrepArgs: z.ZodObject<{
+    brep: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"brep">, string>>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PluginDesignCreateMassFromBrepArgs = z.infer<typeof PluginDesignCreateMassFromBrepArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.slab}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | Footprint (outer + holes) |
+ * | `thickness` | `number` | Slab thickness (> 0) |
+ * | `direction` | `"up" \| "down"`? | Extrusion direction (default `"down"`) |
+ * | `slabType` | {@linkcode PluginSlabType}? | Slab-type classification |
+ */
+export declare const PluginDesignCreateSlabArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    thickness: z.ZodNumber;
+    direction: z.ZodOptional<z.ZodEnum<{
+        up: "up";
+        down: "down";
+    }>>;
+    slabType: z.ZodOptional<z.ZodEnum<{
+        Plinth: "Plinth";
+        "Intermediate Slab": "Intermediate Slab";
+        "Basement Slab": "Basement Slab";
+        Roof: "Roof";
+    }>>;
+}, z.core.$strip>;
+export type PluginDesignCreateSlabArgs = z.infer<typeof PluginDesignCreateSlabArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.floor}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | Footprint (outer + holes) |
+ * | `thickness` | `number` | Floor thickness (> 0) |
+ * | `position` | {@linkcode Vec3Handle}? | Offset from origin |
+ */
+export declare const PluginDesignCreateFloorArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    thickness: z.ZodNumber;
+    position: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginDesignCreateFloorArgs = z.infer<typeof PluginDesignCreateFloorArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.roof}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | Footprint (outer + holes) |
+ * | `thickness` | `number` | Roof-slab thickness (> 0) |
+ */
+export declare const PluginDesignCreateRoofArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    thickness: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginDesignCreateRoofArgs = z.infer<typeof PluginDesignCreateRoofArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.ceiling}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | Footprint (outer + holes) |
+ * | `thickness` | `number` | Ceiling thickness (> 0) |
+ * | `heightFromFloor` | `number`? | Lift above the floor (default 0) |
+ */
+export declare const PluginDesignCreateCeilingArgs: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    thickness: z.ZodNumber;
+    heightFromFloor: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginDesignCreateCeilingArgs = z.infer<typeof PluginDesignCreateCeilingArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.column}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `position` | {@linkcode Vec3Handle} | Base point |
+ * | `crossSection` | {@linkcode ContourHandle} | Column cross-section footprint |
+ * | `height` | `number` | Column height (> 0) |
+ * | `directionUp` | {@linkcode Vec3Handle}? | Up axis (default world up) |
+ */
+export declare const PluginDesignCreateColumnArgs: z.ZodObject<{
+    position: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    crossSection: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    height: z.ZodNumber;
+    directionUp: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginDesignCreateColumnArgs = z.infer<typeof PluginDesignCreateColumnArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.beam}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `section` | {@linkcode ContourHandle} | Beam cross-section footprint |
+ * | `length` | `number` | Beam length along `direction` (> 0) |
+ * | `direction` | {@linkcode Vec3Handle}? | Extrusion axis (default world up) |
+ */
+export declare const PluginDesignCreateBeamArgs: z.ZodObject<{
+    section: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    length: z.ZodNumber;
+    direction: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginDesignCreateBeamArgs = z.infer<typeof PluginDesignCreateBeamArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.walls}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | Ordered curve chain (wall centerlines) |
+ * | `height` | `number`? | Wall height (default engine default) |
+ * | `thickness` | `number`? | Wall thickness (default: `wallType`'s total layer thickness when given, else engine default) |
+ * | `wallType` | `string`? | Wall type name from `design.types.list("wall")` — layers/material/thickness defaults (default generic) |
+ * | `storey` | `number`? | Target storey (integer, must exist) — walls assigned + lifted to its base in the same undo entry (default: geometry-derived) |
+ */
+export declare const PluginDesignCreateWallsArgs: z.ZodObject<{
+    profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"profile">, string>>;
+    height: z.ZodOptional<z.ZodNumber>;
+    thickness: z.ZodOptional<z.ZodNumber>;
+    wallType: z.ZodOptional<z.ZodString>;
+    storey: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginDesignCreateWallsArgs = z.infer<typeof PluginDesignCreateWallsArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.staircase}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `preset` | {@linkcode PluginStaircasePreset} | The parametric preset to generate |
+ * | `position` | {@linkcode Vec3Handle} | Placement point |
+ * | `label` | `string`? | Optional label |
+ * | `structureId` | `string`? | Target structure (default active) |
+ * | `level` | `string`? | Target level name (default active/`"01"`) |
+ * | `dimensions` | {@linkcode PluginStaircaseDimensions}? | Positive dimension overrides in engine units, applied before creation |
+ */
+export declare const PluginDesignCreateStaircaseArgs: z.ZodObject<{
+    preset: z.ZodEnum<{
+        custom: "custom";
+        straight: "straight";
+        straightWoLanding: "straightWoLanding";
+        straightFlightWoMidLanding: "straightFlightWoMidLanding";
+        dogLegged: "dogLegged";
+        openWell: "openWell";
+        lShaped: "lShaped";
+        "3StepLShaped": "3StepLShaped";
+        square: "square";
+        singleStep: "singleStep";
+        plinthLevel: "plinthLevel";
+        amphitheatre: "amphitheatre";
+        connectingStepsToAmphitheatre: "connectingStepsToAmphitheatre";
+        mezzanineFloorStraight: "mezzanineFloorStraight";
+        mezzanineFloorDogLegged: "mezzanineFloorDogLegged";
+        mezzanineFloorLShaped: "mezzanineFloorLShaped";
+    }>;
+    position: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    label: z.ZodOptional<z.ZodString>;
+    structureId: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodString>;
+    dimensions: z.ZodOptional<z.ZodObject<{
+        width: z.ZodOptional<z.ZodNumber>;
+        tread: z.ZodOptional<z.ZodNumber>;
+        riser: z.ZodOptional<z.ZodNumber>;
+        landingWidth: z.ZodOptional<z.ZodNumber>;
+        angleInDegrees: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type PluginDesignCreateStaircaseArgs = z.infer<typeof PluginDesignCreateStaircaseArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.furniture}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `catalogId` | `string` | Library id: team `_id` or general `fullName` |
+ * | `position` | {@linkcode Vec3Handle} | Absolute world placement point |
+ * | `label` | `string`? | Instance name (default auto `${name}Ins${n}`) |
+ * | `createNewSourceMesh` | `boolean`? | Legacy, kept for compatibility; the host records a catalog source exactly once and this flag cannot skip it |
+ * | `angleInDegrees` | `number`? | Rotation about the vertical axis, in degrees (default unrotated) |
+ */
+export declare const PluginDesignCreateFurnitureArgs: z.ZodObject<{
+    catalogId: z.ZodString;
+    position: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    label: z.ZodOptional<z.ZodString>;
+    createNewSourceMesh: z.ZodOptional<z.ZodBoolean>;
+    angleInDegrees: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginDesignCreateFurnitureArgs = z.infer<typeof PluginDesignCreateFurnitureArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.door}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `catalogId` | `string` | Library id: team `_id` or general `fullName` |
+ * | `hostWall` | {@linkcode ComponentHandle} | The wall to host the door |
+ * | `position` | {@linkcode Vec3Handle} | World point projected onto the wall |
+ * | `label` | `string`? | Instance name (optional) |
+ * | `facing` | {@linkcode Vec3Handle}? | World point on the side of the wall the door swings open to (default engine-chosen) |
+ * | `hinge` | {@linkcode Vec3Handle}? | World point near the jamb the door is hinged on (default the catalog item's authored side) |
+ */
+export declare const PluginDesignCreateDoorArgs: z.ZodObject<{
+    catalogId: z.ZodString;
+    hostWall: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    position: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    label: z.ZodOptional<z.ZodString>;
+    facing: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    hinge: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginDesignCreateDoorArgs = z.infer<typeof PluginDesignCreateDoorArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.window}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `catalogId` | `string` | Library id: team `_id` or general `fullName` |
+ * | `hostWall` | {@linkcode ComponentHandle} | The wall to host the window |
+ * | `position` | {@linkcode Vec3Handle} | World point projected onto the wall |
+ * | `label` | `string`? | Instance name (optional) |
+ * | `facing` | {@linkcode Vec3Handle}? | World point on the side of the wall the window opens to (default engine-chosen) |
+ * | `hinge` | {@linkcode Vec3Handle}? | World point near the jamb the window is hinged on (default the catalog item's authored side) |
+ */
+export declare const PluginDesignCreateWindowArgs: z.ZodObject<{
+    catalogId: z.ZodString;
+    hostWall: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    position: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    label: z.ZodOptional<z.ZodString>;
+    facing: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    hinge: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginDesignCreateWindowArgs = z.infer<typeof PluginDesignCreateWindowArgs>;
+/**
+ * Options for {@linkcode PluginDesignCreateApi.opening}, discriminated by
+ * `kind`. Width and height are positive Snaptrude engine-unit values.
+ * `sillHeight` is available only for windows, is nonnegative, and is precisely
+ * the distance from the host wall base to the bottom of the window.
+ */
+export declare const PluginDesignCreateOpeningOptions: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    catalogId: z.ZodString;
+    hostWall: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    position: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    facing: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    hinge: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    label: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"door">;
+}, z.core.$strict>, z.ZodObject<{
+    sillHeight: z.ZodOptional<z.ZodNumber>;
+    catalogId: z.ZodString;
+    hostWall: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    position: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    facing: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    hinge: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    label: z.ZodOptional<z.ZodString>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"window">;
+}, z.core.$strict>], "kind">;
+export type PluginDesignCreateOpeningOptions = z.infer<typeof PluginDesignCreateOpeningOptions>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.smartLayout}. Provide **exactly
+ * one** template source: `templateGroup` or a non-empty `templateComponents`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `templateGroup` | `string`? | Id of the group to clone as the template (a group id from `snaptrude.core.groups.list`, NOT a component handle) |
+ * | `templateComponents` | {@linkcode ComponentHandle}`[]`? | Explicit component set to clone as the template |
+ * | `targets` | {@linkcode ComponentHandle}`[]` | ROOM/DEPARTMENT spaces to place into (≥1) |
+ * | `hideTargets` | `boolean`? | Hide the target spaces after placement (default `true`) |
+ */
+export declare const PluginSmartLayoutArgs: z.ZodObject<{
+    templateGroup: z.ZodOptional<z.ZodString>;
+    templateComponents: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>>;
+    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    hideTargets: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PluginSmartLayoutArgs = z.infer<typeof PluginSmartLayoutArgs>;
+/**
+ * Result of {@linkcode PluginDesignCreateApi.smartLayout} — the entities the run
+ * created, grouped by kind (flat across all targets; see the method JSDoc for why
+ * this is not attributed per target).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `created.walls` | {@linkcode ComponentHandle}`[]` | Created walls |
+ * | `created.furniture` | {@linkcode ComponentHandle}`[]` | Created furniture |
+ * | `created.doors` | {@linkcode ComponentHandle}`[]` | Created doors |
+ * | `created.windows` | {@linkcode ComponentHandle}`[]` | Created windows |
+ * | `created.floors` | {@linkcode ComponentHandle}`[]` | Created floors |
+ * | `skippedWalls` | `number` | Walls the interior optimizer could not place |
+ */
+export declare const PluginSmartLayoutResult: z.ZodObject<{
+    created: z.ZodObject<{
+        walls: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+        furniture: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+        doors: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+        windows: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+        floors: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    }, z.core.$strip>;
+    skippedWalls: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginSmartLayoutResult = z.infer<typeof PluginSmartLayoutResult>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.referenceLines}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | Ordered curve chain (centerlines) |
+ * | `color` | `string`? | Hex color `"#RRGGBB"` (default white) |
+ * | `thickness` | `number`? | Line thickness (default 1) |
+ * | `style` | {@linkcode PluginReferenceLineStyle}? | Line style (default `SOLID`) |
+ * | `gridTag` | `string`? | Grid tag label (default `"A"`) |
+ */
+export declare const PluginDesignCreateReferenceLinesArgs: z.ZodObject<{
+    profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"profile">, string>>;
+    color: z.ZodOptional<z.ZodString>;
+    thickness: z.ZodOptional<z.ZodNumber>;
+    style: z.ZodOptional<z.ZodEnum<{
+        SOLID: "SOLID";
+        DASHED: "DASHED";
+        DOT_DASH: "DOT_DASH";
+    }>>;
+    gridTag: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PluginDesignCreateReferenceLinesArgs = z.infer<typeof PluginDesignCreateReferenceLinesArgs>;
+/**
+ * Copy mode for {@linkcode PluginDesignCreateApi.copy}.
+ *
+ * | Value | Description |
+ * |---|---|
+ * | `"instance"` | Keep copies in the source's instance family where possible |
+ * | `"unique"` | Independent geometry copies |
+ */
+export declare const PluginCopyMode: z.ZodEnum<{
+    unique: "unique";
+    instance: "instance";
+}>;
+export type PluginCopyMode = z.infer<typeof PluginCopyMode>;
+/**
+ * Arguments for {@linkcode PluginDesignCreateApi.copy} (options flattened).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `components` | {@linkcode ComponentHandle}`[]` | Entities to copy (≥1) |
+ * | `displacement` | {@linkcode Vec3Handle} | Per-copy offset (copy `i` at `displacement * i`) |
+ * | `count` | `number`? | Copies per component (default 1) |
+ * | `mode` | {@linkcode PluginCopyMode}? | `"instance"` (default) or `"unique"` |
+ */
+export declare const PluginDesignCreateCopyArgs: z.ZodObject<{
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    displacement: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    count: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        unique: "unique";
+        instance: "instance";
+    }>>;
+}, z.core.$strip>;
+export type PluginDesignCreateCopyArgs = z.infer<typeof PluginDesignCreateCopyArgs>;
+/**
+ * One space to create via {@linkcode PluginDesignCreateApi.spaces} — the same
+ * footprint-extrude inputs as {@linkcode PluginDesignCreateApi.space}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `contour` | {@linkcode ContourHandle} | Footprint (outer profile + holes) |
+ * | `height` | `number` | Extrude height |
+ * | `label` | `string`? | Room label |
+ * | `position` | {@linkcode Vec3Handle}? | Placement offset |
+ * | `spaceType` | `PluginSpaceType`? | Space type |
+ * | `massType` | `PluginMassType`? | Mass type |
+ * | `departmentId` | `PluginDepartmentId`? | Department |
+ * | `storey` | `number`? (int) | Target storey number (default active storey) |
+ */
+export declare const PluginCreateSpaceItem: z.ZodObject<{
+    contour: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"contour">, string>>;
+    height: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    spaceType: z.ZodOptional<z.ZodEnum<{
+        Room: "Room";
+        "Program Block": "Program Block";
+        Balcony: "Balcony";
+        Road: "Road";
+        Garden: "Garden";
+        Deck: "Deck";
+        Pool: "Pool";
+        Walkway: "Walkway";
+        Envelope: "Envelope";
+        Parking: "Parking";
+    }>>;
+    massType: z.ZodOptional<z.ZodEnum<{
+        Room: "Room";
+        Plinth: "Plinth";
+        Void: "Void";
+        Pergola: "Pergola";
+        Furniture: "Furniture";
+        "Facade element": "Facade element";
+        "Generic mass": "Generic mass";
+        Department: "Department";
+        Building: "Building";
+        "Revit Import": "Revit Import";
+        Mass: "Mass";
+        Site: "Site";
+    }>>;
+    departmentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        DEFAULT: "DEFAULT";
+        SITE: "SITE";
+        ENVELOPE: "ENVELOPE";
+        CORE: "CORE";
+    }>, z.ZodUUID]>>;
+    storey: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginCreateSpaceItem = z.infer<typeof PluginCreateSpaceItem>;
+export * from "./opening-fields";
+export * from "./bulk-items";
+export * from "./grids";
+//# sourceMappingURL=index.d.ts.map