@snaptrude/plugin-core 0.9.5 → 0.9.7

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

@@ -0,0 +1,427 @@
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"dimensions.d.ts","sourceRoot":"","sources":["../../../src/api/design/dimensions.ts"],"names":[],"mappings":"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"}

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

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { PluginApiReturn } from "../../../types";
 import { ComponentHandle } from "../../../handles";
 import { PluginDesignChangeResult } from "../lock";
+import { PluginObjectCatalogGroup } from "../doors";
 /**
  * `snaptrude.design.furniture` — the placeable furniture **catalog** (a library of
  * source items, NOT scene entities) plus dimension reads/edits of PLACED furniture.
@@ -83,8 +84,40 @@ export declare abstract class PluginDesignFurnitureApi {
      * const items = await snaptrude.design.furniture.listCatalog(undefined, first)
      * console.log(first, "→", items.length, "items")
      * ```
+     *
+     * @deprecated Use `design.furniture.listCatalogGroups` — the same name
+     * `design.doors` and `design.windows` use. Still supported.
      */
     abstract listCategories(): PluginApiReturn<string[]>;
+    /**
+     * List the furniture catalog's groups. Matches
+     * {@linkcode PluginDesignDoorsApi.listCatalogGroups} and
+     * {@linkcode PluginDesignWindowsApi.listCatalogGroups}, so all three catalog
+     * surfaces are named alike.
+     *
+     * `source` is `"default"` for the built-in picker groups and `"team"` for the
+     * sub-types of THIS project's team library — exactly the split
+     * {@linkcode PluginDesignFurnitureApi.listCatalog}'s `source` filter uses, so
+     * every `"team"` group is guaranteed to match at least one team item here.
+     * For furniture the group token and its label are the same string (the
+     * category), so `dbType === label`; `design.doors`/`design.windows` have a
+     * distinct engine `dbType`.
+     *
+     * @returns The catalog groups as {@linkcode PluginObjectCatalogGroup}`[]`
+     *   (`[]` when empty). Pass a group's `dbType` (=== `label`) to
+     *   {@linkcode PluginDesignFurnitureApi.listCatalog}'s `category` filter to
+     *   list its items.
+     *
+     * @examplePrompt What furniture groups are available?
+     * @examplePrompt List the furniture categories in this project
+     *
+     * # Example
+     * ```ts
+     * const groups = await snaptrude.design.furniture.listCatalogGroups()
+     * for (const g of groups) console.log(g.dbType, g.label, g.source)
+     * ```
+     */
+    abstract listCatalogGroups(): PluginApiReturn<PluginObjectCatalogGroup[]>;
     /**
      * List the placeable furniture catalog (team + general libraries),
      * optionally filtered by library `source` and/or `category`.

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/furniture/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;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,wBAAwB;;IAG5C;;;;;;;;;;;;;;;;;;;OAmBG;aACa,aAAa,CAC3B,IAAI,EAAE,eAAe,GACpB,eAAe,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAEpD;;;;;;;;;;;;;;;;;;;;;;OAsBG;aACa,aAAa,CAC3B,IAAI,EAAE,eAAe,EACrB,UAAU,EAAE,+BAA+B,GAC1C,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;OAmBG;aACa,cAAc,IAAI,eAAe,CAAC,MAAM,EAAE,CAAC;IAE3D;;;;;;;;;;;;;;;;;;OAkBG;aACa,WAAW,CACzB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,EAC3B,QAAQ,CAAC,EAAE,MAAM,GAChB,eAAe,CAAC,0BAA0B,EAAE,CAAC;IAEhD;;;;;;;;;;;;;;;;OAgBG;aACa,cAAc,CAC5B,EAAE,EAAE,MAAM,GACT,eAAe,CAAC,0BAA0B,GAAG,IAAI,CAAC;IAErD;;;;;;;;;;;;;;;;OAgBG;aACa,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,CAAC,OAAO,CAAC;CAC7D;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;iBASrC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;;;GAOG;AACH,eAAO,MAAM,oCAAoC;;;;;;iBAG/C,CAAA;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uCAAuC;;iBAElD,CAAA;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,uCAAuC,CAC/C,CAAA;AAED,eAAO,MAAM,+BAA+B;;iBAA0C,CAAA;AACtF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAM7F;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEjF;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;iBAExC,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B;;;;iBAI1C,CAAA;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,sCAAsC;;;;;;;iBAGjD,CAAA;AACF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,sCAAsC,CAC9C,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/furniture/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;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAA;AAEnD;;;;;;;;;;;;;;GAcG;AACH,8BAAsB,wBAAwB;;IAG5C;;;;;;;;;;;;;;;;;;;OAmBG;aACa,aAAa,CAC3B,IAAI,EAAE,eAAe,GACpB,eAAe,CAAC,yBAAyB,GAAG,IAAI,CAAC;IAEpD;;;;;;;;;;;;;;;;;;;;;;OAsBG;aACa,aAAa,CAC3B,IAAI,EAAE,eAAe,EACrB,UAAU,EAAE,+BAA+B,GAC1C,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;OAsBG;aACa,cAAc,IAAI,eAAe,CAAC,MAAM,EAAE,CAAC;IAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;aACa,iBAAiB,IAAI,eAAe,CAAC,wBAAwB,EAAE,CAAC;IAEhF;;;;;;;;;;;;;;;;;;OAkBG;aACa,WAAW,CACzB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,EAC3B,QAAQ,CAAC,EAAE,MAAM,GAChB,eAAe,CAAC,0BAA0B,EAAE,CAAC;IAEhD;;;;;;;;;;;;;;;;OAgBG;aACa,cAAc,CAC5B,EAAE,EAAE,MAAM,GACT,eAAe,CAAC,0BAA0B,GAAG,IAAI,CAAC;IAErD;;;;;;;;;;;;;;;;OAgBG;aACa,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,CAAC,OAAO,CAAC;CAC7D;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;iBASrC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;;;GAOG;AACH,eAAO,MAAM,oCAAoC;;;;;;iBAG/C,CAAA;AACF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uCAAuC;;iBAElD,CAAA;AACF,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,KAAK,CAC3D,OAAO,uCAAuC,CAC/C,CAAA;AAED,eAAO,MAAM,+BAA+B;;iBAA0C,CAAA;AACtF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAM7F;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEjF;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;iBAExC,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF;;;;;;;;;GASG;AACH,eAAO,MAAM,+BAA+B;;;;iBAI1C,CAAA;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,sCAAsC;;;;;;;iBAGjD,CAAA;AACF,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,sCAAsC,CAC9C,CAAA"}

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

@@ -14,6 +14,7 @@ import { PluginDesignTransformApi } from "./transform";
 import { PluginDesignEditApi } from "./edit";
 import { PluginDesignUpdateApi } from "./update";
 import { PluginDesignVisibilityApi } from "./visibility";
+import { PluginDesignDimensionsApi } from "./dimensions";
 import { PluginDesignTypesApi } from "./types";
 import { PluginDesignChangeResult } from "./lock";
 /**
@@ -29,6 +30,7 @@ import { PluginDesignChangeResult } from "./lock";
  * - {@linkcode PluginDesignApi.erase} — plan-level adjacency-edge erase (NOT hard delete)
  * - {@linkcode PluginDesignApi.delete} — hard entity removal
  * - {@linkcode PluginDesignApi.visibility} — hide / isolate / reveal entities
+ * - {@linkcode PluginDesignApi.dimensions} — dimension lines (Measuring Tape): create / list / delete / hide
  * - {@linkcode PluginDesignApi.types} — read-only building type / assembly reference
  * - {@linkcode PluginDesignApi.lock} / {@linkcode PluginDesignApi.unlock} / {@linkcode PluginDesignApi.isLocked} / {@linkcode PluginDesignApi.listLocked} — lock state (top-level design verbs, §2A.1)
  * - {@linkcode PluginDesignApi.lockArea} / {@linkcode PluginDesignApi.unlockArea} / {@linkcode PluginDesignApi.isAreaLocked} / {@linkcode PluginDesignApi.listAreaLocked} — footprint-area lock for Room/Department spaces
@@ -64,6 +66,8 @@ export declare abstract class PluginDesignApi {
     abstract update: PluginDesignUpdateApi;
     /** Hide / isolate / reveal entities. See {@linkcode PluginDesignVisibilityApi}. */
     abstract visibility: PluginDesignVisibilityApi;
+    /** Dimension lines (Measuring Tape). See {@linkcode PluginDesignDimensionsApi}. */
+    abstract dimensions: PluginDesignDimensionsApi;
     /** Read-only building type / assembly reference. See {@linkcode PluginDesignTypesApi}. */
     abstract types: PluginDesignTypesApi;
     /**
@@ -242,5 +246,6 @@ export * from "./transform";
 export * from "./edit";
 export * from "./update";
 export * from "./visibility";
+export * from "./dimensions";
 export * from "./types";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/design/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/design/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAA;AAEjD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,8BAAsB,eAAe;IACnC,sFAAsF;IACtF,SAAgB,MAAM,EAAE,qBAAqB,CAAA;IAC7C,oFAAoF;IACpF,SAAgB,KAAK,EAAE,oBAAoB,CAAA;IAC3C,mFAAmF;IACnF,SAAgB,SAAS,EAAE,wBAAwB,CAAA;IACnD,yEAAyE;IACzE,SAAgB,KAAK,EAAE,oBAAoB,CAAA;IAC3C,qEAAqE;IACrE,SAAgB,OAAO,EAAE,sBAAsB,CAAA;IAC/C,yEAAyE;IACzE,SAAgB,SAAS,EAAE,wBAAwB,CAAA;IACnD,+EAA+E;IAC/E,SAAgB,SAAS,EAAE,wBAAwB,CAAA;IACnD,+FAA+F;IAC/F,SAAgB,KAAK,EAAE,oBAAoB,CAAA;IAC3C,kEAAkE;IAClE,SAAgB,MAAM,EAAE,qBAAqB,CAAA;IAC7C,8FAA8F;IAC9F,SAAgB,OAAO,EAAE,sBAAsB,CAAA;IAC/C,kFAAkF;IAClF,SAAgB,SAAS,EAAE,wBAAwB,CAAA;IACnD,qFAAqF;IACrF,SAAgB,IAAI,EAAE,mBAAmB,CAAA;IACzC,+FAA+F;IAC/F,SAAgB,MAAM,EAAE,qBAAqB,CAAA;IAC7C,mFAAmF;IACnF,SAAgB,UAAU,EAAE,yBAAyB,CAAA;IACrD,mFAAmF;IACnF,SAAgB,UAAU,EAAE,yBAAyB,CAAA;IACrD,0FAA0F;IAC1F,SAAgB,KAAK,EAAE,oBAAoB,CAAA;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;aACa,IAAI,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,eAAe,CAAC,wBAAwB,CAAC;IAE9F;;;;;;;;;;;;;;;;;OAiBG;aACa,MAAM,CAAC,UAAU,EAAE,eAAe,EAAE,GAAG,eAAe,CAAC,wBAAwB,CAAC;IAEhG;;;;;;;;;;;;;;;;;;OAkBG;aACa,QAAQ,CACtB,SAAS,EAAE,eAAe,EAC1B,gBAAgB,CAAC,EAAE,OAAO,GACzB,eAAe,CAAC,OAAO,CAAC;IAE3B;;;;;;;;;;;;;;OAcG;aACa,UAAU,IAAI,eAAe,CAAC,eAAe,EAAE,CAAC;IAEhE;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;aACa,QAAQ,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,eAAe,CAAC,wBAAwB,CAAC;IAE9F;;;;;;;;;;;;;;;;;;OAkBG;aACa,UAAU,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,eAAe,CAAC,wBAAwB,CAAC;IAEhG;;;;;;;;;;;;;;;;;OAiBG;aACa,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,CAAC,OAAO,CAAC;IAE9E;;;;;;;;;;;;;;;OAeG;aACa,cAAc,IAAI,eAAe,CAAC,eAAe,EAAE,CAAC;;CAGrE;AAED,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA;AAC3B,cAAc,QAAQ,CAAA;AACtB,cAAc,UAAU,CAAA;AACxB,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,SAAS,CAAA"}

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

@@ -34,6 +34,23 @@ export declare abstract class PluginDesignVisibilityApi {
      * ```
      */
     abstract hide(components: ComponentHandle[]): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Reveal specific hidden components — the inverse of
+     * {@linkcode PluginDesignVisibilityApi.hide}. Use
+     * {@linkcode PluginDesignVisibilityApi.showAll} to reveal everything.
+     *
+     * @param components - The components to reveal.
+     * @returns A {@linkcode PluginDesignChangeResult} echoing the components shown.
+     *
+     * @examplePrompt Show these walls again
+     * @examplePrompt Unhide the selected furniture
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.design.visibility.show([wall])
+     * ```
+     */
+    abstract show(components: ComponentHandle[]): PluginApiReturn<PluginDesignChangeResult>;
     /**
      * Isolate entities — hide everything else so only the given entities remain
      * visible (the "Isolate" / solo action). Undoable. Reverse it with
@@ -84,6 +101,17 @@ export declare const PluginDesignVisibilityHideArgs: z.ZodObject<{
     components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
 }, z.core.$strip>;
 export type PluginDesignVisibilityHideArgs = z.infer<typeof PluginDesignVisibilityHideArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignVisibilityApi.show}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `components` | {@linkcode ComponentHandle}`[]` | Entities to reveal |
+ */
+export declare const PluginDesignVisibilityShowArgs: z.ZodObject<{
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDesignVisibilityShowArgs = z.infer<typeof PluginDesignVisibilityShowArgs>;
 /**
  * Arguments for {@linkcode PluginDesignVisibilityApi.isolate}.
  *

package/dist/api/design/visibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../src/api/design/visibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAA;AAEjD;;;;;;;;;GASG;AACH,8BAAsB,yBAAyB;;IAG7C;;;;;;;;;;;;;;;;;;OAkBG;aACa,IAAI,CAClB,UAAU,EAAE,eAAe,EAAE,GAC5B,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;OAkBG;aACa,OAAO,CACrB,UAAU,EAAE,eAAe,EAAE,GAC5B,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;OAgBG;aACa,OAAO,IAAI,eAAe,CAAC,wBAAwB,CAAC;CACrE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC;;iBAE5C,CAAA;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA"}
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../src/api/design/visibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAA;AAEjD;;;;;;;;;GASG;AACH,8BAAsB,yBAAyB;;IAG7C;;;;;;;;;;;;;;;;;;OAkBG;aACa,IAAI,CAClB,UAAU,EAAE,eAAe,EAAE,GAC5B,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;OAeG;aACa,IAAI,CAClB,UAAU,EAAE,eAAe,EAAE,GAC5B,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;OAkBG;aACa,OAAO,CACrB,UAAU,EAAE,eAAe,EAAE,GAC5B,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;OAgBG;aACa,OAAO,IAAI,eAAe,CAAC,wBAAwB,CAAC;CACrE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,8BAA8B,CACtC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iCAAiC;;iBAE5C,CAAA;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA"}

package/dist/api/presentation/annotate.d.ts

@@ -301,8 +301,8 @@ export type PluginAnnotateGeoKind = z.infer<typeof PluginAnnotateGeoKind>;
 /** Fill style for geo shapes (the same fills as the Present-mode style panel). */
 export declare const PluginAnnotateFill: z.ZodEnum<{
     pattern: "pattern";
-    solid: "solid";
     none: "none";
+    solid: "solid";
     semi: "semi";
 }>;
 export type PluginAnnotateFill = z.infer<typeof PluginAnnotateFill>;
@@ -445,8 +445,8 @@ export declare const PluginPresentationAnnotateShapeArgs: z.ZodObject<{
     }>>;
     fill: z.ZodOptional<z.ZodEnum<{
         pattern: "pattern";
-        solid: "solid";
         none: "none";
+        solid: "solid";
         semi: "semi";
     }>>;
 }, z.core.$strip>;

package/dist/api/presentation/shapes.d.ts

@@ -271,8 +271,8 @@ export declare const PluginPresentationShapeSpec: z.ZodDiscriminatedUnion<[z.Zod
     }>>;
     fill: z.ZodOptional<z.ZodEnum<{
         pattern: "pattern";
-        solid: "solid";
         none: "none";
+        solid: "solid";
         semi: "semi";
     }>>;
 }, z.core.$strip>], "type">;
@@ -426,8 +426,8 @@ export declare const PluginPresentationShapesUpsertArgs: z.ZodObject<{
         }>>;
         fill: z.ZodOptional<z.ZodEnum<{
             pattern: "pattern";
-            solid: "solid";
             none: "none";
+            solid: "solid";
             semi: "semi";
         }>>;
     }, z.core.$strip>], "type">;