@snaptrude/plugin-core 0.0.0-dev-20260708130115 → 0.0.0-dev-20260827135706

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

@@ -12,6 +12,13 @@ import { PluginDesignChangeResult } from "../lock"
  * mesh reflection state. `mirror` reflects the door across an axis (undoable, one
  * command); `setType` is intentionally absent (the engine has no in-place re-type —
  * it would require delete+recreate).
+ *
+ * The **catalog** reads (`listCatalogGroups`/`listCatalog`/`getCatalogItem`/`exists`)
+ * browse the placeable door library — plain value records keyed by a library id
+ * (team `_id` or general `fullName`), NOT handles — and feed `design.create.door`.
+ * They are network-backed but carry no `Async` suffix (§6.6) and never throw
+ * (`[]`/`null`). The {@linkcode PluginObjectCatalogGroup} / {@linkcode PluginObjectCatalogItem}
+ * DTOs are shared with `design.windows`.
  */
 export abstract class PluginDesignDoorsApi {
   constructor() {}
@@ -98,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.
@@ -224,6 +255,90 @@ export abstract class PluginDesignDoorsApi {
     doors: ComponentHandle[],
     height: number
   ): PluginApiReturn<PluginDesignChangeResult>
+
+  /**
+   * List the door catalog **groups** — the placement families (Swing, Sliding,
+   * Folding, Pivot, …), built-in groups merged with any team-custom types.
+   *
+   * @returns The groups as {@linkcode PluginObjectCatalogGroup}`[]` (`[]` when empty)
+   *
+   * @examplePrompt What kinds of doors can I place?
+   * @examplePrompt List the door groups in the catalog
+   * @examplePrompt Show me the door families available in this project
+   * @examplePrompt Which door types does this project support?
+   *
+   * # Example
+   * ```ts
+   * const groups = await snaptrude.design.doors.listCatalogGroups()
+   * for (const g of groups) console.log(g.dbType, g.label, g.source)
+   * ```
+   */
+  public abstract listCatalogGroups(): PluginApiReturn<PluginObjectCatalogGroup[]>
+
+  /**
+   * List the placeable door catalog (team + general libraries), optionally
+   * restricted to one group by its `dbType` token.
+   *
+   * @param group Restrict to one group's `dbType` (optional; e.g. `"singleDoor"`)
+   * @returns The catalog as {@linkcode PluginObjectCatalogItem}`[]` (`[]` when empty)
+   *
+   * @examplePrompt What doors can I place in this project?
+   * @examplePrompt List every door in the library
+   * @examplePrompt Show me the sliding doors I can add
+   * @examplePrompt Browse the door catalog
+   *
+   * # Example
+   * ```ts
+   * const [group] = await snaptrude.design.doors.listCatalogGroups()
+   * const items = await snaptrude.design.doors.listCatalog(group?.dbType)
+   * for (const item of items) console.log(item.id, item.name, item.thumbnailUrl)
+   * ```
+   */
+  public abstract listCatalog(
+    group?: string
+  ): PluginApiReturn<PluginObjectCatalogItem[]>
+
+  /**
+   * Get a single door catalog item by its library id.
+   *
+   * @param id The catalog library id
+   * @returns The item, or `null` if no catalog item matches
+   *
+   * @examplePrompt Get the details of this door from the library
+   * @examplePrompt Look up the catalog entry for this door id
+   * @examplePrompt What is the cost of this door item?
+   * @examplePrompt Show me the family name of this door in the catalog
+   *
+   * # Example
+   * ```ts
+   * const [entry] = await snaptrude.design.doors.listCatalog()
+   * const item = await snaptrude.design.doors.getCatalogItem(entry.id)
+   * if (item) console.log(item.name, item.source, item.dbType)
+   * ```
+   */
+  public abstract getCatalogItem(
+    id: string
+  ): PluginApiReturn<PluginObjectCatalogItem | null>
+
+  /**
+   * Test whether a door catalog item exists for the given library id.
+   *
+   * @param id The catalog library id
+   * @returns `true` if it exists, otherwise `false`
+   *
+   * @examplePrompt Is this door still in the library?
+   * @examplePrompt Check whether a door catalog item with this id exists
+   * @examplePrompt Does my team library have this door?
+   * @examplePrompt Verify the door is available before placing it
+   *
+   * # Example
+   * ```ts
+   * const [entry] = await snaptrude.design.doors.listCatalog()
+   * const stillAvailable = await snaptrude.design.doors.exists(entry.id)
+   * console.log(stillAvailable ? "safe to place" : "removed from library")
+   * ```
+   */
+  public abstract exists(id: string): PluginApiReturn<boolean>
 }
 
 /**
@@ -238,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>
@@ -283,3 +414,80 @@ export const PluginDesignDoorSetHeightArgs = z.object({
   height: z.number(),
 })
 export type PluginDesignDoorSetHeightArgs = z.infer<typeof PluginDesignDoorSetHeightArgs>
+
+// ---------------------------------------------------------------------------
+// catalog (shared by doors + windows)
+// ---------------------------------------------------------------------------
+
+/**
+ * A door/window catalog **group** — a placement family (e.g. Swing, Sliding,
+ * Casement). Shared by `design.doors` and `design.windows`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `dbType` | `string` | Stable engine token (e.g. `singleDoor`, `casementDouble`) |
+ * | `label` | `string` | Human-readable group label (e.g. `"Swing - 1 Shutter"`) |
+ * | `source` | `'default' \| 'team'` | Built-in group or a team-custom type |
+ */
+export const PluginObjectCatalogGroup = z.object({
+  dbType: z.string(),
+  label: z.string(),
+  source: z.enum(["default", "team"]),
+})
+export type PluginObjectCatalogGroup = z.infer<typeof PluginObjectCatalogGroup>
+
+/**
+ * A placeable door/window catalog **item** (value record — not a scene
+ * entity/handle). Shared by `design.doors` and `design.windows`; symmetric with
+ * {@linkcode PluginFurnitureCatalogItem}. The raw mesh (`.babylon`) URL is never
+ * exposed — only `thumbnailUrl`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | Library id (team `_id` or general `fullName`) — pass to `design.create.door`/`window` |
+ * | `name` | `string` | Display name |
+ * | `source` | `'team' \| 'general'` | Which library it came from |
+ * | `dbType` | `string` | The group token it belongs to (e.g. `singleDoor`) |
+ * | `subType` | `string`? | Engine sub-type (optional) |
+ * | `thumbnailUrl` | `string`? | Preview thumbnail URL (optional) |
+ * | `cost` | `number`? | Cost (optional; team items) |
+ * | `familyName` | `string`? | Family name (optional) |
+ */
+export const PluginObjectCatalogItem = z.object({
+  id: z.string(),
+  name: z.string(),
+  source: z.enum(["team", "general"]),
+  dbType: z.string(),
+  subType: z.string().optional(),
+  thumbnailUrl: z.string().optional(),
+  cost: z.number().optional(),
+  familyName: z.string().optional(),
+})
+export type PluginObjectCatalogItem = z.infer<typeof PluginObjectCatalogItem>
+
+/**
+ * Arguments for {@linkcode PluginDesignDoorsApi.listCatalog}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `group` | `string`? | Restrict to one group's `dbType` token (optional) |
+ */
+export const PluginDesignDoorListCatalogArgs = z.object({
+  group: z.string().optional(),
+})
+export type PluginDesignDoorListCatalogArgs = z.infer<typeof PluginDesignDoorListCatalogArgs>
+
+/**
+ * Arguments for {@linkcode PluginDesignDoorsApi.getCatalogItem} / {@linkcode PluginDesignDoorsApi.exists}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | The catalog library id |
+ */
+export const PluginDesignDoorGetCatalogItemArgs = z.object({
+  id: z.string(),
+})
+export type PluginDesignDoorGetCatalogItemArgs = z.infer<typeof PluginDesignDoorGetCatalogItemArgs>
+
+export const PluginDesignDoorExistsArgs = PluginDesignDoorGetCatalogItemArgs
+export type PluginDesignDoorExistsArgs = z.infer<typeof PluginDesignDoorExistsArgs>

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

@@ -35,7 +35,7 @@ export const ErasableEdgeRef = z.object({
   strategy: EraseStrategy,
   /** Bottom-graph edge weight: `1` = external boundary edge, `>=2` = internal edge shared between components. */
   edgeWeight: z.number(),
-  /** The components this edge is incident to — one for external (DirectDelete), two for internal (DirectUnion). */
+  /** The components this edge is incident to — one for external (DirectDelete); two or more for internal (DirectUnion; 3+ at T-junctions where several masses share the edge). */
   components: z.array(ComponentHandle),
   /** A representative point on the edge (its head endpoint). Diagnostic only. */
   snapPoint: Vec3Handle,

package/src/api/design/family.ts

@@ -0,0 +1,388 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+
+/**
+ * `snaptrude.design.family.*` — author NATIVE parametric families from a JSON spec.
+ *
+ * A parametric family is a reusable, parameter-driven building component: a
+ * curtain-wall panel, a louvre screen, a balustrade, a shading fin. Unlike the
+ * rest of `design.*`, you do not build one out of geometry calls — you write a
+ * JSON **spec** describing its parameters and its geometry rules, and the host
+ * compiles that into a live parametric definition the user can place, flex and
+ * save to their library.
+ *
+ * ## Workflow
+ *
+ * ```
+ * getReference()        read the spec DSL once — grammar, ops, expressions, example
+ * prepare({ bundle })   validate + compile + show a live ghost; nothing committed
+ * flex({ values })      re-run at new values; returns the geometry delta
+ * place()               arm placement — the USER clicks to drop it
+ * create({ name })      commit it to the project's family library
+ * ```
+ *
+ * ## Read getReference() first
+ *
+ * The spec DSL is a closed expression language with its own op set, coordinate
+ * convention (**+Y up, integer millimetres** — not Snaptrude's babylon units)
+ * and part-naming law. It is deliberately NOT duplicated in these types:
+ * {@linkcode PluginDesignFamilyApi.getReference} returns the whole reference,
+ * generated from a family that is actually registered in the host, so the
+ * documentation cannot drift from what the compiler accepts.
+ *
+ * ## The repair contract
+ *
+ * {@linkcode PluginDesignFamilyApi.prepare} does **not** throw on an invalid
+ * spec — it returns `{ ok: false, errors }` where each error carries a JSON
+ * pointer into the bundle you sent (e.g. `"/root/geometry/2/body/0/w"`). Read
+ * `errors[0].path`, fix that node, and call `prepare` again. A failed `prepare`
+ * leaves the previous good draft standing, so it costs nothing but the node you
+ * broke. Re-authoring from scratch throws away everything already correct.
+ *
+ * Accessed via `snaptrude.design.family`.
+ */
+export abstract class PluginDesignFamilyApi {
+  constructor() {}
+
+  /**
+   * Read the family-spec DSL reference: grammar, the op table, the expression
+   * whitelist, the coordinate convention, the repair contract, and a worked
+   * example taken from a registered family.
+   *
+   * Read this before authoring a family for the first time in a session. The
+   * DSL is a closed language — a guessed op or function is a rejected spec.
+   *
+   * @returns The reference text
+   *
+   * @examplePrompt How do I write a parametric family spec?
+   * @examplePrompt Show me the family DSL
+   *
+   * # Example
+   * ```ts
+   * const { reference } = await snaptrude.design.family.getReference()
+   * ```
+   */
+  public abstract getReference(): PluginApiReturn<PluginFamilyReference>
+
+  /**
+   * Validate, compile and preview a family spec. Nothing is committed to the
+   * model or the library — call {@linkcode PluginDesignFamilyApi.place} or
+   * {@linkcode PluginDesignFamilyApi.create} for that.
+   *
+   * Safe to call repeatedly while iterating. On success, check `partCount` and
+   * `bbox` against what you intended before treating the family as correct — a
+   * facade that built 3 parts, or a 3 m screen reporting 40 m of height, is a
+   * visible bug the validator cannot catch.
+   *
+   * @param args The spec bundle, as `{ bundle }` or `{ spec }`
+   * @returns Build report, or `{ ok: false, errors }` with JSON-pointer paths
+   *
+   * @examplePrompt Make a louvre screen with adjustable blade count and tilt
+   * @examplePrompt Design a curtain wall panel family with 8 bays
+   * @examplePrompt Create a railing family I can adjust
+   *
+   * # Example
+   * ```ts
+   * const r = await snaptrude.design.family.prepare({ bundle })
+   * if (!r.ok) console.error(r.errors[0].path, r.errors[0].message)
+   * ```
+   */
+  public abstract prepare(
+    args: PluginDesignFamilyPrepareArgs,
+  ): PluginApiReturn<PluginFamilyPrepareResult>
+
+  /**
+   * Re-run the prepared family's recipe at new parameter values.
+   *
+   * Values are merged over the current ones and clamped to the parameter
+   * sheet's min/max, so a partial `{ bays: 6 }` is fine. The returned `changed`
+   * buckets are the host's own diff of what the geometry did — flexing a
+   * driving parameter and reporting them demonstrates the family is parametric.
+   *
+   * @param args The parameter values to change
+   * @returns The new build plus the geometry delta
+   *
+   * @examplePrompt Change it to 6 bays
+   * @examplePrompt Show me what happens with 20 blades
+   *
+   * # Example
+   * ```ts
+   * const { changed } = await snaptrude.design.family.flex({ values: { bays: 6 } })
+   * console.log(`removed ${changed.removed}, rebuilt ${changed.rebuilt}`)
+   * ```
+   */
+  public abstract flex(
+    args: PluginDesignFamilyFlexArgs,
+  ): PluginApiReturn<PluginFamilyFlexResult>
+
+  /**
+   * The prepared family's spec bundle, or `null` when nothing is prepared.
+   *
+   * @returns The draft bundle, or `null`
+   *
+   * # Example
+   * ```ts
+   * const bundle = await snaptrude.design.family.get()
+   * ```
+   */
+  public abstract get(): PluginApiReturn<PluginFamilyBundle | null>
+
+  /**
+   * Every parametric family registered in this session — native and imported.
+   *
+   * @returns One summary per family
+   *
+   * @examplePrompt What families are available?
+   *
+   * # Example
+   * ```ts
+   * const families = await snaptrude.design.family.list()
+   * ```
+   */
+  public abstract list(): PluginApiReturn<PluginFamilySummary[]>
+
+  /**
+   * Arm placement with the prepared family.
+   *
+   * This does **not** create geometry. It puts the editor into placement mode
+   * with a ghost on the cursor; the user clicks in the canvas to drop it, the
+   * same as for any other family. Tell the user to click.
+   *
+   * @returns Which family was armed
+   *
+   * @examplePrompt Place it in the model
+   * @examplePrompt Let me put this on the facade
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.design.family.place()
+   * ```
+   */
+  public abstract place(): PluginApiReturn<PluginFamilyPlaceResult>
+
+  /**
+   * Commit the prepared bundle to the project's parametric-definition library,
+   * so it survives the session and appears in the Families panel.
+   *
+   * @param args Optional library name and team scope
+   * @returns The catalogued definition's id and version
+   *
+   * @examplePrompt Save this as a family called Vertical Louvre
+   * @examplePrompt Add it to my library
+   *
+   * # Example
+   * ```ts
+   * const { definitionId } = await snaptrude.design.family.create({ name: "Louvre Screen" })
+   * ```
+   */
+  public abstract create(
+    args?: PluginDesignFamilyCreateArgs,
+  ): PluginApiReturn<PluginFamilyCreateResult>
+}
+
+// ---------------------------------------------------------------------------
+// Result types
+// ---------------------------------------------------------------------------
+
+/** The family-spec DSL reference returned by `getReference`. */
+export interface PluginFamilyReference {
+  /** Grammar, op table, expression whitelist, repair contract, worked example. */
+  reference: string
+}
+
+/**
+ * A family spec bundle. `root` is the family; `deps` carries every spec
+ * reachable through an `instance` op, keyed by spec id, so a saved family is
+ * self-contained and reloads anywhere.
+ *
+ * The internal shape of a spec is documented by
+ * {@linkcode PluginDesignFamilyApi.getReference}, not by these types — it is a
+ * data DSL whose grammar changes independently of this API surface.
+ */
+export interface PluginFamilyBundle {
+  root: Record<string, unknown>
+  deps?: Record<string, Record<string, unknown>>
+}
+
+/** Axis-aligned extents of a built family. Integer millimetres, +Y up. */
+export interface PluginFamilyBBox {
+  min: [number, number, number]
+  max: [number, number, number]
+  /** `[width, height, depth]` in millimetres. */
+  size: [number, number, number]
+}
+
+/** One row of a family's parameter sheet. */
+export interface PluginFamilyParameter {
+  key: string
+  label: string
+  type: "length" | "integer" | "enum" | "text" | "boolean"
+  /** Current value. `length`/`integer` are numbers; the rest are strings. */
+  value: string | number
+  default: string | number
+  /**
+   * Whether this parameter actually drives geometry — INFERRED by the host from
+   * which names the spec's expressions reference. `false` means the value is
+   * stored and round-tripped but moves nothing.
+   */
+  drivesGeometry: boolean
+  min?: number
+  max?: number
+  options?: readonly string[]
+}
+
+/**
+ * A validation diagnostic. `path` is a JSON pointer into the submitted bundle —
+ * fix that node and re-`prepare`.
+ */
+export interface PluginFamilyDiagnostic {
+  /** JSON pointer, e.g. `"/root/geometry/2/body/0/w"`. */
+  path: string
+  code:
+    | "schema"
+    | "bad-expression"
+    | "unknown-name"
+    | "unknown-def"
+    | "cycle"
+    | "duplicate-name"
+    | "unbounded-repeat"
+    | "depth"
+    | "bad-dimension"
+  message: string
+  hint?: string
+}
+
+/** What `prepare` reports. */
+export interface PluginFamilyPrepareResult {
+  /** `false` means the spec was rejected — read `errors`, fix, re-prepare. */
+  ok: boolean
+  familyId?: string
+  version?: number
+  label?: string
+  /** How many parts the family built. Sanity-check against intent. */
+  partCount?: number
+  /** Extents in millimetres. Sanity-check against intent. */
+  bbox?: PluginFamilyBBox
+  evalMs?: number
+  parameters?: PluginFamilyParameter[]
+  /** Computed quantities, when the spec declares a `takeoff` block. */
+  takeoff?: Record<string, number | string>
+  /** The first few part names — enough to check the naming came out right. */
+  sampleParts?: string[]
+  errors: PluginFamilyDiagnostic[]
+  warnings: PluginFamilyDiagnostic[]
+  /** Set when the bundle validated but threw while building. */
+  error?: string
+}
+
+/**
+ * The host's diff of what a flex did to the geometry. This is the evidence that
+ * a family is parametric.
+ */
+export interface PluginFamilyChangeBuckets {
+  added: number
+  removed: number
+  moved: number
+  rebuilt: number
+  addedNames: string[]
+  removedNames: string[]
+}
+
+/** What `flex` reports. */
+export interface PluginFamilyFlexResult {
+  ok: boolean
+  /** The RESOLVED values after merge + clamping — not necessarily what was sent. */
+  values?: Record<string, number | string>
+  partCount?: number
+  bbox?: PluginFamilyBBox
+  evalMs?: number
+  changed?: PluginFamilyChangeBuckets
+  takeoff?: Record<string, number | string>
+  error?: string
+}
+
+/** One registered parametric family. */
+export interface PluginFamilySummary {
+  id: string
+  version: number
+  label: string
+  category?: string
+  /** Number of rows on the family's parameter sheet. */
+  parameters: number
+}
+
+/** What `place` reports. */
+export interface PluginFamilyPlaceResult {
+  ok: boolean
+  familyId?: string
+  version?: number
+  error?: string
+}
+
+/** What `create` reports. */
+export interface PluginFamilyCreateResult {
+  ok: boolean
+  definitionId?: string
+  version?: number
+  guid?: string
+  error?: string
+}
+
+// ---------------------------------------------------------------------------
+// Argument schemas
+// ---------------------------------------------------------------------------
+
+/**
+ * A spec bundle as it crosses the boundary: `root` plus optional `deps`.
+ *
+ * Loose by design — the spec grammar is a data DSL validated by the host's own
+ * validator, which returns JSON-pointer diagnostics far more useful than a Zod
+ * shape error. This schema only guarantees the envelope is an object.
+ */
+export const PluginFamilyBundleSchema = z.object({
+  root: z.record(z.string(), z.unknown()),
+  deps: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
+})
+
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.prepare}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `bundle` | {@linkcode PluginFamilyBundle} | The family spec bundle |
+ * | `spec` | {@linkcode PluginFamilyBundle} | Alias for `bundle` |
+ *
+ * Exactly one of `bundle` / `spec` is required. A bare `FamilySpec` (no `root`
+ * wrapper) is also accepted by the host and wrapped for the caller.
+ */
+export const PluginDesignFamilyPrepareArgs = z.object({
+  bundle: PluginFamilyBundleSchema.optional(),
+  spec: PluginFamilyBundleSchema.optional(),
+})
+export type PluginDesignFamilyPrepareArgs = z.infer<typeof PluginDesignFamilyPrepareArgs>
+
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.flex}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `values` | `Record<string, number \| string>` | Parameter values to change (partial) |
+ */
+export const PluginDesignFamilyFlexArgs = z.object({
+  values: z.record(z.string(), z.union([z.number(), z.string()])),
+})
+export type PluginDesignFamilyFlexArgs = z.infer<typeof PluginDesignFamilyFlexArgs>
+
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.create}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `name` | `string` | Library name; defaults to the spec's own label |
+ * | `teamId` | `string` | Team library to save into; omit for personal |
+ */
+export const PluginDesignFamilyCreateArgs = z.object({
+  name: z.string().optional(),
+  teamId: z.string().optional(),
+})
+export type PluginDesignFamilyCreateArgs = z.infer<typeof PluginDesignFamilyCreateArgs>