@snaptrude/plugin-core 0.0.0-dev-20260911064951 → 0.0.0-surfaces-20260921090636

package/dist/api/design/create/bulk-items.d.ts

@@ -1,185 +0,0 @@
-import * as z from "zod";
-/**
- * Maximum items per bulk `design.create.*` call. A bounded request keeps
- * validation, command capture and rollback work finite; split a larger import
- * into separate awaited batches, each with its own undo entry.
- */
-export declare const PLUGIN_CREATE_BATCH_LIMIT = 1000;
-/**
- * One wall run to create via {@linkcode PluginDesignCreateApi.wallRuns} — the
- * same inputs as {@linkcode PluginDesignCreateApi.walls}, one run per item.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `profile` | {@linkcode ProfileHandle} | Ordered curve chain (wall centerlines) |
- * | `height` | `number`? | Wall height (Snaptrude units, > 0; default engine default) |
- * | `thickness` | `number`? | Wall thickness (Snaptrude units, > 0; 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`? (int) | Target storey (must exist) — the run's walls are assigned + lifted to its base in the same undo entry (default: geometry-derived) |
- */
-export declare const PluginCreateWallRunItem: 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 PluginCreateWallRunItem = z.infer<typeof PluginCreateWallRunItem>;
-/** The `items` array of {@linkcode PluginDesignCreateApi.wallRuns} (1…1000). */
-export declare const PluginCreateWallRunItems: z.ZodArray<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 PluginCreateWallRunItems = z.infer<typeof PluginCreateWallRunItems>;
-/**
- * One floor to create via {@linkcode PluginDesignCreateApi.floors} — the same
- * footprint-extrude inputs as {@linkcode PluginDesignCreateApi.floor}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `contour` | {@linkcode ContourHandle} | Footprint (outer profile + holes) |
- * | `thickness` | `number` | Floor thickness (Snaptrude units, > 0) |
- * | `position` | {@linkcode Vec3Handle}? | Offset from origin (default origin) |
- */
-export declare const PluginCreateFloorItem: 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 PluginCreateFloorItem = z.infer<typeof PluginCreateFloorItem>;
-/** The `items` array of {@linkcode PluginDesignCreateApi.floors} (1…1000). */
-export declare const PluginCreateFloorItems: z.ZodArray<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 PluginCreateFloorItems = z.infer<typeof PluginCreateFloorItems>;
-/**
- * One door to place via {@linkcode PluginDesignCreateApi.doors} — the same
- * fields as a `"door"` {@linkcode PluginDesignCreateOpeningOptions}, so the
- * size overrides singular {@linkcode PluginDesignCreateApi.door} lacks are
- * available per item. `facing` and `hinge` are WORLD POINTS, not directions:
- * `facing` on the side of the wall the door swings open to, `hinge` near the
- * jamb it is hinged on. Rejects unknown fields.
- *
- * | 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 |
- * | `facing` | {@linkcode Vec3Handle}? | World point on the side 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) |
- * | `label` | `string`? | Instance name (optional) |
- * | `width` | `number`? | Width override (Snaptrude units, > 0; default the catalog item's) |
- * | `height` | `number`? | Height override (Snaptrude units, > 0; default the catalog item's) |
- */
-export declare const PluginCreateDoorItem: z.ZodObject<{
-    catalogId: z.ZodString;
-    hostWall: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").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>;
-}, z.core.$strict>;
-export type PluginCreateDoorItem = z.infer<typeof PluginCreateDoorItem>;
-/** The `items` array of {@linkcode PluginDesignCreateApi.doors} (1…1000). */
-export declare const PluginCreateDoorItems: z.ZodArray<z.ZodObject<{
-    catalogId: z.ZodString;
-    hostWall: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").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>;
-}, z.core.$strict>>;
-export type PluginCreateDoorItems = z.infer<typeof PluginCreateDoorItems>;
-/**
- * One window to place via {@linkcode PluginDesignCreateApi.windows} — the same
- * fields as a `"window"` {@linkcode PluginDesignCreateOpeningOptions}.
- * `sillHeight` is a nonnegative Snaptrude-unit distance from the host wall's
- * base to the BOTTOM of the window, not to its center. `facing` and `hinge`
- * are WORLD POINTS, not directions: `facing` on the side of the wall the
- * window opens to, `hinge` near the jamb it is hinged on. Rejects unknown
- * fields.
- *
- * | 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 |
- * | `facing` | {@linkcode Vec3Handle}? | World point on the side 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) |
- * | `label` | `string`? | Instance name (optional) |
- * | `width` | `number`? | Width override (Snaptrude units, > 0; default the catalog item's) |
- * | `height` | `number`? | Height override (Snaptrude units, > 0; default the catalog item's) |
- * | `sillHeight` | `number`? | Wall base to window bottom (Snaptrude units, ≥ 0; default the catalog item's) |
- */
-export declare const PluginCreateWindowItem: z.ZodObject<{
-    sillHeight: z.ZodOptional<z.ZodNumber>;
-    catalogId: z.ZodString;
-    hostWall: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").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>;
-}, z.core.$strict>;
-export type PluginCreateWindowItem = z.infer<typeof PluginCreateWindowItem>;
-/** The `items` array of {@linkcode PluginDesignCreateApi.windows} (1…1000). */
-export declare const PluginCreateWindowItems: z.ZodArray<z.ZodObject<{
-    sillHeight: z.ZodOptional<z.ZodNumber>;
-    catalogId: z.ZodString;
-    hostWall: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").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>;
-}, z.core.$strict>>;
-export type PluginCreateWindowItems = z.infer<typeof PluginCreateWindowItems>;
-/**
- * One furniture instance to place via
- * {@linkcode PluginDesignCreateApi.furnitureItems} — the same inputs as
- * {@linkcode PluginDesignCreateApi.furniture} minus `createNewSourceMesh`: in a
- * batch the host owns source-mesh persistence (a source is recorded once per
- * call, however many items reuse it).
- *
- * `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.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `catalogId` | `string` | Library id: team `_id` or general `fullName` |
- * | `position` | {@linkcode Vec3Handle} | Absolute world placement point (`y` = rest elevation) |
- * | `label` | `string`? | Instance name and readable label (default auto `${name}Ins${n}`) |
- * | `angleInDegrees` | `number`? | Rotation about the vertical axis, in degrees (default unrotated) |
- */
-export declare const PluginCreateFurnitureItem: 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>;
-    angleInDegrees: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type PluginCreateFurnitureItem = z.infer<typeof PluginCreateFurnitureItem>;
-/**
- * The `items` array of {@linkcode PluginDesignCreateApi.furnitureItems}
- * (1…1000).
- */
-export declare const PluginCreateFurnitureItems: z.ZodArray<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>;
-    angleInDegrees: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>;
-export type PluginCreateFurnitureItems = z.infer<typeof PluginCreateFurnitureItems>;
-//# sourceMappingURL=bulk-items.d.ts.map

package/dist/api/design/create/bulk-items.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk-items.d.ts","sourceRoot":"","sources":["../../../../src/api/design/create/bulk-items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAA;AAM7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB;;;;;;iBAMlC,CAAA;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E,gFAAgF;AAChF,eAAO,MAAM,wBAAwB;;;;;;kBAGJ,CAAA;AACjC,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAM/E;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB;;;;kBAGF,CAAA;AACjC,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAM3E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;kBAEtB,CAAA;AACX,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,6EAA6E;AAC7E,eAAO,MAAM,qBAAqB;;;;;;;;;mBAGD,CAAA;AACjC,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;kBAKxB,CAAA;AACX,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E,+EAA+E;AAC/E,eAAO,MAAM,uBAAuB;;;;;;;;;;mBAGH,CAAA;AACjC,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAM7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB;;;;;iBAKpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,yBAAyB,CACjC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;kBAGN,CAAA;AACjC,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,0BAA0B,CAClC,CAAA"}

package/dist/api/design/create/opening-fields.d.ts

@@ -1,37 +0,0 @@
-import * as z from "zod";
-import { ComponentHandle } from "../../../handles";
-/**
- * The shared field bag every hosted opening (door / window) carries — used by
- * {@linkcode PluginDesignCreateOpeningOptions} and by the bulk item schemas in
- * `bulk-items.ts`, so singular and plural openings validate identically.
- *
- * `facing` and `hinge` are WORLD POINTS, not directions: `facing` sits on the
- * side of the wall the leaf swings open to (where the plan symbol draws the
- * swing arc); `hinge` sits near the jamb the leaf is hinged on — the item is
- * reflected along the wall so its hinged jamb is the one nearer that point.
- * Either may be omitted (engine-chosen side / the catalog item's authored
- * hinge side). Neither has a visible effect on symmetric items such as
- * sliders or fixed windows.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `catalogId` | `string` | Library id: team `_id` or general `fullName` |
- * | `hostWall` | {@linkcode ComponentHandle} | The wall to host the opening |
- * | `position` | {@linkcode Vec3Handle} | World point projected onto the wall |
- * | `facing` | {@linkcode Vec3Handle}? | World point on the side of the wall the opening swings open to (default engine-chosen) |
- * | `hinge` | {@linkcode Vec3Handle}? | World point near the jamb the opening is hinged on (default the catalog item's authored side) |
- * | `label` | `string`? | Instance name (optional) |
- * | `width` | `number`? | Width override (Snaptrude units, > 0; default the catalog item's) |
- * | `height` | `number`? | Height override (Snaptrude units, > 0; default the catalog item's) |
- */
-export declare const PluginOpeningBaseOptions: {
-    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>;
-};
-//# sourceMappingURL=opening-fields.d.ts.map

package/dist/api/design/create/opening-fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"opening-fields.d.ts","sourceRoot":"","sources":["../../../../src/api/design/create/opening-fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAc,MAAM,kBAAkB,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;CASpC,CAAA"}

package/dist/api/design/dimensions.d.ts

@@ -1,427 +0,0 @@
-import * as z from "zod";
-import { PluginApiReturn } from "../../types";
-import { ComponentHandle, DimensionHandle, Vec3Handle } from "../../handles";
-/**
- * Dimension lines (Measuring Tape) — the measurement annotations the Measuring
- * Tape tool leaves in the 3D scene, NOT an entity's width/height/depth
- * properties (for those see `design.windows.getDimensions`,
- * `design.create.staircase`'s `dimensions`, or `design.query.measure`).
- *
- * A dimension line is a scene object: two endpoints anchored to the geometry
- * they were measured on, an offset that pushes the drawn line clear of the
- * span, and a label showing the distance in the project's units. Because the
- * endpoints are anchored, the line follows its host when the host is moved,
- * edited, or resized, and it is removed with the host when the host is deleted.
- * Dimension lines are storey-scoped, render in both plan and 3D, and are drawn
- * into Present-mode sheets (style them with
- * `presentation.placedViews.updateStyles(shapeId, "Dimension", …)`).
- *
- * **Units.** Every length here — `offset` and the record's `length` — is in
- * **Babylon units** (BU), the engine's storage unit: 1 BU = 10 in = 0.254 m.
- * Convert with `core.units.convert(value, from, await core.units.getBabylonType())`.
- *
- * **Offset convention.** `options.offset` is a **signed** distance in BU:
- * positive pushes the drawn line to the **left** of the `from` → `to`
- * direction in plan (`cross(up, direction)`), negative to the right. It
- * defaults to `3.937` BU (1 m). The placement mode is always `"across"` (the
- * tape tool's perpendicular mode), which re-perpendicularises when the host
- * geometry is edited.
- *
- * Every mutator here (`create`, `delete`, `hide`, `show`) commits through the
- * engine's command manager, so each call is a single undo entry, is autosaved,
- * and replays to collaborators.
- *
- * Accessed via `snaptrude.design.dimensions`.
- */
-export declare abstract class PluginDesignDimensionsApi {
-    constructor();
-    /**
-     * Draw one dimension line between two world points, anchored to a component.
-     *
-     * `anchor` is **required**: the endpoints are stored relative to the anchor's
-     * mesh, and only component-anchored dimension lines survive a reload. A
-     * free-point dimension anchors to a scene helper mesh whose id is not stable
-     * across reloads, so it is dropped or corrupted when the project is reopened
-     * — the host therefore rejects a non-component anchor rather than writing a
-     * record that silently disappears. Pass `options.anchorTo` to anchor the
-     * second endpoint to a different component (it defaults to `anchor`).
-     *
-     * The dimension is created flat (never plan-projected) so the same call
-     * produces the same record whatever the current camera; it still draws in
-     * plan.
-     *
-     * @param from - World-space first endpoint.
-     * @param to - World-space second endpoint.
-     * @param anchor - The component the first endpoint is anchored to (required).
-     * @param options - `anchorTo` (component for the second endpoint; defaults to
-     *   `anchor`), `offset` (signed perpendicular offset in Babylon units,
-     *   positive = left of the `from` → `to` direction in plan; default `3.937`
-     *   BU = 1 m).
-     * @returns The new dimension line's {@linkcode DimensionHandle}.
-     * @throws `VALIDATION` for malformed arguments or a degenerate span (`from`
-     *   and `to` closer than the engine's minimum); `HANDLE_INVALID` for an
-     *   unknown `anchor` / `anchorTo`; `PRECONDITION_FAILED` when the anchor is
-     *   outside the active proposal or the editor is not mounted;
-     *   `METHOD_NOT_PERMITTED` when plugin writes are disabled.
-     *
-     * @examplePrompt Dimension every wall on level 2
-     * @examplePrompt Add a dimension line along this wall
-     * @examplePrompt Measure the width of this room and label it on the plan
-     *
-     * # Example
-     * ```ts
-     * const { design, core } = snaptrude
-     * const v = core.math.vec3
-     * const curve = core.geom.query.curve
-     * for (const wall of await design.query.listWalls({ storeys: [2] })) {
-     *   const cl = await design.query.geometry.getCenterline(wall)
-     *   if (!cl) continue
-     *   const a = await curve.getStartPoint(cl)
-     *   const b = await curve.getEndPoint(cl)
-     *   await design.dimensions.create(
-     *     await v.new(a.x, a.y, a.z),
-     *     await v.new(b.x, b.y, b.z),
-     *     wall,
-     *   )
-     * }
-     * ```
-     */
-    abstract create(from: Vec3Handle, to: Vec3Handle, anchor: ComponentHandle, options?: {
-        anchorTo?: ComponentHandle;
-        offset?: number;
-    }): PluginApiReturn<DimensionHandle>;
-    /**
-     * List the dimension lines in the project as full records.
-     *
-     * Filters combine with AND. `storeys` keeps only the dimensions on those
-     * storey numbers, `anchors` only the ones anchored to those components
-     * (matching either endpoint, and matching an instanced anchor's source mesh
-     * too), `isHidden` only the ones whose user Hide flag equals the value given.
-     *
-     * Dimension lines drawn by the Measuring Tape onto a scene helper mesh rather
-     * than a component come back with `anchor: null` and are not proposal-scoped.
-     *
-     * @param options - `storeys`, `anchors`, `isHidden` filters (all optional,
-     *   ANDed).
-     * @returns The matching {@linkcode PluginDimensionLine} records (`[]` when
-     *   nothing matches).
-     * @throws `VALIDATION` for malformed filters; `HANDLE_INVALID` for an unknown
-     *   handle in `anchors`.
-     *
-     * @examplePrompt List all the dimension lines in this model
-     * @examplePrompt Which dimensions are on level 3?
-     * @examplePrompt Flag any dimension line shorter than 600 mm
-     *
-     * @performance Array read — one host round-trip returns every record. Filter
-     *   in one call rather than calling `get` per dimension.
-     *
-     * # Example
-     * ```ts
-     * const units = snaptrude.core.units
-     * const min = await units.convert(600, "millimeters", await units.getBabylonType())
-     * const short = (await snaptrude.design.dimensions.list()).filter(
-     *   (d) => d.length < min,
-     * )
-     * console.log(short.map((d) => `${d.label} on storey ${d.storey}`))
-     * ```
-     */
-    abstract list(options?: {
-        storeys?: number[];
-        anchors?: ComponentHandle[];
-        isHidden?: boolean;
-    }): PluginApiReturn<PluginDimensionLine[]>;
-    /**
-     * Read one dimension line by handle.
-     *
-     * Returns `null` — rather than throwing — when the dimension no longer
-     * exists, so a handle kept across a delete or an undo can be polled safely.
-     *
-     * @param dimension - The dimension line to read.
-     * @returns Its {@linkcode PluginDimensionLine} record, or `null` if it is
-     *   gone.
-     * @throws `VALIDATION` if `dimension` is not a non-empty id string.
-     *
-     * @examplePrompt Read the dimension line I just created
-     * @examplePrompt How long is this dimension and what does its label say?
-     * @examplePrompt Check whether that dimension line still exists
-     *
-     * # Example
-     * ```ts
-     * const dim = await snaptrude.design.dimensions.get(handle)
-     * if (dim) console.log(dim.label, dim.length, dim.storey)
-     * ```
-     */
-    abstract get(dimension: DimensionHandle): PluginApiReturn<PluginDimensionLine | null>;
-    /**
-     * Delete dimension lines — the same hard removal as selecting them and
-     * pressing Delete. Undoable as a **single** entry for the whole batch.
-     *
-     * Deleted handles are stale afterwards: {@linkcode
-     * PluginDesignDimensionsApi.get} returns `null` for them and the other
-     * mutators throw `HANDLE_INVALID`.
-     *
-     * @param dimensions - The dimension lines to delete (at least one — an empty
-     *   array is a caller error, not a no-op).
-     * @returns The dimensions that were deleted, as
-     *   {@linkcode PluginDimensionsChangeResult}.
-     * @throws `VALIDATION` for an empty or malformed array; `HANDLE_INVALID` if
-     *   any handle is unknown (the whole call rejects before anything is
-     *   deleted); `PRECONDITION_FAILED` if any dimension's anchor is outside the
-     *   active proposal; `METHOD_NOT_PERMITTED` when plugin writes are disabled.
-     *
-     * @examplePrompt Remove all dimension lines
-     * @examplePrompt Delete the dimensions on this wall
-     * @examplePrompt Clear the measurements I added to level 2
-     *
-     * @performance Array API — pass the whole set in one call (one host
-     *   round-trip, one undo entry). Never loop this per dimension.
-     *
-     * # Example
-     * ```ts
-     * const dims = snaptrude.design.dimensions
-     * const onWall = await dims.list({ anchors: [wall] })
-     * if (onWall.length > 0) await dims.delete(onWall.map((d) => d.id))
-     * ```
-     */
-    abstract delete(dimensions: DimensionHandle[]): PluginApiReturn<PluginDimensionsChangeResult>;
-    /**
-     * Hide dimension lines from the viewport — the same as the right-click "Hide"
-     * action (it sets the user Hide flag, `isHidden`). Undoable. Already-hidden
-     * dimensions are skipped and are not reported in `affected`.
-     *
-     * @param dimensions - The dimension lines to hide.
-     * @returns The dimensions actually hidden, as
-     *   {@linkcode PluginDimensionsChangeResult} — already-hidden inputs are
-     *   omitted, so `affected` can be shorter than the input.
-     * @throws `VALIDATION` for a malformed array; `HANDLE_INVALID` if any handle
-     *   is unknown; `PRECONDITION_FAILED` if any dimension's anchor is outside
-     *   the active proposal; `METHOD_NOT_PERMITTED` when plugin writes are
-     *   disabled.
-     *
-     * @examplePrompt Hide the dimensions on this storey
-     * @examplePrompt Hide every dimension line while I present
-     * @examplePrompt Temporarily hide the measurements on level 3
-     *
-     * @performance Array API — one host round-trip and one undo entry for the
-     *   whole set.
-     *
-     * # Example
-     * ```ts
-     * const dims = snaptrude.design.dimensions
-     * const onLevel3 = await dims.list({ storeys: [3] })
-     * const { affected } = await dims.hide(onLevel3.map((d) => d.id))
-     * ```
-     */
-    abstract hide(dimensions: DimensionHandle[]): PluginApiReturn<PluginDimensionsChangeResult>;
-    /**
-     * Reveal hidden dimension lines — clear the user Hide flag, the inverse of
-     * {@linkcode PluginDesignDimensionsApi.hide}. Undoable. Already-visible
-     * dimensions are skipped and are not reported in `affected`.
-     *
-     * Clearing the flag does not guarantee the dimension is on screen: a
-     * dimension whose anchor component is itself hidden stays off screen with
-     * `isHidden: false` and `isVisible: false`.
-     *
-     * @param dimensions - The dimension lines to reveal.
-     * @returns The dimensions actually revealed, as
-     *   {@linkcode PluginDimensionsChangeResult} — already-visible inputs are
-     *   omitted, so `affected` can be shorter than the input.
-     * @throws `VALIDATION` for a malformed array; `HANDLE_INVALID` if any handle
-     *   is unknown; `PRECONDITION_FAILED` if any dimension's anchor is outside
-     *   the active proposal; `METHOD_NOT_PERMITTED` when plugin writes are
-     *   disabled.
-     *
-     * @examplePrompt Show the dimension lines again
-     * @examplePrompt Unhide all the hidden dimensions
-     * @examplePrompt Bring back the measurements I hid on this storey
-     *
-     * @performance Array API — one host round-trip and one undo entry for the
-     *   whole set.
-     *
-     * # Example
-     * ```ts
-     * const dims = snaptrude.design.dimensions
-     * const hidden = await dims.list({ isHidden: true })
-     * await dims.show(hidden.map((d) => d.id))
-     * ```
-     */
-    abstract show(dimensions: DimensionHandle[]): PluginApiReturn<PluginDimensionsChangeResult>;
-}
-/**
- * How a dimension line's drawn offset is constrained.
- *
- * - `"across"` — perpendicular to the span (the tape tool's default, and what
- *   every plugin-created dimension uses); re-perpendicularises when the host
- *   geometry is edited.
- * - `"x"` / `"y"` / `"z"` — the offset is locked to that world axis.
- * - `"none"` — no placement mode recorded (a plain world-space offset).
- */
-export declare const PluginDimensionPlacement: z.ZodEnum<{
-    x: "x";
-    y: "y";
-    z: "z";
-    across: "across";
-    none: "none";
-}>;
-export type PluginDimensionPlacement = z.infer<typeof PluginDimensionPlacement>;
-/**
- * One dimension line (Measuring Tape annotation). Lengths are in **Babylon
- * units** (1 BU = 0.254 m — convert with `core.units.convert`).
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `id` | {@linkcode DimensionHandle} | The dimension line's handle |
- * | `from` | {@linkcode Vec3Components} | Live world position of the first endpoint |
- * | `to` | {@linkcode Vec3Components} | Live world position of the second endpoint |
- * | `length` | `number` | Straight-line distance between `from` and `to`, in Babylon units |
- * | `label` | `string` | The text drawn on the canvas, in the project's units (a bare number for metric/inch projects, `27' 7"` style for feet-inches). For a span whose x, y and z all differ the drawn line is the plan projection, so `label` reads the horizontal distance while `length` is the true 3D one |
- * | `offset` | {@linkcode Vec3Components} | World vector from the measured span to the drawn line |
- * | `placement` | {@linkcode PluginDimensionPlacement} | How that offset is constrained |
- * | `anchor` | {@linkcode ComponentHandle}` \| null` | Component the first endpoint is anchored to; `null` for a free point or a non-component host mesh |
- * | `anchorTo` | {@linkcode ComponentHandle}` \| null` | Component the second endpoint is anchored to; equals `anchor` when both endpoints share a host |
- * | `storey` | `number` | Storey the dimension belongs to |
- * | `buildingId` | `string \| null` | Building it belongs to, when it has one |
- * | `isHidden` | `boolean` | The user Hide flag (what `hide` / `show` toggle) |
- * | `isVisible` | `boolean` | Whether it is actually drawn — `false` when hidden, and also when an anchor component is hidden |
- * | `isPlanProjected` | `boolean` | Whether it is drawn flattened onto the storey base (Measuring Tape dimensions drawn in 2D are; plugin-created ones never are) |
- */
-export declare const PluginDimensionLine: z.ZodObject<{
-    id: z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>;
-    from: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    to: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    length: z.ZodNumber;
-    label: z.ZodString;
-    offset: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        z: z.ZodNumber;
-    }, z.core.$strip>;
-    placement: z.ZodEnum<{
-        x: "x";
-        y: "y";
-        z: "z";
-        across: "across";
-        none: "none";
-    }>;
-    anchor: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
-    anchorTo: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
-    storey: z.ZodNumber;
-    buildingId: z.ZodNullable<z.ZodString>;
-    isHidden: z.ZodBoolean;
-    isVisible: z.ZodBoolean;
-    isPlanProjected: z.ZodBoolean;
-}, z.core.$strip>;
-export type PluginDimensionLine = z.infer<typeof PluginDimensionLine>;
-/**
- * Result of every `design.dimensions` mutation that takes a batch
- * ({@linkcode PluginDesignDimensionsApi.delete} /
- * {@linkcode PluginDesignDimensionsApi.hide} /
- * {@linkcode PluginDesignDimensionsApi.show}) — the dimensions actually
- * affected. `hide` / `show` skip dimensions already in the target state, so
- * `affected` can be shorter than the input; `delete` echoes the whole batch.
- * Failures throw (the RPC rejects); there is no `Result<>` monad in the SDK.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `affected` | {@linkcode DimensionHandle}`[]` | The dimension lines the call changed |
- */
-export declare const PluginDimensionsChangeResult: z.ZodObject<{
-    affected: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>>;
-}, z.core.$strip>;
-export type PluginDimensionsChangeResult = z.infer<typeof PluginDimensionsChangeResult>;
-/**
- * Arguments for {@linkcode PluginDesignDimensionsApi.create} (options
- * flattened).
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `from` | {@linkcode Vec3Handle} | World-space first endpoint |
- * | `to` | {@linkcode Vec3Handle} | World-space second endpoint |
- * | `anchor` | {@linkcode ComponentHandle} | Component the first endpoint anchors to (required — free-point dimensions do not survive a reload) |
- * | `anchorTo` | {@linkcode ComponentHandle}? | Component for the second endpoint (default: `anchor`) |
- * | `offset` | `number`? | Signed perpendicular offset in Babylon units, positive = left of the `from` → `to` direction in plan (default `3.937` BU = 1 m) |
- *
- * TRANSPORT: positional args — validated host-side as this object.
- */
-export declare const PluginDesignDimensionsCreateArgs: z.ZodObject<{
-    from: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../..").Handle<"vec3">, string>>;
-    to: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../..").Handle<"vec3">, string>>;
-    anchor: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
-    anchorTo: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
-    offset: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type PluginDesignDimensionsCreateArgs = z.infer<typeof PluginDesignDimensionsCreateArgs>;
-/**
- * Arguments for {@linkcode PluginDesignDimensionsApi.list} (options flattened).
- * Filters combine with AND; omitting all of them lists every dimension line.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `storeys` | `number[]`? | Only dimensions on these storey numbers |
- * | `anchors` | {@linkcode ComponentHandle}`[]`? | Only dimensions anchored to these components (either endpoint) |
- * | `isHidden` | `boolean`? | user-hidden flag === |
- */
-export declare const PluginDesignDimensionsListArgs: z.ZodObject<{
-    storeys: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    anchors: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>>;
-    isHidden: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type PluginDesignDimensionsListArgs = z.infer<typeof PluginDesignDimensionsListArgs>;
-/**
- * Arguments for {@linkcode PluginDesignDimensionsApi.get}.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `dimension` | {@linkcode DimensionHandle} | The dimension line to read |
- */
-export declare const PluginDesignDimensionsGetArgs: z.ZodObject<{
-    dimension: z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>;
-}, z.core.$strip>;
-export type PluginDesignDimensionsGetArgs = z.infer<typeof PluginDesignDimensionsGetArgs>;
-/**
- * Arguments for {@linkcode PluginDesignDimensionsApi.delete}.
- *
- * `.min(1)` mirrors {@linkcode PluginDesignDeleteEntitiesArgs}: an empty delete
- * is a caller error, not a no-op.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `dimensions` | {@linkcode DimensionHandle}`[]` | Dimension lines to delete. Unknown handles reject the whole call (fail-fast). |
- */
-export declare const PluginDesignDimensionsDeleteArgs: z.ZodObject<{
-    dimensions: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>>;
-}, z.core.$strip>;
-export type PluginDesignDimensionsDeleteArgs = z.infer<typeof PluginDesignDimensionsDeleteArgs>;
-/**
- * Arguments for {@linkcode PluginDesignDimensionsApi.hide}. An empty array is
- * allowed and is a no-op (mirroring {@linkcode PluginDesignVisibilityHideArgs}).
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `dimensions` | {@linkcode DimensionHandle}`[]` | Dimension lines to hide |
- */
-export declare const PluginDesignDimensionsHideArgs: z.ZodObject<{
-    dimensions: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>>;
-}, z.core.$strip>;
-export type PluginDesignDimensionsHideArgs = z.infer<typeof PluginDesignDimensionsHideArgs>;
-/**
- * Arguments for {@linkcode PluginDesignDimensionsApi.show}. An empty array is
- * allowed and is a no-op.
- *
- * | Property | Type | Description |
- * |---|---|---|
- * | `dimensions` | {@linkcode DimensionHandle}`[]` | Dimension lines to reveal |
- */
-export declare const PluginDesignDimensionsShowArgs: z.ZodObject<{
-    dimensions: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>>;
-}, z.core.$strip>;
-export type PluginDesignDimensionsShowArgs = z.infer<typeof PluginDesignDimensionsShowArgs>;
-//# sourceMappingURL=dimensions.d.ts.map