@snaptrude/plugin-core 0.7.1 → 0.9.0

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

@@ -52,6 +52,9 @@ export abstract class PluginDesignDeleteApi {
    * @examplePrompt Delete all the furniture I picked
    * @examplePrompt Remove the door and window I just created
    *
+   * @performance Array delete — pass every target in one call (one host round-trip). There is
+   *   no per-item delete; collect the whole set and never loop this per entity.
+   *
    * # Example
    * ```ts
    * // Hard-delete every furniture item on storey 2 (a single undo entry)

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

@@ -105,6 +105,30 @@ export abstract class PluginDesignDoorsApi {
    */
   public abstract getHeight(door: ComponentHandle): PluginApiReturn<number | null>
 
+  /**
+   * Get a door's full dimensions in one call — width along the wall, vertical
+   * height, and thickness through the wall — measured in the door's local
+   * oriented space. Parity with {@linkcode PluginDesignWindowsApi.getDimensions}.
+   *
+   * @param door The door to query
+   * @returns The dimensions, or `null`
+   *
+   * @examplePrompt What are the dimensions of this door?
+   * @examplePrompt How big is the selected door?
+   * @examplePrompt Give me the width, height and depth of this door
+   * @examplePrompt Measure the entrance door including its thickness through the wall
+   *
+   * # Example
+   * ```ts
+   * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
+   * const dims = await snaptrude.design.doors.getDimensions(door)
+   * if (dims) console.log(dims.width, dims.height, dims.thickness)
+   * ```
+   */
+  public abstract getDimensions(
+    door: ComponentHandle
+  ): PluginApiReturn<PluginDoorDimensions | null>
+
   /**
    * Get the floor a door is hosted on — the storey/level component that
    * supports the door.
@@ -329,6 +353,22 @@ export const PluginDesignDoorArgs = z.object({
 })
 export type PluginDesignDoorArgs = z.infer<typeof PluginDesignDoorArgs>
 
+/**
+ * A door's dimensions (engine units), symmetric with {@linkcode PluginWindowDimensions}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `width` | `number` | Along the wall |
+ * | `height` | `number` | Vertical |
+ * | `thickness` | `number` | Through the wall (engine `length` axis) |
+ */
+export const PluginDoorDimensions = z.object({
+  width: z.number(),
+  height: z.number(),
+  thickness: z.number(),
+})
+export type PluginDoorDimensions = z.infer<typeof PluginDoorDimensions>
+
 /** Mirror axis — tokens mirror the engine `FlipDirection` verbatim (§6.1). */
 export const PluginMirrorAxis = z.enum(["x", "y", "z"])
 export type PluginMirrorAxis = z.infer<typeof PluginMirrorAxis>

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

@@ -1,19 +1,78 @@
 import * as z from "zod"
 import { PluginApiReturn } from "../../../types"
+import { ComponentHandle } from "../../../handles"
+import { PluginDesignChangeResult } from "../lock"
 
 /**
  * `snaptrude.design.furniture` — the placeable furniture **catalog** (a library of
- * source items, NOT scene entities). Placement lives at `design.create.furniture`
- * (returns a {@linkcode ComponentHandle}); reads of placed furniture live at
- * `design.query.listFurniture`/`getProperties`.
+ * source items, NOT scene entities) plus dimension reads/edits of PLACED furniture.
+ * Placement lives at `design.create.furniture` (returns a {@linkcode ComponentHandle});
+ * generic reads of placed furniture live at `design.query.listFurniture`/`getProperties`.
  *
  * Catalog items are plain value records ({@linkcode PluginFurnitureCatalogItem}) keyed
  * by a library id (team `_id` or general `fullName`) — not handles. Reads are async
  * (network-backed) but carry no `Async` suffix (§6.6).
+ *
+ * {@linkcode PluginDesignFurnitureApi.getDimensions} / {@linkcode PluginDesignFurnitureApi.setDimensions}
+ * target a PLACED furniture {@linkcode ComponentHandle} (not a catalog id) — `length`
+ * along the object, `width` across it, `height` up. Values are engine units, matching
+ * the length/width/height fields the furniture properties panel shows.
  */
 export abstract class PluginDesignFurnitureApi {
   constructor() {}
 
+  /**
+   * Get the dimensions of a PLACED furniture item — `length` (along the object),
+   * `width` (across it) and `height` (vertical), in engine units. Mirrors the
+   * Length/Width/Height fields of the furniture properties panel.
+   *
+   * @param item The placed furniture to query
+   * @returns The dimensions, or `null` if the geometry is degenerate
+   *
+   * @examplePrompt How big is this sofa?
+   * @examplePrompt What are the dimensions of the selected furniture?
+   * @examplePrompt Measure the length, width and height of this table
+   * @examplePrompt Get the size of the chair I just placed
+   *
+   * # Example
+   * ```ts
+   * const [item] = await snaptrude.design.query.listFurniture({ isSelected: true })
+   * const dims = await snaptrude.design.furniture.getDimensions(item)
+   * if (dims) console.log(dims.length, dims.width, dims.height)
+   * ```
+   */
+  public abstract getDimensions(
+    item: ComponentHandle
+  ): PluginApiReturn<PluginFurnitureDimensions | null>
+
+  /**
+   * Resize a PLACED furniture item along one or more axes — `length`, `width`
+   * and/or `height` (engine units). Omitted axes are left unchanged. Each supplied
+   * axis is an undoable command, mirroring editing the furniture properties panel.
+   *
+   * @param item The placed furniture to resize
+   * @param dimensions New `length` / `width` / `height` (each optional, engine units)
+   * @returns The affected furniture
+   *
+   * @examplePrompt Make this table 1.8m long
+   * @examplePrompt Resize the selected sofa to 2000 wide
+   * @examplePrompt Set this furniture to 800mm tall
+   * @examplePrompt Change the desk to 1500 long and 700 deep
+   *
+   * # Example
+   * ```ts
+   * const [item] = await snaptrude.design.query.listFurniture({ isSelected: true })
+   * const { affected } = await snaptrude.design.furniture.setDimensions(item, {
+   *   length: 1800,
+   *   height: 750
+   * })
+   * ```
+   */
+  public abstract setDimensions(
+    item: ComponentHandle,
+    dimensions: PluginFurnitureDimensionUpdates
+  ): PluginApiReturn<PluginDesignChangeResult>
+
   /**
    * List the categories (Living, Bedroom, Kitchen, …) that organize the
    * furniture catalog — the picker taxonomy, merged from built-in categories,
@@ -159,3 +218,68 @@ export type PluginDesignFurnitureGetCatalogItemArgs = z.infer<
 
 export const PluginDesignFurnitureExistsArgs = PluginDesignFurnitureGetCatalogItemArgs
 export type PluginDesignFurnitureExistsArgs = z.infer<typeof PluginDesignFurnitureExistsArgs>
+
+// ---------------------------------------------------------------------------
+// placed-furniture dimensions
+// ---------------------------------------------------------------------------
+
+/**
+ * A placed furniture item's dimensions (engine units).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `length` | `number` | Along the object (panel "Length") |
+ * | `width` | `number` | Across the object (panel "Width") |
+ * | `height` | `number` | Vertical (panel "Height") |
+ */
+export const PluginFurnitureDimensions = z.object({
+  length: z.number(),
+  width: z.number(),
+  height: z.number(),
+})
+export type PluginFurnitureDimensions = z.infer<typeof PluginFurnitureDimensions>
+
+/**
+ * Arguments for {@linkcode PluginDesignFurnitureApi.getDimensions}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `item` | {@linkcode ComponentHandle} | The placed furniture to query |
+ */
+export const PluginDesignFurnitureItemArgs = z.object({
+  item: ComponentHandle,
+})
+export type PluginDesignFurnitureItemArgs = z.infer<typeof PluginDesignFurnitureItemArgs>
+
+/**
+ * A partial dimension patch — each axis is optional; omitted axes are unchanged.
+ * Every supplied axis must be a positive engine-unit length.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `length` | `number`? | New length along the object (engine units, > 0) |
+ * | `width` | `number`? | New width across the object (engine units, > 0) |
+ * | `height` | `number`? | New height (engine units, > 0) |
+ */
+export const PluginFurnitureDimensionUpdates = z.object({
+  length: z.number().positive().optional(),
+  width: z.number().positive().optional(),
+  height: z.number().positive().optional(),
+})
+export type PluginFurnitureDimensionUpdates = z.infer<typeof PluginFurnitureDimensionUpdates>
+
+/**
+ * Arguments for {@linkcode PluginDesignFurnitureApi.setDimensions}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `item` | {@linkcode ComponentHandle} | The placed furniture to resize |
+ * | `dimensions` | {@linkcode PluginFurnitureDimensionUpdates} | The axes to change (each optional) |
+ */
+export const PluginDesignFurnitureSetDimensionsArgs = z.object({
+  item: ComponentHandle,
+  dimensions: PluginFurnitureDimensionUpdates,
+})
+export type PluginDesignFurnitureSetDimensionsArgs = z.infer<
+  typeof PluginDesignFurnitureSetDimensionsArgs
+>

package/src/api/design/index.ts

@@ -13,6 +13,8 @@ import { PluginDesignBooleanApi } from "./boolean"
 import { PluginDesignTransformApi } from "./transform"
 import { PluginDesignEditApi } from "./edit"
 import { PluginDesignUpdateApi } from "./update"
+import { PluginDesignVisibilityApi } from "./visibility"
+import { PluginDesignTypesApi } from "./types"
 import { PluginDesignChangeResult } from "./lock"
 
 /**
@@ -27,6 +29,8 @@ import { PluginDesignChangeResult } from "./lock"
  * - {@linkcode PluginDesignApi.boolean} — CSG boolean ops (union / subtract / intersect)
  * - {@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.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
  *
@@ -59,6 +63,10 @@ export abstract class PluginDesignApi {
   public abstract edit: PluginDesignEditApi
   /** Update existing entities — properties + geometry. See {@linkcode PluginDesignUpdateApi}. */
   public abstract update: PluginDesignUpdateApi
+  /** Hide / isolate / reveal entities. See {@linkcode PluginDesignVisibilityApi}. */
+  public abstract visibility: PluginDesignVisibilityApi
+  /** Read-only building type / assembly reference. See {@linkcode PluginDesignTypesApi}. */
+  public abstract types: PluginDesignTypesApi
 
   /**
    * Lock entities so they cannot be edited. Undoable. Cascades to void/door/window
@@ -247,3 +255,5 @@ export * from "./boolean"
 export * from "./transform"
 export * from "./edit"
 export * from "./update"
+export * from "./visibility"
+export * from "./types"

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

@@ -8,7 +8,9 @@ import { ComponentHandle, MaterialHandle } from "../../../handles"
  * Materials are {@linkcode MaterialHandle}s (entity-style, name-addressed). Reads return
  * a {@linkcode MaterialHandle}/{@linkcode PluginMaterialInfo}; `apply`/`reset` mutate the
  * scene (undoable via `save`, default `true`). `create` mints a material from a
- * {@linkcode PluginMaterialSpec} (idempotent by name).
+ * {@linkcode PluginMaterialSpec} (idempotent by name). `list` reads the materials loaded
+ * in the project; `listPresets` reads the browsable preset/library catalog (handle-less
+ * {@linkcode PluginPresetMaterial} records that become materials via `create`/`apply`).
  *
  * Per-face assignment — {@linkcode PluginDesignMaterialsApi.applyToFaces} /
  * {@linkcode PluginDesignMaterialsApi.resetFaces} plus per-face reads
@@ -24,23 +26,59 @@ export abstract class PluginDesignMaterialsApi {
   constructor() {}
 
   /**
-   * List the project materials.
-   * @param scope Which library to list (optional)
+   * List the materials loaded in the project — every named material in the live
+   * scene (applied finishes, plugin-created materials, and type defaults in use).
+   * For the browsable preset/library catalog (finishes not yet in the project),
+   * use {@linkcode PluginDesignMaterialsApi.listPresets}.
+   *
    * @returns The materials as {@linkcode MaterialHandle}`[]`
    *
    * @examplePrompt List all the materials in this project
    * @examplePrompt What materials do I have available to apply?
-   * @examplePrompt Show me the preset materials library
    * @examplePrompt Which finishes exist in this model?
    * @examplePrompt Get every material in the project palette
    *
    * # Example
    * ```ts
-   * const presets = await snaptrude.design.materials.list("preset")
-   * console.log(presets.length, "preset materials")
+   * const materials = await snaptrude.design.materials.list()
+   * console.log(materials.length, "materials in the project")
    * ```
    */
-  public abstract list(scope?: "project" | "preset"): PluginApiReturn<MaterialHandle[]>
+  public abstract list(): PluginApiReturn<MaterialHandle[]>
+
+  /**
+   * List the preset material library — the catalog the app's material browser
+   * shows (the built-in finishes plus the workspace's uploaded materials),
+   * fetched from the material library service. Library entries are **not**
+   * scene materials and carry no {@linkcode MaterialHandle}; each is a named
+   * texture record. To use one, feed it to
+   * {@linkcode PluginDesignMaterialsApi.create} /
+   * {@linkcode PluginDesignMaterialsApi.apply} as a
+   * {@linkcode PluginMaterialSpec}: `{ name, textureUrl, materialType: category }`.
+   *
+   * @returns The library as {@linkcode PluginPresetMaterial}`[]` (`[]` when the
+   * library service is unreachable)
+   *
+   * @examplePrompt Show me the preset materials library
+   * @examplePrompt What wood finishes are available in the material library?
+   * @examplePrompt Browse the material catalog and apply a brick texture
+   * @examplePrompt Which preset materials can I choose from?
+   *
+   * # Example
+   * ```ts
+   * const presets = await snaptrude.design.materials.listPresets()
+   * const brick = presets.find((p) => p.category.toLowerCase().includes("brick"))
+   * if (brick) {
+   *   const walls = await snaptrude.design.query.listWalls()
+   *   await snaptrude.design.materials.apply(walls, {
+   *     name: brick.name,
+   *     textureUrl: brick.textureUrl,
+   *     materialType: brick.category,
+   *   })
+   * }
+   * ```
+   */
+  public abstract listPresets(): PluginApiReturn<PluginPresetMaterial[]>
 
   /**
    * Read a material's descriptor — its name, color, opacity, and texture
@@ -61,7 +99,43 @@ export abstract class PluginDesignMaterialsApi {
    * if (info) console.log(info.name, info.colorHex, info.alpha)
    * ```
    */
-  public abstract getInfo(material: MaterialHandle): PluginApiReturn<PluginMaterialInfo | null>
+  public abstract getInfo(
+    material: MaterialHandle,
+  ): PluginApiReturn<PluginMaterialInfo | null>
+
+  /**
+   * Read the material applied to a component **as a whole** — the eyedropper. For a
+   * uniformly-painted component this is that single material; for a per-face-painted
+   * component it is the material on the component's base/first face. Use
+   * {@linkcode PluginDesignMaterialsApi.getByFace} /
+   * {@linkcode PluginDesignMaterialsApi.listByFace} for the per-face breakdown.
+   *
+   * @param component The component to sample
+   * @returns The whole-object material as a {@linkcode PluginComponentMaterial} — its
+   * handle (chain it into `apply` / `getInfo`), engine id, name, and whether the
+   * component carries its type `default` or an explicitly `applied` finish — or `null`
+   * if the component carries no material
+   *
+   * @examplePrompt What material is on this wall?
+   * @examplePrompt Eyedrop the finish of the selected object
+   * @examplePrompt Which material does this slab use?
+   * @examplePrompt Read the material on this column so I can paint others with it
+   * @examplePrompt Is this component painted, and with what?
+   *
+   * # Example
+   * ```ts
+   * const [component] = await snaptrude.design.selection.get()
+   * const sampled = await snaptrude.design.materials.get(component)
+   * if (sampled) {
+   *   console.log(sampled.name, sampled.source) // e.g. "Brick Red" "applied"
+   *   const info = await snaptrude.design.materials.getInfo(sampled.material)
+   *   console.log(info?.colorHex)
+   * }
+   * ```
+   */
+  public abstract get(
+    component: ComponentHandle,
+  ): PluginApiReturn<PluginComponentMaterial | null>
 
   /**
    * Apply a material to one or more components — an existing project material by
@@ -90,7 +164,7 @@ export abstract class PluginDesignMaterialsApi {
   public abstract apply(
     targets: ComponentHandle[],
     material: MaterialHandle | PluginMaterialSpec,
-    save?: boolean
+    save?: boolean,
   ): PluginApiReturn<PluginMaterialResult>
 
   /**
@@ -116,7 +190,7 @@ export abstract class PluginDesignMaterialsApi {
    */
   public abstract reset(
     components: ComponentHandle[],
-    save?: boolean
+    save?: boolean,
   ): PluginApiReturn<PluginMaterialResult>
 
   /**
@@ -155,7 +229,7 @@ export abstract class PluginDesignMaterialsApi {
     component: ComponentHandle,
     faces: number[],
     material: MaterialHandle | PluginMaterialSpec,
-    save?: boolean
+    save?: boolean,
   ): PluginApiReturn<PluginMaterialResult>
 
   /**
@@ -183,7 +257,7 @@ export abstract class PluginDesignMaterialsApi {
   public abstract resetFaces(
     component: ComponentHandle,
     faces: number[],
-    save?: boolean
+    save?: boolean,
   ): PluginApiReturn<PluginMaterialResult>
 
   /**
@@ -207,7 +281,7 @@ export abstract class PluginDesignMaterialsApi {
    */
   public abstract getByFace(
     component: ComponentHandle,
-    face: number
+    face: number,
   ): PluginApiReturn<MaterialHandle | null>
 
   /**
@@ -230,7 +304,7 @@ export abstract class PluginDesignMaterialsApi {
    * ```
    */
   public abstract listByFace(
-    component: ComponentHandle
+    component: ComponentHandle,
   ): PluginApiReturn<PluginFaceMaterial[]>
 
   /**
@@ -253,7 +327,9 @@ export abstract class PluginDesignMaterialsApi {
    * await snaptrude.design.materials.apply(walls, glass)
    * ```
    */
-  public abstract create(spec: PluginMaterialSpec): PluginApiReturn<MaterialHandle>
+  public abstract create(
+    spec: PluginMaterialSpec,
+  ): PluginApiReturn<MaterialHandle>
 
   /**
    * Get the default material for a component's type.
@@ -272,7 +348,9 @@ export abstract class PluginDesignMaterialsApi {
    * if (defaultMaterial) console.log(await snaptrude.design.materials.getInfo(defaultMaterial))
    * ```
    */
-  public abstract getDefault(component: ComponentHandle): PluginApiReturn<MaterialHandle | null>
+  public abstract getDefault(
+    component: ComponentHandle,
+  ): PluginApiReturn<MaterialHandle | null>
 
   /**
    * Test whether a component carries its (type) default material.
@@ -291,7 +369,9 @@ export abstract class PluginDesignMaterialsApi {
    * console.log(untouched ? "still default" : "has been painted")
    * ```
    */
-  public abstract isDefault(component: ComponentHandle): PluginApiReturn<boolean>
+  public abstract isDefault(
+    component: ComponentHandle,
+  ): PluginApiReturn<boolean>
 
   /**
    * Test whether a component has a single (uniform) material across all faces.
@@ -310,7 +390,9 @@ export abstract class PluginDesignMaterialsApi {
    * console.log(uniform ? "one material all over" : "painted per face")
    * ```
    */
-  public abstract isUniform(component: ComponentHandle): PluginApiReturn<boolean>
+  public abstract isUniform(
+    component: ComponentHandle,
+  ): PluginApiReturn<boolean>
 
   /**
    * Test whether a material has a texture.
@@ -392,18 +474,54 @@ export const PluginFaceMaterial = z.object({
 })
 export type PluginFaceMaterial = z.infer<typeof PluginFaceMaterial>
 
-/** Arguments for {@linkcode PluginDesignMaterialsApi.list}. */
-export const PluginDesignMaterialsListArgs = z.object({
-  scope: z.enum(["project", "preset"]).optional(),
+/**
+ * The material on a component **as a whole** — the eyedropper read returned by
+ * {@linkcode PluginDesignMaterialsApi.get} (value record, plus a reusable handle).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `material` | {@linkcode MaterialHandle} | The whole-object material — chain into `apply` / `getInfo` |
+ * | `id` | `string` | Engine material id |
+ * | `name` | `string` | Material name (== the handle token) |
+ * | `source` | `"default" \| "applied"` | Whether it is the component's type default or an explicitly-applied finish |
+ */
+export const PluginComponentMaterial = z.object({
+  material: MaterialHandle,
+  id: z.string(),
+  name: z.string(),
+  source: z.enum(["default", "applied"]),
+})
+export type PluginComponentMaterial = z.infer<typeof PluginComponentMaterial>
+
+/**
+ * A preset material library entry (value record — NOT a handle), returned by
+ * {@linkcode PluginDesignMaterialsApi.listPresets}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `name` | `string` | Display name of the library entry |
+ * | `category` | `string` | Library category (camelCase, e.g. `"wood"`, `"colors"`, `"brick"`) |
+ * | `textureUrl` | `string` | Texture/swatch image URL — feed to {@linkcode PluginMaterialSpec}`.textureUrl` |
+ */
+export const PluginPresetMaterial = z.object({
+  name: z.string(),
+  category: z.string(),
+  textureUrl: z.string(),
 })
-export type PluginDesignMaterialsListArgs = z.infer<typeof PluginDesignMaterialsListArgs>
+export type PluginPresetMaterial = z.infer<typeof PluginPresetMaterial>
 
 /** Arguments for {@linkcode PluginDesignMaterialsApi.getInfo} / `hasTexture`. */
-export const PluginDesignMaterialsGetInfoArgs = z.object({ material: MaterialHandle })
-export type PluginDesignMaterialsGetInfoArgs = z.infer<typeof PluginDesignMaterialsGetInfoArgs>
+export const PluginDesignMaterialsGetInfoArgs = z.object({
+  material: MaterialHandle,
+})
+export type PluginDesignMaterialsGetInfoArgs = z.infer<
+  typeof PluginDesignMaterialsGetInfoArgs
+>
 
 /** Arguments for component-scoped predicates (`getDefault`/`isDefault`/`isUniform`). */
-export const PluginDesignMaterialsComponentArgs = z.object({ component: ComponentHandle })
+export const PluginDesignMaterialsComponentArgs = z.object({
+  component: ComponentHandle,
+})
 export type PluginDesignMaterialsComponentArgs = z.infer<
   typeof PluginDesignMaterialsComponentArgs
 >
@@ -422,18 +540,26 @@ export const PluginDesignMaterialsApplyArgs = z.object({
   material: z.union([MaterialHandle, PluginMaterialSpec]),
   save: z.boolean().optional(),
 })
-export type PluginDesignMaterialsApplyArgs = z.infer<typeof PluginDesignMaterialsApplyArgs>
+export type PluginDesignMaterialsApplyArgs = z.infer<
+  typeof PluginDesignMaterialsApplyArgs
+>
 
 /** Arguments for {@linkcode PluginDesignMaterialsApi.reset}. */
 export const PluginDesignMaterialsResetArgs = z.object({
   components: z.array(ComponentHandle),
   save: z.boolean().optional(),
 })
-export type PluginDesignMaterialsResetArgs = z.infer<typeof PluginDesignMaterialsResetArgs>
+export type PluginDesignMaterialsResetArgs = z.infer<
+  typeof PluginDesignMaterialsResetArgs
+>
 
 /** Arguments for {@linkcode PluginDesignMaterialsApi.create}. */
-export const PluginDesignMaterialsCreateArgs = z.object({ spec: PluginMaterialSpec })
-export type PluginDesignMaterialsCreateArgs = z.infer<typeof PluginDesignMaterialsCreateArgs>
+export const PluginDesignMaterialsCreateArgs = z.object({
+  spec: PluginMaterialSpec,
+})
+export type PluginDesignMaterialsCreateArgs = z.infer<
+  typeof PluginDesignMaterialsCreateArgs
+>
 
 /**
  * Arguments for {@linkcode PluginDesignMaterialsApi.applyToFaces}.
@@ -475,7 +601,8 @@ export type PluginDesignMaterialsGetByFaceArgs = z.infer<
 >
 
 /** Arguments for {@linkcode PluginDesignMaterialsApi.listByFace} (component only). */
-export const PluginDesignMaterialsListByFaceArgs = PluginDesignMaterialsComponentArgs
+export const PluginDesignMaterialsListByFaceArgs =
+  PluginDesignMaterialsComponentArgs
 export type PluginDesignMaterialsListByFaceArgs = z.infer<
   typeof PluginDesignMaterialsListByFaceArgs
 >