@snaptrude/plugin-core 0.0.0-bimsvg-20260928124803

package/src/api/entity/buildableEnvelope.ts

@@ -0,0 +1,322 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+
+/**
+ * Buildable Envelope management — create and update parametric zoning envelopes.
+ *
+ * A **buildable envelope** is the regulated volume inside which a building may
+ * be massed. The host owns envelope identity: {@linkcode PluginBuildableEnvelopeApi.create create}
+ * mints a `buildableEnvelopeId` and returns it; {@linkcode PluginBuildableEnvelopeApi.update update}
+ * requires that id to target the existing envelope.
+ *
+ * Accessed via `snaptrude.entity.buildableEnvelope`.
+ */
+export abstract class PluginBuildableEnvelopeApi {
+  constructor() {}
+
+  /**
+   * Create a new parametric buildable envelope — the zoning-regulated volume a
+   * building may occupy — generated from a site polygon, tiered setbacks, a
+   * height or floor-count cap, and optional FAR and lot-coverage limits.
+   *
+   * @param sitePolygon - Site polygon vertices in `lengthUnit`; minimum 3 vertices.
+   * @param lengthUnit - Unit used by all length fields (`"ft" | "m"`).
+   * @param setbacks - Setback profile, ground tier first; minimum 1 tier.
+   * @param verticalCap - Maximum height or floor count.
+   * @param floorToFloor - Required floor-to-floor height in `lengthUnit`.
+   * @param farRatio - Optional FAR value, positive when provided.
+   * @param lotCoverageMaxPct - Optional lot coverage cap, `0..100`.
+   * @returns A {@linkcode PluginBuildableEnvelopeCreateResult} with the
+   *   `buildableEnvelopeId` of the created envelope.
+   * @throws If validation fails or generation produces no renderable geometry.
+   *
+   * @examplePrompt Create a buildable envelope for my site
+   * @examplePrompt Generate the zoning envelope with 10ft front setbacks
+   * @examplePrompt Show the maximum buildable volume with a 150ft height limit
+   * @examplePrompt Model the allowable massing from the setback rules
+   * @examplePrompt Create a zoning envelope capped at 12 floors with FAR 3
+   *
+   * # Example
+   * ```ts
+   * const { buildableEnvelopeId } = await snaptrude.entity.buildableEnvelope.create(
+   *   [
+   *     { x: 0, z: 0 },
+   *     { x: 100, z: 0 },
+   *     { x: 100, z: 80 },
+   *     { x: 0, z: 80 },
+   *   ],
+   *   "ft",
+   *   [
+   *     { aboveHeight: 0, front: 10, side: 5, rear: 10 },
+   *     { aboveHeight: 100, front: 20, side: 10, rear: 20 },
+   *   ],
+   *   { kind: "max_height", maxHeight: 150 },
+   *   12,
+   * )
+   * ```
+   *
+   * @deprecated Use `design.create.buildableEnvelope`
+   */
+  public abstract create(
+    sitePolygon: PluginBuildableEnvelopePolygonVertex[],
+    lengthUnit: "ft" | "m",
+    setbacks: PluginBuildableEnvelopeSetbackTier[],
+    verticalCap: PluginBuildableEnvelopeVerticalCap,
+    floorToFloor: number,
+    farRatio?: number,
+    lotCoverageMaxPct?: number
+  ): PluginApiReturn<PluginBuildableEnvelopeCreateResult>
+
+  /**
+   * Update an existing parametric buildable envelope — regenerate the zoning
+   * volume from a revised site polygon, setbacks, vertical cap, or FAR and
+   * lot-coverage limits, keeping the same envelope id.
+   *
+   * @param buildableEnvelopeId - Existing envelope ID to update; non-empty and
+   *   must match an existing envelope on the canvas.
+   * @param sitePolygon - Site polygon vertices in `lengthUnit`; minimum 3 vertices.
+   * @param lengthUnit - Unit used by all length fields (`"ft" | "m"`).
+   * @param setbacks - Setback profile, ground tier first; minimum 1 tier.
+   * @param verticalCap - Maximum height or floor count.
+   * @param floorToFloor - Required floor-to-floor height in `lengthUnit`.
+   * @param farRatio - Optional FAR value, positive when provided.
+   * @param lotCoverageMaxPct - Optional lot coverage cap, `0..100`.
+   * @returns A {@linkcode PluginBuildableEnvelopeUpdateResult} with the
+   *   `buildableEnvelopeId` of the updated envelope.
+   * @throws If validation fails, the envelope does not exist, or generation
+   *   produces no renderable geometry.
+   *
+   * @examplePrompt Change the envelope's height limit to 175 feet
+   * @examplePrompt Update the setbacks on the buildable envelope
+   * @examplePrompt Regenerate the zoning envelope with a new site boundary
+   * @examplePrompt Increase the FAR on the buildable volume
+   * @examplePrompt Modify the envelope to allow 15 storeys instead
+   *
+   * # Example
+   * ```ts
+   * const { buildableEnvelopeId } = await snaptrude.entity.buildableEnvelope.update(
+   *   existingId,
+   *   [
+   *     { x: 0, z: 0 },
+   *     { x: 100, z: 0 },
+   *     { x: 100, z: 80 },
+   *     { x: 0, z: 80 },
+   *   ],
+   *   "ft",
+   *   [{ aboveHeight: 0, front: 10, side: 5, rear: 10 }],
+   *   { kind: "max_height", maxHeight: 175 },
+   *   12,
+   * )
+   * ```
+   *
+   * @deprecated Use `design.update.buildableEnvelope`
+   */
+  public abstract update(
+    buildableEnvelopeId: string,
+    sitePolygon: PluginBuildableEnvelopePolygonVertex[],
+    lengthUnit: "ft" | "m",
+    setbacks: PluginBuildableEnvelopeSetbackTier[],
+    verticalCap: PluginBuildableEnvelopeVerticalCap,
+    floorToFloor: number,
+    farRatio?: number,
+    lotCoverageMaxPct?: number
+  ): PluginApiReturn<PluginBuildableEnvelopeUpdateResult>
+}
+
+/**
+ * Site polygon vertex in the request `lengthUnit`.
+ *
+ * Vertices may be passed as `{x, z}` objects or `[x, z]` tuples. Numeric
+ * values must be finite (no `NaN` or `±Infinity`).
+ */
+export const PluginBuildableEnvelopePolygonVertex = z.union([
+  z.object({ x: z.number().finite(), z: z.number().finite() }).strict(),
+  z.tuple([z.number().finite(), z.number().finite()]),
+])
+
+export type PluginBuildableEnvelopePolygonVertex = z.infer<
+  typeof PluginBuildableEnvelopePolygonVertex
+>
+
+/**
+ * Vertical cap for a buildable envelope.
+ *
+ * Use exactly one shape:
+ * - `{ kind: "max_height", maxHeight }`
+ * - `{ kind: "max_floors", maxFloors }`
+ *
+ * Floor-to-floor height is not nested here; it is always supplied as the
+ * top-level `floorToFloor` argument.
+ */
+export const PluginBuildableEnvelopeVerticalCap = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("max_height"),
+    maxHeight: z.number().finite().positive(),
+  }).strict(),
+  z.object({
+    kind: z.literal("max_floors"),
+    maxFloors: z.number().finite().int().positive(),
+  }).strict(),
+])
+
+export type PluginBuildableEnvelopeVerticalCap = z.infer<
+  typeof PluginBuildableEnvelopeVerticalCap
+>
+
+/**
+ * One tier of a buildable envelope's setback profile.
+ *
+ * Tiers are ordered by `aboveHeight`. The first tier (index 0) must have
+ * `aboveHeight: 0` and describes the ground footprint; each subsequent tier
+ * describes the complete setback at a strictly greater height. Each tier
+ * carries its own `front`, `side`, and `rear` values — there is no
+ * inheritance from earlier tiers.
+ *
+ * All numeric values must be finite and nonnegative, in the request
+ * `lengthUnit`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `aboveHeight` | `number` | Height at or above which this tier applies; the ground tier uses `0` |
+ * | `front` | `number` | Front setback for this tier |
+ * | `side` | `number` | Side setback for this tier |
+ * | `rear` | `number` | Rear setback for this tier |
+ */
+export const PluginBuildableEnvelopeSetbackTier = z.object({
+  aboveHeight: z.number().finite().nonnegative(),
+  front: z.number().finite().nonnegative(),
+  side: z.number().finite().nonnegative(),
+  rear: z.number().finite().nonnegative(),
+}).strict()
+
+export type PluginBuildableEnvelopeSetbackTier = z.infer<
+  typeof PluginBuildableEnvelopeSetbackTier
+>
+
+// Enforces setback tier ordering invariants on the parsed args shape:
+//   - setbacks[0].aboveHeight === 0
+//   - aboveHeight strictly increasing thereafter
+// Length >= 1 is enforced earlier by z.array(...).min(1).
+function refineSetbackTiers(
+  args: { setbacks: PluginBuildableEnvelopeSetbackTier[] },
+  ctx: z.RefinementCtx
+): void {
+  const tiers = args.setbacks
+  if (tiers.length === 0) return
+  if (tiers[0].aboveHeight !== 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["setbacks", 0, "aboveHeight"],
+      message: "Ground tier required: setbacks[0].aboveHeight must be 0.",
+    })
+  }
+  for (let i = 1; i < tiers.length; i++) {
+    if (!(tiers[i].aboveHeight > tiers[i - 1].aboveHeight)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["setbacks", i, "aboveHeight"],
+        message:
+          "Setback tiers must be ordered by strictly increasing aboveHeight.",
+      })
+    }
+  }
+}
+
+/**
+ * Arguments for {@linkcode PluginBuildableEnvelopeApi.create}.
+ *
+ * Strict schema. The host owns identity — no `buildableEnvelopeId` is accepted
+ * on create; the id is minted by the host and returned in
+ * {@linkcode PluginBuildableEnvelopeCreateResult}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `sitePolygon` | {@linkcode PluginBuildableEnvelopePolygonVertex}`[]` | Site polygon vertices in `lengthUnit`; minimum 3 vertices |
+ * | `lengthUnit` | `"ft" \| "m"` | Unit used by all length fields |
+ * | `setbacks` | {@linkcode PluginBuildableEnvelopeSetbackTier}`[]` | Setback profile, ground tier first; minimum 1 tier |
+ * | `verticalCap` | {@linkcode PluginBuildableEnvelopeVerticalCap} | Maximum height or floor count |
+ * | `floorToFloor` | `number` | Required floor-to-floor height in `lengthUnit` |
+ * | `farRatio` | `number?` | Optional FAR value, positive when provided |
+ * | `lotCoverageMaxPct` | `number?` | Optional lot coverage cap, `0..100` |
+ */
+export const PluginBuildableEnvelopeCreateArgs = z
+  .object({
+    sitePolygon: z.array(PluginBuildableEnvelopePolygonVertex).min(3),
+    lengthUnit: z.union([z.literal("ft"), z.literal("m")]),
+    setbacks: z.array(PluginBuildableEnvelopeSetbackTier).min(1),
+    verticalCap: PluginBuildableEnvelopeVerticalCap,
+    floorToFloor: z.number().finite().positive(),
+    farRatio: z.number().finite().positive().optional(),
+    lotCoverageMaxPct: z.number().finite().min(0).max(100).optional(),
+  })
+  .strict()
+  .superRefine(refineSetbackTiers)
+
+export type PluginBuildableEnvelopeCreateArgs = z.infer<
+  typeof PluginBuildableEnvelopeCreateArgs
+>
+
+/**
+ * Result of {@linkcode PluginBuildableEnvelopeApi.create}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `buildableEnvelopeId` | `string` | Non-empty unique ID of the created buildable envelope |
+ */
+export const PluginBuildableEnvelopeCreateResult = z.object({
+  buildableEnvelopeId: z.string().min(1),
+}).strict()
+
+export type PluginBuildableEnvelopeCreateResult = z.infer<
+  typeof PluginBuildableEnvelopeCreateResult
+>
+
+/**
+ * Arguments for {@linkcode PluginBuildableEnvelopeApi.update}.
+ *
+ * Strict schema. `buildableEnvelopeId` is required and identifies the prior
+ * envelope on the canvas to update.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `buildableEnvelopeId` | `string` | Existing envelope ID to update; non-empty |
+ * | `sitePolygon` | {@linkcode PluginBuildableEnvelopePolygonVertex}`[]` | Site polygon vertices in `lengthUnit`; minimum 3 vertices |
+ * | `lengthUnit` | `"ft" \| "m"` | Unit used by all length fields |
+ * | `setbacks` | {@linkcode PluginBuildableEnvelopeSetbackTier}`[]` | Setback profile, ground tier first; minimum 1 tier |
+ * | `verticalCap` | {@linkcode PluginBuildableEnvelopeVerticalCap} | Maximum height or floor count |
+ * | `floorToFloor` | `number` | Required floor-to-floor height in `lengthUnit` |
+ * | `farRatio` | `number?` | Optional FAR value, positive when provided |
+ * | `lotCoverageMaxPct` | `number?` | Optional lot coverage cap, `0..100` |
+ */
+export const PluginBuildableEnvelopeUpdateArgs = z
+  .object({
+    buildableEnvelopeId: z.string().min(1),
+    sitePolygon: z.array(PluginBuildableEnvelopePolygonVertex).min(3),
+    lengthUnit: z.union([z.literal("ft"), z.literal("m")]),
+    setbacks: z.array(PluginBuildableEnvelopeSetbackTier).min(1),
+    verticalCap: PluginBuildableEnvelopeVerticalCap,
+    floorToFloor: z.number().finite().positive(),
+    farRatio: z.number().finite().positive().optional(),
+    lotCoverageMaxPct: z.number().finite().min(0).max(100).optional(),
+  })
+  .strict()
+  .superRefine(refineSetbackTiers)
+
+export type PluginBuildableEnvelopeUpdateArgs = z.infer<
+  typeof PluginBuildableEnvelopeUpdateArgs
+>
+
+/**
+ * Result of {@linkcode PluginBuildableEnvelopeApi.update}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `buildableEnvelopeId` | `string` | Non-empty unique ID of the updated buildable envelope |
+ */
+export const PluginBuildableEnvelopeUpdateResult = z.object({
+  buildableEnvelopeId: z.string().min(1),
+}).strict()
+
+export type PluginBuildableEnvelopeUpdateResult = z.infer<
+  typeof PluginBuildableEnvelopeUpdateResult
+>

package/src/api/entity/index.ts

@@ -0,0 +1,30 @@
+import { PluginBuildableEnvelopeApi } from "./buildableEnvelope"
+import { PluginReferenceLineApi } from "./referenceLine"
+import { PluginStoryApi } from "./story"
+
+/**
+ * CRUD operations on Snaptrude building entities.
+ *
+ * - {@linkcode PluginEntityApi.story} — Create, query, and update stories (floors)
+ * - {@linkcode PluginEntityApi.referenceLine} — Create, query, and delete reference lines
+ * - {@linkcode PluginEntityApi.buildableEnvelope} — Create or update parametric buildable envelopes
+ *
+ * Space operations moved to `design.create.spaces` / `design.update.*` /
+ * `design.query.*` / `design.delete.entities` (the `entity.space` API was removed);
+ * `./space` still exports the shared space value types.
+ */
+export abstract class PluginEntityApi {
+  /** Story (floor/storey) operations. See {@linkcode PluginStoryApi}. */
+  public abstract story: PluginStoryApi
+  /** Reference line operations. See {@linkcode PluginReferenceLineApi}. */
+  public abstract referenceLine: PluginReferenceLineApi
+  /** Buildable Envelope operations. See {@linkcode PluginBuildableEnvelopeApi}. */
+  public abstract buildableEnvelope: PluginBuildableEnvelopeApi
+
+  constructor() {}
+}
+
+export * from "./buildableEnvelope"
+export * from "./referenceLine"
+export * from "./space"
+export * from "./story"

package/src/api/entity/referenceLine.ts

@@ -0,0 +1,235 @@
+import * as z from "zod"
+import { PluginApiReturn } from "../../types"
+import { ProfileHandle, CurveHandle } from "../../handles"
+
+/**
+ * Reference line management — create, query, and delete reference lines.
+ *
+ * A **reference line** is a 2D guide line (or arc) in the Snaptrude scene,
+ * typically used for grid lines and alignment guides. Reference lines
+ * carry properties such as grid tags, labels, and line styles.
+ *
+ * All methods are **host API calls** that return Promises and support
+ * undo/redo via Snaptrude's command system.
+ *
+ * Accessed via `snaptrude.entity.referenceLine`.
+ */
+export abstract class PluginReferenceLineApi {
+  constructor() {}
+
+  /**
+   * Create multiple reference lines from a profile.
+   *
+   * Each curve in the given {@linkcode ProfileHandle} becomes
+   * a separate reference line. Uses `ReferenceLineConstructor.createFromProfile`
+   * internally.
+   *
+   * @param profile - A {@linkcode ProfileHandle} whose curves define the
+   *   reference lines to create
+   * @returns A {@linkcode PluginReferenceLineCreateMultiResult} with the
+   *   `referenceLineIds` of the created reference lines
+   * @throws If reference line creation fails
+   *
+   * @examplePrompt Draw grid lines across the site
+   * @examplePrompt Create reference lines from these curves
+   * @examplePrompt Add alignment guides along the building edge
+   * @examplePrompt Set up a structural grid using guide lines
+   * @examplePrompt Turn this profile into reference lines
+   *
+   * # Example
+   * ```ts
+   * const { vec3 } = snaptrude.core.math
+   *
+   * const start = await vec3.new(0, 0, 0)
+   * const mid = await vec3.new(10, 0, 0)
+   * const end = await vec3.new(10, 0, 10)
+   * const l1 = await snaptrude.core.geom.create.line(start, mid)
+   * const l2 = await snaptrude.core.geom.create.line(mid, end)
+   * const profile = await snaptrude.core.geom.create.profileFromCurves([l1, l2])
+   *
+   * const { referenceLineIds } = await snaptrude.entity.referenceLine.createMulti(profile)
+   * ```
+   *
+   * @deprecated Use `design.create.referenceLines`
+   */
+  public abstract createMulti(
+    profile: ProfileHandle
+  ): PluginApiReturn<PluginReferenceLineCreateMultiResult>
+
+  /**
+   * Get properties of a reference line by its ID.
+   *
+   * Only the properties listed in `properties` are returned — unlisted
+   * properties will be `undefined` in the result.
+   *
+   * @param referenceLineId - The unique reference line ID
+   * @param properties - Array of property names to retrieve. See
+   *   {@linkcode PluginReferenceLineGetProperty}.
+   * @returns A partial {@linkcode PluginReferenceLineGetResult} containing only the
+   *   requested properties
+   * @throws If the reference line does not exist
+   *
+   * @examplePrompt Get the curve geometry of this reference line
+   * @examplePrompt Where does this grid line run?
+   * @examplePrompt Read the geometry of a guide line by its id
+   * @examplePrompt Look up the curve of the selected reference line
+   *
+   * # Example
+   * ```ts
+   * const result = await snaptrude.entity.referenceLine.get("some-ref-line-id", ["curve"])
+   * // result.curve is an opaque CurveHandle; a dedicated curve read API for its
+   * // coordinates is exposed separately via `snaptrude.core.geom.curve`.
+   * ```
+   *
+   * @deprecated Use `design.query.referenceLines.get`
+   */
+  public abstract get(
+    referenceLineId: string,
+    properties: z.infer<typeof PluginReferenceLineGetProperty>[]
+  ): PluginApiReturn<PluginReferenceLineGetResult>
+
+  /**
+   * Get the IDs of all reference lines in the current project.
+   *
+   * Returns every reference line across all stories.
+   * Use the returned IDs with {@linkcode PluginReferenceLineApi.get} to query
+   * individual reference line properties.
+   *
+   * @returns A {@linkcode PluginReferenceLineGetAllResult} with a
+   *   `referenceLineIds` array
+   *
+   * @examplePrompt How many grid lines are in the project?
+   * @examplePrompt List all the reference lines in my model
+   * @examplePrompt Show every guide line in the file
+   * @examplePrompt Do I have any reference lines in this project?
+   *
+   * # Example
+   * ```ts
+   * const { referenceLineIds } = await snaptrude.entity.referenceLine.getAll()
+   * console.log(`Project has ${referenceLineIds.length} reference lines`)
+   * ```
+   *
+   * @deprecated Use `design.query.listReferenceLines`
+   */
+  public abstract getAll(): PluginApiReturn<PluginReferenceLineGetAllResult>
+
+  /**
+   * Delete a reference line by its ID.
+   *
+   * Permanently removes the reference line and its associated mesh from
+   * the scene. This operation is undoable via Snaptrude's command system.
+   *
+   * @param referenceLineId - The unique reference line ID to delete
+   * @throws If the reference line does not exist
+   *
+   * @examplePrompt Delete this reference line
+   * @examplePrompt Remove the grid line I just drew
+   * @examplePrompt Get rid of the alignment guide on the left
+   * @examplePrompt Erase a reference line by its id
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.entity.referenceLine.delete("some-ref-line-id")
+   * ```
+   *
+   * @deprecated Use `design.delete.entities`
+   */
+  public abstract delete(
+    referenceLineId: string
+  ): PluginApiReturn<PluginReferenceLineDeleteResult>
+}
+
+/**
+ * Arguments for {@linkcode PluginReferenceLineApi.createMulti}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `profile` | {@linkcode ProfileHandle} | Profile handle whose curves define reference lines |
+ */
+export const PluginReferenceLineCreateMultiArgs = z.object({
+  profile: ProfileHandle,
+})
+
+export type PluginReferenceLineCreateMultiArgs = z.infer<typeof PluginReferenceLineCreateMultiArgs>
+
+/**
+ * Result of {@linkcode PluginReferenceLineApi.createMulti}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `referenceLineIds` | `string[]` | IDs of the created reference lines |
+ */
+export const PluginReferenceLineCreateMultiResult = z.object({
+  referenceLineIds: z.array(z.string()),
+})
+
+export type PluginReferenceLineCreateMultiResult = z.infer<typeof PluginReferenceLineCreateMultiResult>
+
+/**
+ * Available properties that can be queried on a reference line.
+ *
+ * | Value | Return Type | Description |
+ * |---|---|---|
+ * | `"curve"` | {@linkcode CurveHandle} | The curve geometry of the reference line, as an opaque handle |
+ */
+export const PluginReferenceLineGetProperty = z.enum([
+  "curve",
+])
+
+/**
+ * Arguments for {@linkcode PluginReferenceLineApi.get}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `referenceLineId` | `string` | The reference line ID to query |
+ * | `properties` | {@linkcode PluginReferenceLineGetProperty}`[]` | Properties to retrieve |
+ */
+export const PluginReferenceLineGetArgs = z.object({
+  referenceLineId: z.string(),
+  properties: z.array(PluginReferenceLineGetProperty),
+})
+
+export type PluginReferenceLineGetArgs = z.infer<typeof PluginReferenceLineGetArgs>
+
+/**
+ * Result of {@linkcode PluginReferenceLineApi.get}.
+ *
+ * A partial object — only the properties that were requested in
+ * {@linkcode PluginReferenceLineGetArgs.properties} will be present.
+ */
+export const PluginReferenceLineGetResult = z
+  .object({
+    curve: CurveHandle,
+  })
+  .partial()
+
+export type PluginReferenceLineGetResult = z.infer<typeof PluginReferenceLineGetResult>
+
+/**
+ * Result of {@linkcode PluginReferenceLineApi.getAll}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `referenceLineIds` | `string[]` | IDs of all reference lines in the project |
+ */
+export const PluginReferenceLineGetAllResult = z.object({
+  referenceLineIds: z.array(z.string()),
+})
+
+export type PluginReferenceLineGetAllResult = z.infer<typeof PluginReferenceLineGetAllResult>
+
+/**
+ * Arguments for {@linkcode PluginReferenceLineApi.delete}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `referenceLineId` | `string` | The reference line ID to delete |
+ */
+export const PluginReferenceLineDeleteArgs = z.object({
+  referenceLineId: z.string(),
+})
+
+export type PluginReferenceLineDeleteArgs = z.infer<typeof PluginReferenceLineDeleteArgs>
+
+/** Result type for {@linkcode PluginReferenceLineApi.delete} — returns nothing on success. */
+export type PluginReferenceLineDeleteResult = void