@snaptrude/plugin-core 0.7.1 → 0.9.0

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

@@ -6,12 +6,12 @@ import { PluginDesignChangeResult } from "../lock";
  * `snaptrude.design.transform` — rigid transforms on scene entities.
  *
  * `move` / `rotate` migrated from the removed `tools.transform.*`; `align` snaps a
- * set of components' bounding-box edges to each other (or to a reference). All ops
- * are undoable and return {@linkcode PluginDesignChangeResult} `{ affected }`;
- * failures throw (RPC rejects).
+ * set of components' bounding-box edges to each other (or to a reference); `mirror`
+ * flips components in place about a horizontal axis. All ops are undoable and return
+ * {@linkcode PluginDesignChangeResult} `{ affected }`; failures throw (RPC rejects).
  *
- * `mirror` / `getPosition` / `setPosition` (and `scale`, an engine gap) are NOT in
- * this surface yet — they are a later, non-migration pass.
+ * `getPosition` / `setPosition` (and `scale`, an engine gap) are NOT in this surface
+ * yet — they are a later pass.
  */
 export declare abstract class PluginDesignTransformApi {
     constructor();
@@ -30,6 +30,9 @@ export declare abstract class PluginDesignTransformApi {
      * @examplePrompt Translate the furniture block by (10, 0, 5)
      * @examplePrompt Move these masses up one storey
      *
+     * @performance Array API — one host round-trip for the whole set. Pass every target in a
+     *   single call; never loop `design.transform.move` per entity.
+     *
      * # Example
      * ```ts
      * const { vec3 } = snaptrude.core.math
@@ -41,28 +44,39 @@ export declare abstract class PluginDesignTransformApi {
         trackParentChange?: boolean;
     }): PluginApiReturn<PluginDesignChangeResult>;
     /**
-     * Rotate entities by a **signed angle in DEGREES**, anchored at the combined
-     * bounding-box centre (positive = CCW about +Y). NOTE: unlike the removed
-     * `tools.transform.rotate` (radians + caller pivot), this canonical form takes
-     * DEGREES and has NO caller pivot — the pivot is always the bbox centre. Undoable.
+     * Rotate entities by a **signed angle in DEGREES** (positive = CCW about +Y).
+     * The pivot defaults to the combined bounding-box centre; pass `options.pivot`
+     * to rotate about an explicit world-space point instead. NOTE: unlike the
+     * removed `tools.transform.rotate` (radians), this canonical form takes
+     * DEGREES. Undoable.
      *
      * @param components - Entities to rotate
      * @param angleInDegrees - Signed rotation angle in degrees
-     * @param options - `axis` (defaults to world +Y), `is2D`
+     * @param options - `axis` (defaults to world +Y), `pivot` (world-space rotation
+     *   centre as a {@linkcode Vec3Handle}; defaults to the combined bbox centre),
+     *   `is2D`
      * @returns {@linkcode PluginDesignChangeResult}
      *
      * @examplePrompt Rotate the selected building 90 degrees
      * @examplePrompt Turn this room 45 degrees clockwise
      * @examplePrompt Spin the furniture block 180 degrees about its centre
      * @examplePrompt Rotate these masses 30 degrees around the vertical axis
+     * @examplePrompt Rotate these walls 90 degrees about the origin
+     *
+     * @performance Array API — one host round-trip for the whole set. Pass every target in a
+     *   single call; never loop `design.transform.rotate` per entity.
      *
      * # Example
      * ```ts
      * await snaptrude.design.transform.rotate(["space-id"], 90)
+     * // …or rotate about an explicit pivot point
+     * const { vec3 } = snaptrude.core.math
+     * await snaptrude.design.transform.rotate(["space-id"], 90, { pivot: vec3.new(0, 0, 0) })
      * ```
      */
     abstract rotate(components: ComponentHandle[], angleInDegrees: number, options?: {
         axis?: Vec3Handle;
+        pivot?: Vec3Handle;
         is2D?: boolean;
     }): PluginApiReturn<PluginDesignChangeResult>;
     /**
@@ -95,6 +109,9 @@ export declare abstract class PluginDesignTransformApi {
      * @examplePrompt Align all the walls to the left edge of this reference wall
      * @examplePrompt Snap the bottom edges of these spaces together
      *
+     * @performance Array API — one host round-trip for the whole set. Pass every target in a
+     *   single call; never loop `design.transform.align` per entity.
+     *
      * # Example
      * ```ts
      * const rooms = await snaptrude.design.selection.get()
@@ -108,7 +125,54 @@ export declare abstract class PluginDesignTransformApi {
     abstract align(components: ComponentHandle[], edge: PluginAlignEdge, options?: {
         reference?: ComponentHandle;
     }): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Mirror components **in place** about a horizontal axis, flipping their geometry
+     * across that axis through the combined bounding-box centre (the mesh's
+     * world-matrix flip + brep inversion + CAD/dimension-line/parametric handling
+     * commit atomically). Nothing moves off-centre — this is the toolbar "flip", not
+     * a translate-and-reflect. Undoable.
+     *
+     * `axis` names the axis the geometry mirrors **across** (world axes, Y is up):
+     * - `'x'` — mirror across world X (a front↔back flip in plan; reflects the Z coord)
+     * - `'z'` — mirror across world Z (a left↔right flip in plan; reflects the X coord)
+     *
+     * Vertical (`'y'`) mirroring is intentionally not exposed. Locked, bucket-locked
+     * and ineligible entries (terrain, plinths, reference/dimension lines,
+     * neighbourhood buildings) are **silently dropped**; the call only throws if
+     * nothing mirrorable remains. `affected` echoes the supplied handles.
+     *
+     * @param components - Entities to mirror (≥1)
+     * @param axis - Axis to mirror across ({@linkcode PluginTransformMirrorAxis})
+     * @returns {@linkcode PluginDesignChangeResult}
+     *
+     * @examplePrompt Mirror the selected building across the x axis
+     * @examplePrompt Flip these rooms left to right
+     * @examplePrompt Mirror this furniture block horizontally
+     * @examplePrompt Flip the selected walls front to back
+     * @examplePrompt Create a mirror image of these masses about the z axis
+     *
+     * @performance Array API — one host round-trip for the whole set. Pass every target in a
+     *   single call; never loop `design.transform.mirror` per entity.
+     *
+     * # Example
+     * ```ts
+     * const rooms = await snaptrude.design.selection.get()
+     * await snaptrude.design.transform.mirror(rooms, "x")
+     * ```
+     */
+    abstract mirror(components: ComponentHandle[], axis: PluginTransformMirrorAxis): PluginApiReturn<PluginDesignChangeResult>;
 }
+/**
+ * The horizontal axis a {@linkcode PluginDesignTransformApi.mirror} flips **across**
+ * (world axes, Y up): `'x'` mirrors across world X (front↔back in plan; reflects Z),
+ * `'z'` mirrors across world Z (left↔right in plan; reflects X). Vertical (`'y'`)
+ * mirroring is not exposed.
+ */
+export declare const PluginTransformMirrorAxis: z.ZodEnum<{
+    x: "x";
+    z: "z";
+}>;
+export type PluginTransformMirrorAxis = z.infer<typeof PluginTransformMirrorAxis>;
 /**
  * The bounding-box edge an {@linkcode PluginDesignTransformApi.align} snaps to.
  * Mirrors the engine's align `DirectionType`. World-axis mapping: `left`/`right`/`center`
@@ -116,9 +180,9 @@ export declare abstract class PluginDesignTransformApi {
  */
 export declare const PluginAlignEdge: z.ZodEnum<{
     center: "center";
+    top: "top";
     left: "left";
     right: "right";
-    top: "top";
     bottom: "bottom";
     middle: "middle";
 }>;
@@ -128,7 +192,7 @@ export type PluginAlignEdge = z.infer<typeof PluginAlignEdge>;
  */
 export declare const PluginDesignMoveArgs: z.ZodObject<{
     components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
-    displacement: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    displacement: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
     is2D: z.ZodOptional<z.ZodBoolean>;
     trackParentChange: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
@@ -139,8 +203,9 @@ export type PluginDesignMoveArgs = z.infer<typeof PluginDesignMoveArgs>;
 export declare const PluginDesignRotateArgs: z.ZodObject<{
     components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
     angleInDegrees: z.ZodNumber;
-    axis: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+    axis: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
     is2D: z.ZodOptional<z.ZodBoolean>;
+    pivot: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
 }, z.core.$strip>;
 export type PluginDesignRotateArgs = z.infer<typeof PluginDesignRotateArgs>;
 /**
@@ -156,13 +221,29 @@ export declare const PluginDesignAlignArgs: z.ZodObject<{
     components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
     edge: z.ZodEnum<{
         center: "center";
+        top: "top";
         left: "left";
         right: "right";
-        top: "top";
         bottom: "bottom";
         middle: "middle";
     }>;
     reference: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
 }, z.core.$strip>;
 export type PluginDesignAlignArgs = z.infer<typeof PluginDesignAlignArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignTransformApi.mirror}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `components` | {@linkcode ComponentHandle}`[]` | Entities to mirror (≥1) |
+ * | `axis` | {@linkcode PluginTransformMirrorAxis} | Horizontal axis to mirror across (`'x'` \| `'z'`) |
+ */
+export declare const PluginDesignMirrorArgs: z.ZodObject<{
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    axis: z.ZodEnum<{
+        x: "x";
+        z: "z";
+    }>;
+}, z.core.$strip>;
+export type PluginDesignMirrorArgs = z.infer<typeof PluginDesignMirrorArgs>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/transform/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;;;;;;GAUG;AACH,8BAAsB,wBAAwB;;IAG5C;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,IAAI,CAClB,UAAU,EAAE,eAAe,EAAE,EAC7B,YAAY,EAAE,UAAU,EACxB,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAAE,GACxD,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,MAAM,CACpB,UAAU,EAAE,eAAe,EAAE,EAC7B,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,UAAU,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,GAC9C,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;aACa,KAAK,CACnB,UAAU,EAAE,eAAe,EAAE,EAC7B,IAAI,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,eAAe,CAAA;KAAE,GACxC,eAAe,CAAC,wBAAwB,CAAC;CAC7C;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;EAAiE,CAAA;AAC7F,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAIhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/transform/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;;;;;;GAUG;AACH,8BAAsB,wBAAwB;;IAG5C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;aACa,IAAI,CAClB,UAAU,EAAE,eAAe,EAAE,EAC7B,YAAY,EAAE,UAAU,EACxB,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAAE,GACxD,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;aACa,MAAM,CACpB,UAAU,EAAE,eAAe,EAAE,EAC7B,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,UAAU,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,GAClE,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;aACa,KAAK,CACnB,UAAU,EAAE,eAAe,EAAE,EAC7B,IAAI,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,eAAe,CAAA;KAAE,GACxC,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;aACa,MAAM,CACpB,UAAU,EAAE,eAAe,EAAE,EAC7B,IAAI,EAAE,yBAAyB,GAC9B,eAAe,CAAC,wBAAwB,CAAC;CAC7C;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;EAAqB,CAAA;AAC3D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,yBAAyB,CACjC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;EAO1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;iBAK/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;iBAMjC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAIhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;iBAGjC,CAAA;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

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

@@ -0,0 +1,181 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../types";
+/**
+ * `snaptrude.design.types` — READ-ONLY reference over the project's building
+ * **type / assembly** system (the Project Properties layer stacks: External /
+ * Internal walls, slabs, floors, ceilings, roofs). A type bundles a labelled
+ * layer stack — each layer's role, thickness (engine units) and material — plus a
+ * summed total thickness. Both the built-in defaults and any team/user-added types
+ * are surfaced.
+ *
+ * Types are plain value records ({@linkcode PluginBuildingType}) — NOT scene
+ * entities/handles. A type's `id` is a stable `"<kind>:<name>"` token
+ * (e.g. `"wall:brickWithPlasterAndPaint"`) returned by
+ * {@linkcode PluginDesignTypesApi.list} and consumed by
+ * {@linkcode PluginDesignTypesApi.get}. Reads never throw — an unknown id yields
+ * `null`; a kind with no types yields `[]`.
+ *
+ * These are reads only: there is no engine seam to author a type from a plugin
+ * (types are created through the construction/project-properties UI).
+ */
+export declare abstract class PluginDesignTypesApi {
+    constructor();
+    /**
+     * List the building types of one `kind` (wall / slab / floor / ceiling / roof)
+     * — the built-in defaults plus any team/user-added types. Returns lightweight
+     * summaries; call {@linkcode PluginDesignTypesApi.get} for the full layer stack.
+     *
+     * @param kind Which family of types to list
+     * @returns The type summaries as {@linkcode PluginBuildingTypeSummary}`[]` (`[]` when none)
+     *
+     * @examplePrompt What wall types does this project have?
+     * @examplePrompt List the available slab assemblies
+     * @examplePrompt Show me every roof type in the project
+     * @examplePrompt Which floor types can I use?
+     *
+     * # Example
+     * ```ts
+     * const wallTypes = await snaptrude.design.types.list("wall")
+     * for (const t of wallTypes) console.log(t.id, t.label, t.thickness)
+     * ```
+     */
+    abstract list(kind: PluginBuildingTypeKind): PluginApiReturn<PluginBuildingTypeSummary[]>;
+    /**
+     * Get one building type by its `"<kind>:<name>"` id — its labelled layer stack
+     * (each layer's role, thickness and material) plus the summed total thickness.
+     *
+     * @param typeId The type id from {@linkcode PluginDesignTypesApi.list} (e.g. `"wall:exposedConcrete"`)
+     * @returns The full type, or `null` if no type matches
+     *
+     * @examplePrompt What layers make up this wall type?
+     * @examplePrompt Show the construction of the exposed-concrete wall
+     * @examplePrompt What's the total thickness of this slab type?
+     * @examplePrompt Which materials are in this roof assembly?
+     *
+     * # Example
+     * ```ts
+     * const [first] = await snaptrude.design.types.list("wall")
+     * const type = await snaptrude.design.types.get(first.id)
+     * if (type) for (const layer of type.layers) console.log(layer.name, layer.thickness)
+     * ```
+     */
+    abstract get(typeId: string): PluginApiReturn<PluginBuildingType | null>;
+}
+/** The building-type families exposed by {@linkcode PluginDesignTypesApi}. */
+export declare const PluginBuildingTypeKind: z.ZodEnum<{
+    floor: "floor";
+    wall: "wall";
+    ceiling: "ceiling";
+    slab: "slab";
+    roof: "roof";
+}>;
+export type PluginBuildingTypeKind = z.infer<typeof PluginBuildingTypeKind>;
+/**
+ * One layer of a building type's assembly.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `name` | `string` | Layer name (e.g. `"RCC"`, `"Paint"`) |
+ * | `role` | `string` | Layer role (e.g. `"Structure"`, `"Finish"`) |
+ * | `thickness` | `number` | Layer thickness in engine units (project's active unit mode) |
+ * | `material` | `object`? | Layer material — `{ name, type }` (optional) |
+ */
+export declare const PluginTypeLayer: z.ZodObject<{
+    name: z.ZodString;
+    role: z.ZodString;
+    thickness: z.ZodNumber;
+    material: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginTypeLayer = z.infer<typeof PluginTypeLayer>;
+/**
+ * A lightweight building-type summary (no layer stack).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | Stable `"<kind>:<name>"` token — pass to `design.types.get` |
+ * | `kind` | {@linkcode PluginBuildingTypeKind} | Which family it belongs to |
+ * | `label` | `string` | Human-readable label |
+ * | `isDefault` | `boolean` | `true` for a built-in type, `false` for a team/user type |
+ * | `thickness` | `number` | Summed layer thickness in engine units |
+ */
+export declare const PluginBuildingTypeSummary: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        floor: "floor";
+        wall: "wall";
+        ceiling: "ceiling";
+        slab: "slab";
+        roof: "roof";
+    }>;
+    label: z.ZodString;
+    isDefault: z.ZodBoolean;
+    thickness: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginBuildingTypeSummary = z.infer<typeof PluginBuildingTypeSummary>;
+/**
+ * A full building type — a {@linkcode PluginBuildingTypeSummary} plus its layer stack.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | Stable `"<kind>:<name>"` token |
+ * | `kind` | {@linkcode PluginBuildingTypeKind} | Which family it belongs to |
+ * | `label` | `string` | Human-readable label |
+ * | `isDefault` | `boolean` | `true` for a built-in type |
+ * | `thickness` | `number` | Summed layer thickness in engine units |
+ * | `layers` | {@linkcode PluginTypeLayer}`[]` | The ordered layer stack |
+ */
+export declare const PluginBuildingType: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        floor: "floor";
+        wall: "wall";
+        ceiling: "ceiling";
+        slab: "slab";
+        roof: "roof";
+    }>;
+    label: z.ZodString;
+    isDefault: z.ZodBoolean;
+    thickness: z.ZodNumber;
+    layers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        role: z.ZodString;
+        thickness: z.ZodNumber;
+        material: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginBuildingType = z.infer<typeof PluginBuildingType>;
+/**
+ * Arguments for {@linkcode PluginDesignTypesApi.list}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `kind` | {@linkcode PluginBuildingTypeKind} | Which family of types to list |
+ */
+export declare const PluginDesignTypesListArgs: z.ZodObject<{
+    kind: z.ZodEnum<{
+        floor: "floor";
+        wall: "wall";
+        ceiling: "ceiling";
+        slab: "slab";
+        roof: "roof";
+    }>;
+}, z.core.$strip>;
+export type PluginDesignTypesListArgs = z.infer<typeof PluginDesignTypesListArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignTypesApi.get}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `typeId` | `string` | The `"<kind>:<name>"` id from `design.types.list` |
+ */
+export declare const PluginDesignTypesGetArgs: z.ZodObject<{
+    typeId: z.ZodString;
+}, z.core.$strip>;
+export type PluginDesignTypesGetArgs = z.infer<typeof PluginDesignTypesGetArgs>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AACH,8BAAsB,oBAAoB;;IAGxC;;;;;;;;;;;;;;;;;;OAkBG;aACa,IAAI,CAClB,IAAI,EAAE,sBAAsB,GAC3B,eAAe,CAAC,yBAAyB,EAAE,CAAC;IAE/C;;;;;;;;;;;;;;;;;;OAkBG;aACa,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAAC,kBAAkB,GAAG,IAAI,CAAC;CAChF;AAED,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB;;;;;;EAAuD,CAAA;AAC1F,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe;;;;;;;;iBAU1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAMpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEjF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBAE7B,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;iBAEpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEjF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;iBAEnC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA"}