@snaptrude/plugin-core 0.3.0 → 0.5.0

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

@@ -0,0 +1,178 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../types";
+import { ComponentHandle } from "../../../handles";
+import { PluginSpaceUpdateResult } from "../../entity/space";
+/**
+ * Sparse property updates for a space. Only provided fields change.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `room_type` | `string`? | Room label |
+ * | `massType` | `PluginMassType`? | Mass type |
+ * | `spaceType` | `PluginSpaceType`? | Space type |
+ * | `areaClass` | `PluginAreaClass`? | Area class (NET/GROSS/EXCLUDED) |
+ * | `departmentId` | `PluginDepartmentId`? | Department |
+ */
+export declare const PluginSpacePropertyUpdates: z.ZodObject<{
+    room_type: z.ZodOptional<z.ZodString>;
+    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";
+    }>>;
+    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";
+    }>>;
+    areaClass: z.ZodOptional<z.ZodEnum<{
+        NET: "NET";
+        GROSS: "GROSS";
+        EXCLUDED: "EXCLUDED";
+    }>>;
+    departmentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        DEFAULT: "DEFAULT";
+        SITE: "SITE";
+        ENVELOPE: "ENVELOPE";
+        CORE: "CORE";
+    }>, z.ZodUUID]>>;
+}, z.core.$strip>;
+export type PluginSpacePropertyUpdates = z.infer<typeof PluginSpacePropertyUpdates>;
+/** Geometry replacement for a space — re-extrude a profile. */
+export declare const PluginSpaceGeometryUpdate: z.ZodObject<{
+    profile: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"profile">, string>>;
+    extrudeHeight: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginSpaceGeometryUpdate = z.infer<typeof PluginSpaceGeometryUpdate>;
+/** One space to update via {@linkcode PluginDesignUpdateApi.spaces}. */
+export declare const PluginUpdateSpaceItem: z.ZodObject<{
+    space: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    properties: z.ZodOptional<z.ZodObject<{
+        room_type: z.ZodOptional<z.ZodString>;
+        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";
+        }>>;
+        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";
+        }>>;
+        areaClass: z.ZodOptional<z.ZodEnum<{
+            NET: "NET";
+            GROSS: "GROSS";
+            EXCLUDED: "EXCLUDED";
+        }>>;
+        departmentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            DEFAULT: "DEFAULT";
+            SITE: "SITE";
+            ENVELOPE: "ENVELOPE";
+            CORE: "CORE";
+        }>, z.ZodUUID]>>;
+    }, z.core.$strip>>;
+    geometry: z.ZodOptional<z.ZodObject<{
+        profile: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"profile">, string>>;
+        extrudeHeight: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginUpdateSpaceItem = z.infer<typeof PluginUpdateSpaceItem>;
+/**
+ * `snaptrude.design.update` — edit existing scene entities (properties + geometry).
+ *
+ * Migrated from the removed `entity.space.{update, updateGeometryFromProfile, bulkUpdate}`.
+ * Only provided fields change; each call is undoable. Failures throw (RPC rejects).
+ */
+export declare abstract class PluginDesignUpdateApi {
+    constructor();
+    /**
+     * Update a single space (room) — change its properties (room label, space
+     * type, mass type, area class, department) and/or replace its geometry by
+     * re-extruding a profile to a new height. Sparse and undoable: only the
+     * fields you provide change.
+     *
+     * @param space - The space to update
+     * @param options - `properties` (sparse) and/or `geometry` ({ profile, extrudeHeight })
+     * @returns the updated space's echoed {@linkcode PluginSpaceUpdateResult}
+     *
+     * @examplePrompt Rename this room to Office
+     * @examplePrompt Change this space's room type to Meeting Room
+     * @examplePrompt Set the height of this room to 3 metres
+     * @examplePrompt Move this space into the Circulation department
+     * @examplePrompt Exclude this room from the area calculations
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.design.update.space("space-id", { properties: { room_type: "Office" } })
+     * ```
+     */
+    abstract space(space: ComponentHandle, options: {
+        properties?: PluginSpacePropertyUpdates;
+        geometry?: PluginSpaceGeometryUpdate;
+    }): PluginApiReturn<PluginSpaceUpdateResult>;
+    /**
+     * Update many spaces (rooms) in one undoable operation — the bulk form of
+     * {@linkcode space}. Each item pairs a space with the sparse property
+     * changes and/or geometry re-extrude to apply; every item is validated up
+     * front, then all changes are applied as a single command.
+     *
+     * Migrated from `entity.space.bulkUpdate`.
+     *
+     * @param items - One {@linkcode PluginUpdateSpaceItem} per space
+     * @returns one {@linkcode PluginSpaceUpdateResult} per item, in input order
+     *
+     * @examplePrompt Label all the selected rooms as Bedrooms
+     * @examplePrompt Change the room type of these five spaces at once
+     * @examplePrompt Set every room on this floor to a 3m height in one go
+     * @examplePrompt Bulk-assign these spaces to the Service department
+     * @examplePrompt Mark all of these rooms as excluded from area in one update
+     *
+     * # Example
+     * ```ts
+     * // Re-label every selected room and mark it NET area — one undoable bulk update
+     * const rooms = await snaptrude.design.query.listSpaces({ isSelected: true })
+     * const results = await snaptrude.design.update.spaces(
+     *   rooms.map((space) => ({
+     *     space,
+     *     properties: { room_type: "Bedroom", areaClass: "NET" },
+     *   })),
+     * )
+     * // One result per item, in input order
+     * console.log(results.map((r) => r.spaceId))
+     * ```
+     */
+    abstract spaces(items: PluginUpdateSpaceItem[]): PluginApiReturn<PluginSpaceUpdateResult[]>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/api/design/update/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/update/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAiB,MAAM,kBAAkB,CAAA;AACjE,OAAO,EAKL,uBAAuB,EACxB,MAAM,oBAAoB,CAAA;AAE3B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMrC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF,+DAA+D;AAC/D,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEjF,wEAAwE;AACxE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE;;;;;GAKG;AACH,8BAAsB,qBAAqB;;IAGzC;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,KAAK,CACnB,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE;QACP,UAAU,CAAC,EAAE,0BAA0B,CAAA;QACvC,QAAQ,CAAC,EAAE,yBAAyB,CAAA;KACrC,GACA,eAAe,CAAC,uBAAuB,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;aACa,MAAM,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,eAAe,CAAC,uBAAuB,EAAE,CAAC;CACnG"}

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

@@ -0,0 +1,189 @@
+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 declare 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)
+     * ```
+     */
+    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)
+     * ```
+     */
+    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)
+     * ```
+     */
+    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)
+     * ```
+     */
+    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)
+     * ```
+     */
+    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)
+     * ```
+     */
+    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 declare const PluginDesignWindowArgs: z.ZodObject<{
+    window: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+}, z.core.$strip>;
+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 declare const PluginWindowDimensions: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    thickness: z.ZodNumber;
+}, z.core.$strip>;
+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 declare const PluginDesignWindowSetWidthArgs: z.ZodObject<{
+    window: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    width: z.ZodNumber;
+}, z.core.$strip>;
+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 declare const PluginDesignWindowSetHeightArgs: z.ZodObject<{
+    window: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginDesignWindowSetHeightArgs = z.infer<typeof PluginDesignWindowSetHeightArgs>;
+//# sourceMappingURL=index.d.ts.map

package/dist/api/design/windows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/windows/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;;;GAOG;AACH,8BAAsB,sBAAsB;;IAG1C;;;;;;;;;;;;;;;;;;OAkBG;aACa,OAAO,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC;IAEhF;;;;;;;;;;;;;;;;;OAiBG;aACa,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC;IAEjF;;;;;;;;;;;;;;;;;OAiBG;aACa,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC;IAElF;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,aAAa,CAC3B,MAAM,EAAE,eAAe,GACtB,eAAe,CAAC,sBAAsB,GAAG,IAAI,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;OAmBG;aACa,QAAQ,CACtB,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,MAAM,GACZ,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;OAkBG;aACa,SAAS,CACvB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,MAAM,GACb,eAAe,CAAC,wBAAwB,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;iBAEjC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;iBAIjC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B;;;iBAG1C,CAAA;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA"}

package/dist/api/entity/buildableEnvelope.d.ts

@@ -0,0 +1,261 @@
+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 declare 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,
+     * )
+     * ```
+     */
+    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,
+     * )
+     * ```
+     */
+    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 declare const PluginBuildableEnvelopePolygonVertex: z.ZodUnion<readonly [z.ZodObject<{
+    x: z.ZodNumber;
+    z: z.ZodNumber;
+}, z.core.$strict>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>;
+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 declare const PluginBuildableEnvelopeVerticalCap: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"max_height">;
+    maxHeight: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"max_floors">;
+    maxFloors: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+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 declare const PluginBuildableEnvelopeSetbackTier: z.ZodObject<{
+    aboveHeight: z.ZodNumber;
+    front: z.ZodNumber;
+    side: z.ZodNumber;
+    rear: z.ZodNumber;
+}, z.core.$strict>;
+export type PluginBuildableEnvelopeSetbackTier = z.infer<typeof PluginBuildableEnvelopeSetbackTier>;
+/**
+ * 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 declare const PluginBuildableEnvelopeCreateArgs: z.ZodObject<{
+    sitePolygon: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        x: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strict>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
+    lengthUnit: z.ZodUnion<readonly [z.ZodLiteral<"ft">, z.ZodLiteral<"m">]>;
+    setbacks: z.ZodArray<z.ZodObject<{
+        aboveHeight: z.ZodNumber;
+        front: z.ZodNumber;
+        side: z.ZodNumber;
+        rear: z.ZodNumber;
+    }, z.core.$strict>>;
+    verticalCap: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"max_height">;
+        maxHeight: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"max_floors">;
+        maxFloors: z.ZodNumber;
+    }, z.core.$strict>], "kind">;
+    floorToFloor: z.ZodNumber;
+    farRatio: z.ZodOptional<z.ZodNumber>;
+    lotCoverageMaxPct: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+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 declare const PluginBuildableEnvelopeCreateResult: z.ZodObject<{
+    buildableEnvelopeId: z.ZodString;
+}, z.core.$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 declare const PluginBuildableEnvelopeUpdateArgs: z.ZodObject<{
+    buildableEnvelopeId: z.ZodString;
+    sitePolygon: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        x: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strict>, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>]>>;
+    lengthUnit: z.ZodUnion<readonly [z.ZodLiteral<"ft">, z.ZodLiteral<"m">]>;
+    setbacks: z.ZodArray<z.ZodObject<{
+        aboveHeight: z.ZodNumber;
+        front: z.ZodNumber;
+        side: z.ZodNumber;
+        rear: z.ZodNumber;
+    }, z.core.$strict>>;
+    verticalCap: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"max_height">;
+        maxHeight: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"max_floors">;
+        maxFloors: z.ZodNumber;
+    }, z.core.$strict>], "kind">;
+    floorToFloor: z.ZodNumber;
+    farRatio: z.ZodOptional<z.ZodNumber>;
+    lotCoverageMaxPct: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+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 declare const PluginBuildableEnvelopeUpdateResult: z.ZodObject<{
+    buildableEnvelopeId: z.ZodString;
+}, z.core.$strict>;
+export type PluginBuildableEnvelopeUpdateResult = z.infer<typeof PluginBuildableEnvelopeUpdateResult>;
+//# sourceMappingURL=buildableEnvelope.d.ts.map

package/dist/api/entity/buildableEnvelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildableEnvelope.d.ts","sourceRoot":"","sources":["../../../src/api/entity/buildableEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;GASG;AACH,8BAAsB,0BAA0B;;IAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;aACa,MAAM,CACpB,WAAW,EAAE,oCAAoC,EAAE,EACnD,UAAU,EAAE,IAAI,GAAG,GAAG,EACtB,QAAQ,EAAE,kCAAkC,EAAE,EAC9C,WAAW,EAAE,kCAAkC,EAC/C,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,iBAAiB,CAAC,EAAE,MAAM,GACzB,eAAe,CAAC,mCAAmC,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;aACa,MAAM,CACpB,mBAAmB,EAAE,MAAM,EAC3B,WAAW,EAAE,oCAAoC,EAAE,EACnD,UAAU,EAAE,IAAI,GAAG,GAAG,EACtB,QAAQ,EAAE,kCAAkC,EAAE,EAC9C,WAAW,EAAE,kCAAkC,EAC/C,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,iBAAiB,CAAC,EAAE,MAAM,GACzB,eAAe,CAAC,mCAAmC,CAAC;CACxD;AAED;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC;;;kEAG/C,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC;;;;;;4BAS7C,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kCAAkC;;;;;kBAKpC,CAAA;AAEX,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AA+BD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;kBAWZ,CAAA;AAElC,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;kBAErC,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;kBAYZ,CAAA;AAElC,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;kBAErC,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA"}