@snaptrude/plugin-core 0.3.0 → 0.5.0

package/src/api/design/windows/index.ts

@@ -0,0 +1,207 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../../types"
+import { ComponentHandle } from "../../../handles"
+import { PluginDesignChangeResult } from "../lock"
+
+/**
+ * `snaptrude.design.windows` — window-specific reads. Creation lives at
+ * `design.create.window`; generic reads (`listWindows`/`getHost`/`getProperties`) live
+ * at `design.query.*`. Window targets are {@linkcode ComponentHandle}s.
+ *
+ * `listTypes` (UI-const catalog), `getSillHeight` (bounds-derived), and the
+ * command-wired `mirror` land in a later pass.
+ */
+export abstract class PluginDesignWindowsApi {
+  constructor() {}
+
+  /**
+   * Get the type name of a window — the label that identifies which kind of
+   * window the instance is, as shown in its properties.
+   *
+   * @param window The window to query
+   * @returns The type as a `string`, or `null`
+   *
+   * @examplePrompt What type of window is this?
+   * @examplePrompt Is the selected window a casement or a slider?
+   * @examplePrompt Tell me the window type used on this wall
+   * @examplePrompt Check what kind of window the living room has
+   *
+   * # Example
+   * ```ts
+   * const [win] = await snaptrude.design.query.listWindows({ isSelected: true })
+   * const type = await snaptrude.design.windows.getType(win)
+   * if (type) console.log("window type:", type)
+   * ```
+   */
+  public abstract getType(window: ComponentHandle): PluginApiReturn<string | null>
+
+  /**
+   * Get the width of a window — how wide its opening is along the host wall.
+   *
+   * @param window The window to query
+   * @returns The width as a `number`, or `null`
+   *
+   * @examplePrompt How wide is this window?
+   * @examplePrompt What's the width of the selected window?
+   * @examplePrompt Measure the width of the kitchen window
+   * @examplePrompt Check whether this window is 1200mm wide
+   *
+   * # Example
+   * ```ts
+   * const [win] = await snaptrude.design.query.listWindows()
+   * const width = await snaptrude.design.windows.getWidth(win)
+   * if (width !== null) console.log("window width:", width)
+   * ```
+   */
+  public abstract getWidth(window: ComponentHandle): PluginApiReturn<number | null>
+
+  /**
+   * Get the height of a window — how tall its opening is on the host wall.
+   *
+   * @param window The window to query
+   * @returns The height as a `number`, or `null`
+   *
+   * @examplePrompt How tall is this window?
+   * @examplePrompt What's the height of the selected window?
+   * @examplePrompt Check the window height on this wall
+   * @examplePrompt Is the bedroom window 1.5m high?
+   *
+   * # Example
+   * ```ts
+   * const [win] = await snaptrude.design.query.listWindows()
+   * const height = await snaptrude.design.windows.getHeight(win)
+   * if (height !== null) console.log("window height:", height)
+   * ```
+   */
+  public abstract getHeight(window: ComponentHandle): PluginApiReturn<number | null>
+
+  /**
+   * Get a window's full dimensions in one call — width along the wall, vertical
+   * height, and thickness through the wall — measured in the window's local
+   * oriented space.
+   *
+   * @param window The window to query
+   * @returns The dimensions, or `null`
+   *
+   * @examplePrompt What are the dimensions of this window?
+   * @examplePrompt How big is the selected window?
+   * @examplePrompt Give me the width, height and depth of this window
+   * @examplePrompt Measure the living room window
+   * @examplePrompt Get the window size including its thickness through the wall
+   *
+   * # Example
+   * ```ts
+   * const [win] = await snaptrude.design.query.listWindows({ isSelected: true })
+   * const dims = await snaptrude.design.windows.getDimensions(win)
+   * if (dims) console.log(dims.width, dims.height, dims.thickness)
+   * ```
+   */
+  public abstract getDimensions(
+    window: ComponentHandle
+  ): PluginApiReturn<PluginWindowDimensions | null>
+
+  /**
+   * Set the width of a window, resizing its opening and re-cutting the host
+   * wall. Width is in engine units; the change is undoable.
+   *
+   * @param window The window to resize
+   * @param width New width (engine units)
+   * @returns The affected window
+   *
+   * @examplePrompt Make this window 1200mm wide
+   * @examplePrompt Widen the selected window to 4 feet
+   * @examplePrompt Change the window width to 1.5m
+   * @examplePrompt Resize the kitchen window to 900 wide
+   *
+   * # Example
+   * ```ts
+   * // Takes a single window (unlike design.doors.setWidth, which takes an array)
+   * const [win] = await snaptrude.design.query.listWindows({ isSelected: true })
+   * const { affected } = await snaptrude.design.windows.setWidth(win, 1200)
+   * ```
+   */
+  public abstract setWidth(
+    window: ComponentHandle,
+    width: number
+  ): PluginApiReturn<PluginDesignChangeResult>
+
+  /**
+   * Set the height of a window, resizing its opening and re-cutting the host
+   * wall. Height is in engine units; the change is undoable.
+   *
+   * @param window The window to resize
+   * @param height New height (engine units)
+   * @returns The affected window
+   *
+   * @examplePrompt Make this window 1.5m tall
+   * @examplePrompt Change the window height to 4 feet
+   * @examplePrompt Shorten the selected window to 900mm high
+   * @examplePrompt Set the bedroom window height to 1200
+   *
+   * # Example
+   * ```ts
+   * const [win] = await snaptrude.design.query.listWindows({ isSelected: true })
+   * await snaptrude.design.windows.setHeight(win, 1500)
+   * ```
+   */
+  public abstract setHeight(
+    window: ComponentHandle,
+    height: number
+  ): PluginApiReturn<PluginDesignChangeResult>
+}
+
+/**
+ * Arguments for the single-window read methods.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `window` | {@linkcode ComponentHandle} | The window to query |
+ */
+export const PluginDesignWindowArgs = z.object({
+  window: ComponentHandle,
+})
+export type PluginDesignWindowArgs = z.infer<typeof PluginDesignWindowArgs>
+
+/**
+ * A window's dimensions.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `width` | `number` | Along the wall |
+ * | `height` | `number` | Vertical |
+ * | `thickness` | `number` | Through the wall (engine `length` axis) |
+ */
+export const PluginWindowDimensions = z.object({
+  width: z.number(),
+  height: z.number(),
+  thickness: z.number(),
+})
+export type PluginWindowDimensions = z.infer<typeof PluginWindowDimensions>
+
+/**
+ * Arguments for {@linkcode PluginDesignWindowsApi.setWidth}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `window` | {@linkcode ComponentHandle} | The window to resize |
+ * | `width` | `number` | New width (engine units) |
+ */
+export const PluginDesignWindowSetWidthArgs = z.object({
+  window: ComponentHandle,
+  width: z.number(),
+})
+export type PluginDesignWindowSetWidthArgs = z.infer<typeof PluginDesignWindowSetWidthArgs>
+
+/**
+ * Arguments for {@linkcode PluginDesignWindowsApi.setHeight}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `window` | {@linkcode ComponentHandle} | The window to resize |
+ * | `height` | `number` | New height (engine units) |
+ */
+export const PluginDesignWindowSetHeightArgs = z.object({
+  window: ComponentHandle,
+  height: z.number(),
+})
+export type PluginDesignWindowSetHeightArgs = z.infer<typeof PluginDesignWindowSetHeightArgs>

package/src/api/entity/buildableEnvelope.ts

@@ -0,0 +1,318 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+
+/**
+ * Buildable Envelope management — create and update parametric zoning envelopes.
+ *
+ * A **buildable envelope** is the regulated volume inside which a building may
+ * be massed. The host owns envelope identity: {@linkcode PluginBuildableEnvelopeApi.create create}
+ * mints a `buildableEnvelopeId` and returns it; {@linkcode PluginBuildableEnvelopeApi.update update}
+ * requires that id to target the existing envelope.
+ *
+ * Accessed via `snaptrude.entity.buildableEnvelope`.
+ */
+export abstract class PluginBuildableEnvelopeApi {
+  constructor() {}
+
+  /**
+   * 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.
+   *
+   * @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 Model the allowable massing from the setback rules
+   * @examplePrompt Create a zoning envelope capped at 12 floors with FAR 3
+   *
+   * # Example
+   * ```ts
+   * const { buildableEnvelopeId } = await snaptrude.entity.buildableEnvelope.create(
+   *   [
+   *     { 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,
+   * )
+   * ```
+   */
+  public abstract create(
+    sitePolygon: PluginBuildableEnvelopePolygonVertex[],
+    lengthUnit: "ft" | "m",
+    setbacks: PluginBuildableEnvelopeSetbackTier[],
+    verticalCap: PluginBuildableEnvelopeVerticalCap,
+    floorToFloor: number,
+    farRatio?: number,
+    lotCoverageMaxPct?: number
+  ): PluginApiReturn<PluginBuildableEnvelopeCreateResult>
+
+  /**
+   * Update an existing parametric buildable envelope — regenerate the zoning
+   * volume from a revised site polygon, setbacks, vertical cap, or FAR and
+   * lot-coverage limits, keeping the same envelope id.
+   *
+   * @param buildableEnvelopeId - Existing envelope ID to update; non-empty and
+   *   must match an existing envelope on the canvas.
+   * @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 PluginBuildableEnvelopeUpdateResult} with the
+   *   `buildableEnvelopeId` of the updated envelope.
+   * @throws If validation fails, the envelope does not exist, or generation
+   *   produces no renderable geometry.
+   *
+   * @examplePrompt Change the envelope's height limit to 175 feet
+   * @examplePrompt Update the setbacks on the buildable envelope
+   * @examplePrompt Regenerate the zoning envelope with a new site boundary
+   * @examplePrompt Increase the FAR on the buildable volume
+   * @examplePrompt Modify the envelope to allow 15 storeys instead
+   *
+   * # Example
+   * ```ts
+   * const { buildableEnvelopeId } = await snaptrude.entity.buildableEnvelope.update(
+   *   existingId,
+   *   [
+   *     { 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 }],
+   *   { kind: "max_height", maxHeight: 175 },
+   *   12,
+   * )
+   * ```
+   */
+  public abstract update(
+    buildableEnvelopeId: string,
+    sitePolygon: PluginBuildableEnvelopePolygonVertex[],
+    lengthUnit: "ft" | "m",
+    setbacks: PluginBuildableEnvelopeSetbackTier[],
+    verticalCap: PluginBuildableEnvelopeVerticalCap,
+    floorToFloor: number,
+    farRatio?: number,
+    lotCoverageMaxPct?: number
+  ): PluginApiReturn<PluginBuildableEnvelopeUpdateResult>
+}
+
+/**
+ * Site polygon vertex in the request `lengthUnit`.
+ *
+ * Vertices may be passed as `{x, z}` objects or `[x, z]` tuples. Numeric
+ * values must be finite (no `NaN` or `±Infinity`).
+ */
+export const PluginBuildableEnvelopePolygonVertex = z.union([
+  z.object({ x: z.number().finite(), z: z.number().finite() }).strict(),
+  z.tuple([z.number().finite(), z.number().finite()]),
+])
+
+export type PluginBuildableEnvelopePolygonVertex = z.infer<
+  typeof PluginBuildableEnvelopePolygonVertex
+>
+
+/**
+ * Vertical cap for a buildable envelope.
+ *
+ * Use exactly one shape:
+ * - `{ kind: "max_height", maxHeight }`
+ * - `{ kind: "max_floors", maxFloors }`
+ *
+ * Floor-to-floor height is not nested here; it is always supplied as the
+ * top-level `floorToFloor` argument.
+ */
+export const PluginBuildableEnvelopeVerticalCap = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("max_height"),
+    maxHeight: z.number().finite().positive(),
+  }).strict(),
+  z.object({
+    kind: z.literal("max_floors"),
+    maxFloors: z.number().finite().int().positive(),
+  }).strict(),
+])
+
+export type PluginBuildableEnvelopeVerticalCap = z.infer<
+  typeof PluginBuildableEnvelopeVerticalCap
+>
+
+/**
+ * One tier of a buildable envelope's setback profile.
+ *
+ * Tiers are ordered by `aboveHeight`. The first tier (index 0) must have
+ * `aboveHeight: 0` and describes the ground footprint; each subsequent tier
+ * describes the complete setback at a strictly greater height. Each tier
+ * carries its own `front`, `side`, and `rear` values — there is no
+ * inheritance from earlier tiers.
+ *
+ * All numeric values must be finite and nonnegative, in the request
+ * `lengthUnit`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `aboveHeight` | `number` | Height at or above which this tier applies; the ground tier uses `0` |
+ * | `front` | `number` | Front setback for this tier |
+ * | `side` | `number` | Side setback for this tier |
+ * | `rear` | `number` | Rear setback for this tier |
+ */
+export const PluginBuildableEnvelopeSetbackTier = z.object({
+  aboveHeight: z.number().finite().nonnegative(),
+  front: z.number().finite().nonnegative(),
+  side: z.number().finite().nonnegative(),
+  rear: z.number().finite().nonnegative(),
+}).strict()
+
+export type PluginBuildableEnvelopeSetbackTier = z.infer<
+  typeof PluginBuildableEnvelopeSetbackTier
+>
+
+// Enforces setback tier ordering invariants on the parsed args shape:
+//   - setbacks[0].aboveHeight === 0
+//   - aboveHeight strictly increasing thereafter
+// Length >= 1 is enforced earlier by z.array(...).min(1).
+function refineSetbackTiers(
+  args: { setbacks: PluginBuildableEnvelopeSetbackTier[] },
+  ctx: z.RefinementCtx
+): void {
+  const tiers = args.setbacks
+  if (tiers.length === 0) return
+  if (tiers[0].aboveHeight !== 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["setbacks", 0, "aboveHeight"],
+      message: "Ground tier required: setbacks[0].aboveHeight must be 0.",
+    })
+  }
+  for (let i = 1; i < tiers.length; i++) {
+    if (!(tiers[i].aboveHeight > tiers[i - 1].aboveHeight)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["setbacks", i, "aboveHeight"],
+        message:
+          "Setback tiers must be ordered by strictly increasing aboveHeight.",
+      })
+    }
+  }
+}
+
+/**
+ * Arguments for {@linkcode PluginBuildableEnvelopeApi.create}.
+ *
+ * Strict schema. The host owns identity — no `buildableEnvelopeId` is accepted
+ * on create; the id is minted by the host and returned in
+ * {@linkcode PluginBuildableEnvelopeCreateResult}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `sitePolygon` | {@linkcode PluginBuildableEnvelopePolygonVertex}`[]` | Site polygon vertices in `lengthUnit`; minimum 3 vertices |
+ * | `lengthUnit` | `"ft" \| "m"` | Unit used by all length fields |
+ * | `setbacks` | {@linkcode PluginBuildableEnvelopeSetbackTier}`[]` | Setback profile, ground tier first; minimum 1 tier |
+ * | `verticalCap` | {@linkcode PluginBuildableEnvelopeVerticalCap} | Maximum height or floor count |
+ * | `floorToFloor` | `number` | Required floor-to-floor height in `lengthUnit` |
+ * | `farRatio` | `number?` | Optional FAR value, positive when provided |
+ * | `lotCoverageMaxPct` | `number?` | Optional lot coverage cap, `0..100` |
+ */
+export const PluginBuildableEnvelopeCreateArgs = z
+  .object({
+    sitePolygon: z.array(PluginBuildableEnvelopePolygonVertex).min(3),
+    lengthUnit: z.union([z.literal("ft"), z.literal("m")]),
+    setbacks: z.array(PluginBuildableEnvelopeSetbackTier).min(1),
+    verticalCap: PluginBuildableEnvelopeVerticalCap,
+    floorToFloor: z.number().finite().positive(),
+    farRatio: z.number().finite().positive().optional(),
+    lotCoverageMaxPct: z.number().finite().min(0).max(100).optional(),
+  })
+  .strict()
+  .superRefine(refineSetbackTiers)
+
+export type PluginBuildableEnvelopeCreateArgs = z.infer<
+  typeof PluginBuildableEnvelopeCreateArgs
+>
+
+/**
+ * Result of {@linkcode PluginBuildableEnvelopeApi.create}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `buildableEnvelopeId` | `string` | Non-empty unique ID of the created buildable envelope |
+ */
+export const PluginBuildableEnvelopeCreateResult = z.object({
+  buildableEnvelopeId: z.string().min(1),
+}).strict()
+
+export type PluginBuildableEnvelopeCreateResult = z.infer<
+  typeof PluginBuildableEnvelopeCreateResult
+>
+
+/**
+ * Arguments for {@linkcode PluginBuildableEnvelopeApi.update}.
+ *
+ * Strict schema. `buildableEnvelopeId` is required and identifies the prior
+ * envelope on the canvas to update.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `buildableEnvelopeId` | `string` | Existing envelope ID to update; non-empty |
+ * | `sitePolygon` | {@linkcode PluginBuildableEnvelopePolygonVertex}`[]` | Site polygon vertices in `lengthUnit`; minimum 3 vertices |
+ * | `lengthUnit` | `"ft" \| "m"` | Unit used by all length fields |
+ * | `setbacks` | {@linkcode PluginBuildableEnvelopeSetbackTier}`[]` | Setback profile, ground tier first; minimum 1 tier |
+ * | `verticalCap` | {@linkcode PluginBuildableEnvelopeVerticalCap} | Maximum height or floor count |
+ * | `floorToFloor` | `number` | Required floor-to-floor height in `lengthUnit` |
+ * | `farRatio` | `number?` | Optional FAR value, positive when provided |
+ * | `lotCoverageMaxPct` | `number?` | Optional lot coverage cap, `0..100` |
+ */
+export const PluginBuildableEnvelopeUpdateArgs = z
+  .object({
+    buildableEnvelopeId: z.string().min(1),
+    sitePolygon: z.array(PluginBuildableEnvelopePolygonVertex).min(3),
+    lengthUnit: z.union([z.literal("ft"), z.literal("m")]),
+    setbacks: z.array(PluginBuildableEnvelopeSetbackTier).min(1),
+    verticalCap: PluginBuildableEnvelopeVerticalCap,
+    floorToFloor: z.number().finite().positive(),
+    farRatio: z.number().finite().positive().optional(),
+    lotCoverageMaxPct: z.number().finite().min(0).max(100).optional(),
+  })
+  .strict()
+  .superRefine(refineSetbackTiers)
+
+export type PluginBuildableEnvelopeUpdateArgs = z.infer<
+  typeof PluginBuildableEnvelopeUpdateArgs
+>
+
+/**
+ * Result of {@linkcode PluginBuildableEnvelopeApi.update}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `buildableEnvelopeId` | `string` | Non-empty unique ID of the updated buildable envelope |
+ */
+export const PluginBuildableEnvelopeUpdateResult = z.object({
+  buildableEnvelopeId: z.string().min(1),
+}).strict()
+
+export type PluginBuildableEnvelopeUpdateResult = z.infer<
+  typeof PluginBuildableEnvelopeUpdateResult
+>

package/src/api/entity/department.ts

@@ -1,113 +0,0 @@
-import * as z from "zod"
-import { PluginApiReturn } from "../../types"
-
-/**
- * Department management — create and query departments.
- *
- * A **department** is a named, colored grouping applied to spaces.
- * Departments are used to categorize spaces by function (e.g. "FOH",
- * "Emergency", "Residential") and control their visual appearance.
- *
- * Accessed via `snaptrude.entity.department`.
- */
-export abstract class PluginDepartmentApi {
-  constructor() {}
-
-  /**
-   * Create a new department.
-   *
-   * @param args - An object containing:
-   *   - {@linkcode PluginDepartmentCreateArgs.name args.name} — Display name
-   *   - {@linkcode PluginDepartmentCreateArgs.color args.color} — CSS hex color string (e.g. `"#b5e1dc"`)
-   * @returns A {@linkcode PluginDepartmentCreateResult} with the `departmentId`
-   *   of the created department
-   * @throws If department creation fails
-   *
-   * # Example
-   * ```ts
-   * const { departmentId } = await snaptrude.entity.department.create({
-   *   name: "Emergency",
-   *   color: "#f5e68b",
-   * })
-   * ```
-   */
-  public abstract create(
-    args: PluginDepartmentCreateArgs
-  ): PluginApiReturn<PluginDepartmentCreateResult>
-
-  /**
-   * Get all departments in the current project.
-   *
-   * Returns every department including well-known ones (Default, Site, etc.)
-   * and user-created departments.
-   *
-   * @returns A {@linkcode PluginDepartmentGetAllResult} with a `departments` array
-   *
-   * # Example
-   * ```ts
-   * const { departments } = await snaptrude.entity.department.getAll()
-   * for (const dept of departments) {
-   *   console.log(dept.id, dept.name, dept.color)
-   * }
-   * ```
-   */
-  public abstract getAll(): PluginApiReturn<PluginDepartmentGetAllResult>
-}
-
-/**
- * Arguments for {@linkcode PluginDepartmentApi.create}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `name` | `string` | Display name of the department |
- * | `color` | `string` | CSS hex color string (e.g. `"#b5e1dc"`) |
- */
-export const PluginDepartmentCreateArgs = z.object({
-  name: z.string(),
-  color: z.string(),
-})
-
-export type PluginDepartmentCreateArgs = z.infer<
-  typeof PluginDepartmentCreateArgs
->
-
-/**
- * Result of {@linkcode PluginDepartmentApi.create}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `departmentId` | `string` | Unique ID of the created department |
- */
-export const PluginDepartmentCreateResult = z.object({
-  departmentId: z.string(),
-})
-
-export type PluginDepartmentCreateResult = z.infer<
-  typeof PluginDepartmentCreateResult
->
-
-/**
- * A single department entry returned by {@linkcode PluginDepartmentApi.getAll}.
- */
-export const PluginDepartmentEntry = z.object({
-  id: z.string(),
-  name: z.string(),
-  color: z.string(),
-})
-
-export type PluginDepartmentEntry = z.infer<typeof PluginDepartmentEntry>
-
-/**
- * Result of {@linkcode PluginDepartmentApi.getAll}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `departments` | {@linkcode PluginDepartmentEntry}`[]` | All departments in the project |
- */
-export const PluginDepartmentGetAllResult = z.object({
-  departments: z.array(PluginDepartmentEntry),
-})
-
-export type PluginDepartmentGetAllResult = z.infer<
-  typeof PluginDepartmentGetAllResult
->

package/src/api/entity/index.ts

@@ -1,30 +1,30 @@
-import { PluginDepartmentApi } from "./department"
+import { PluginBuildableEnvelopeApi } from "./buildableEnvelope"
 import { PluginReferenceLineApi } from "./referenceLine"
-import { PluginSpaceApi } from "./space"
 import { PluginStoryApi } from "./story"
 
 /**
  * CRUD operations on Snaptrude building entities.
  *
- * - {@linkcode PluginEntityApi.space} — Create, query, and delete spaces (rooms/masses)
  * - {@linkcode PluginEntityApi.story} — Create, query, and update stories (floors)
  * - {@linkcode PluginEntityApi.referenceLine} — Create, query, and delete reference lines
- * - {@linkcode PluginEntityApi.department} — Create and query departments
+ * - {@linkcode PluginEntityApi.buildableEnvelope} — Create or update parametric buildable envelopes
+ *
+ * Space operations moved to `design.create.spaces` / `design.update.*` /
+ * `design.query.*` / `design.delete.entities` (the `entity.space` API was removed);
+ * `./space` still exports the shared space value types.
  */
 export abstract class PluginEntityApi {
-  /** Space (room/mass) operations. See {@linkcode PluginSpaceApi}. */
-  public abstract space: PluginSpaceApi
   /** Story (floor/storey) operations. See {@linkcode PluginStoryApi}. */
   public abstract story: PluginStoryApi
   /** Reference line operations. See {@linkcode PluginReferenceLineApi}. */
   public abstract referenceLine: PluginReferenceLineApi
-  /** Department operations. See {@linkcode PluginDepartmentApi}. */
-  public abstract department: PluginDepartmentApi
+  /** Buildable Envelope operations. See {@linkcode PluginBuildableEnvelopeApi}. */
+  public abstract buildableEnvelope: PluginBuildableEnvelopeApi
 
   constructor() {}
 }
 
-export * from "./department"
+export * from "./buildableEnvelope"
 export * from "./referenceLine"
 export * from "./space"
 export * from "./story"