@snaptrude/plugin-core 0.7.1 → 0.9.0

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

@@ -3,6 +3,7 @@ import { PluginApiReturn } from "../../../types";
 import { ComponentHandle } from "../../../handles";
 import { PluginSpaceUpdateResult } from "../../entity/space";
 import { PluginDesignChangeResult } from "../lock";
+import { PluginBuildableEnvelopePolygonVertex, PluginBuildableEnvelopeSetbackTier, PluginBuildableEnvelopeVerticalCap, PluginBuildableEnvelopeUpdateResult } from "../../entity/buildableEnvelope";
 /**
  * Sparse property updates for a space. Only provided fields change.
  *
@@ -57,7 +58,7 @@ export declare const PluginSpacePropertyUpdates: z.ZodObject<{
 export type PluginSpacePropertyUpdates = z.infer<typeof PluginSpacePropertyUpdates>;
 /** Geometry replacement for a space — re-extrude a profile. */
 export declare const PluginSpaceGeometryUpdate: z.ZodObject<{
-    profile: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"profile">, string>>;
+    profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"profile">, string>>;
     extrudeHeight: z.ZodNumber;
 }, z.core.$strip>;
 export type PluginSpaceGeometryUpdate = z.infer<typeof PluginSpaceGeometryUpdate>;
@@ -105,7 +106,7 @@ export declare const PluginUpdateSpaceItem: z.ZodObject<{
         }>, z.ZodUUID]>>;
     }, z.core.$strip>>;
     geometry: z.ZodOptional<z.ZodObject<{
-        profile: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"profile">, string>>;
+        profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"profile">, string>>;
         extrudeHeight: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -193,6 +194,90 @@ export declare const PluginDesignUpdateStaircaseArgs: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type PluginDesignUpdateStaircaseArgs = z.infer<typeof PluginDesignUpdateStaircaseArgs>;
+/**
+ * Sparse edits for a wall (all optional; at least one required). Only the
+ * fields you provide change. Dimensions are in **engine units** (the same
+ * convention as `design.doors.setWidth`). Consumed by
+ * {@linkcode PluginDesignUpdateApi.wall}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `thickness` | `number`? | Wall thickness, engine units (> 0) |
+ * | `height` | `number`? | Wall height, engine units (> 0) |
+ * | `type` | `string`? | Convert the wall to another wall type — a name (or `wall:`-prefixed id) from `design.types.list("wall")` |
+ */
+export declare const PluginWallUpdates: z.ZodObject<{
+    thickness: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PluginWallUpdates = z.infer<typeof PluginWallUpdates>;
+/**
+ * Sparse dimension edits for a slab-family element (slab / floor / roof /
+ * ceiling). All values are engine units, the same convention as
+ * `design.doors.setWidth`. Consumed by {@linkcode PluginDesignUpdateApi.slab},
+ * `floor`, `roof`, and `ceiling`.
+ *
+ * `overhang` is only available on **slabs and roofs** (the panel's Overhang
+ * slider) — floors and ceilings reject it with `PRECONDITION_FAILED`.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `thickness` | `number`? | Element thickness, engine units (> 0) |
+ * | `overhang` | `number`? | Absolute overhang offset, engine units (slab / roof only) |
+ */
+export declare const PluginSlabUpdates: z.ZodObject<{
+    thickness: z.ZodOptional<z.ZodNumber>;
+    overhang: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginSlabUpdates = z.infer<typeof PluginSlabUpdates>;
+/** Arguments for {@linkcode PluginDesignUpdateApi.wall}. */
+export declare const PluginDesignUpdateWallArgs: z.ZodObject<{
+    component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    updates: z.ZodObject<{
+        thickness: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PluginDesignUpdateWallArgs = z.infer<typeof PluginDesignUpdateWallArgs>;
+/**
+ * Arguments for the slab-family updaters —
+ * {@linkcode PluginDesignUpdateApi.slab}, `floor`, `roof`, `ceiling`.
+ */
+export declare const PluginDesignUpdateSlabArgs: z.ZodObject<{
+    component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    updates: z.ZodObject<{
+        thickness: z.ZodOptional<z.ZodNumber>;
+        overhang: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PluginDesignUpdateSlabArgs = z.infer<typeof PluginDesignUpdateSlabArgs>;
+/** Arguments for {@linkcode PluginDesignUpdateApi.setElevation}. */
+export declare const PluginDesignSetElevationArgs: z.ZodObject<{
+    component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    elevation: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginDesignSetElevationArgs = z.infer<typeof PluginDesignSetElevationArgs>;
+/** Arguments for {@linkcode PluginDesignUpdateApi.setBaseOffset}. */
+export declare const PluginDesignSetBaseOffsetArgs: z.ZodObject<{
+    component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    offset: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginDesignSetBaseOffsetArgs = z.infer<typeof PluginDesignSetBaseOffsetArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignUpdateApi.setStorey}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `components` | {@linkcode ComponentHandle}`[]` | The components to reassign |
+ * | `storey` | `number` | Target integer storey number (`entity.story` convention; must exist) |
+ */
+export declare const PluginDesignSetStoreyArgs: z.ZodObject<{
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    storey: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginDesignSetStoreyArgs = z.infer<typeof PluginDesignSetStoreyArgs>;
 /**
  * `snaptrude.design.update` — edit existing scene entities (properties + geometry).
  *
@@ -256,6 +341,9 @@ export declare abstract class PluginDesignUpdateApi {
      * @examplePrompt Move this space into the Circulation department
      * @examplePrompt Exclude this room from the area calculations
      *
+     * @performance For MORE THAN ONE space, call `design.update.spaces(items[])` — the whole
+     *   batch is one host round-trip. Looping this single-space updater is N round-trips.
+     *
      * # Example
      * ```ts
      * await snaptrude.design.update.space("space-id", { properties: { room_type: "Office" } })
@@ -282,6 +370,9 @@ export declare abstract class PluginDesignUpdateApi {
      * @examplePrompt Bulk-assign these spaces to the Service department
      * @examplePrompt Mark all of these rooms as excluded from area in one update
      *
+     * @performance Bulk update — the whole batch is ONE host round-trip. Prefer over looping
+     *   `design.update.space`: build the `items[]` array first, then make one call.
+     *
      * # Example
      * ```ts
      * // Re-label every selected room and mark it NET area — one undoable bulk update
@@ -342,5 +433,297 @@ export declare abstract class PluginDesignUpdateApi {
      * ```
      */
     abstract staircase(staircases: ComponentHandle[], params: PluginStaircaseParamUpdates): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Edit a **wall** — its thickness and/or height (the same command the
+     * properties panel's Thickness/Height fields drive) and/or its **wall type**
+     * (the panel's Wall Types dropdown: converts the wall to another type,
+     * rebuilding its layer stack and materials). Sparse: only the fields you
+     * provide change. Undoable; the geometry rebuilds and any dimension lines
+     * refresh. Stacked-wall companions and hosted fenestration are handled
+     * exactly as the panel does.
+     *
+     * Thickness/height are in **engine units** (the same convention as
+     * `design.doors.setWidth`) and must be `> 0`. Shrinking a wall past its
+     * openings is rejected by the engine (the wall is skipped with no change).
+     * `type` accepts a type name from `design.types.list("wall")` (or its
+     * `wall:`-prefixed id); when combined with dimensions, the type conversion
+     * is applied first so an explicit thickness/height wins over the type's
+     * defaults. Re-applying the wall's current type is a no-op.
+     *
+     * Throws when the handle is not a wall, when the wall is locked, when the
+     * handle is gone/forged, when `type` names an unknown wall type, when the
+     * engine rejects the conversion (e.g. a curved wall thinner than the new
+     * type's minimum thickness), or when no field is provided.
+     *
+     * A type conversion (and a thickness edit on a parametric wall) REBUILDS the
+     * wall, replacing it with a new component: the input handle is then dead
+     * (further calls throw HANDLE_INVALID) and `affected[0]` carries the
+     * replacement's handle — use it for any follow-up calls.
+     *
+     * @param component - The wall to edit
+     * @param updates - Sparse {@linkcode PluginWallUpdates} (at least one field)
+     * @returns the affected wall — after a rebuild, the REPLACEMENT wall's handle
+     *
+     * @examplePrompt Make this wall 230mm thick
+     * @examplePrompt Set the selected wall's height to 3 metres
+     * @examplePrompt Thicken every exterior wall to 300
+     * @examplePrompt Change this wall to a Glass Wall
+     * @examplePrompt Convert all the partitions on this floor to Brick Wall
+     *
+     * # Example
+     * ```ts
+     * // Convert every wall on storey 1 to the first listed wall type
+     * const [wallType] = await snaptrude.design.types.list("wall")
+     * const walls = await snaptrude.design.query.listWalls({ storeys: [1] })
+     * for (const wall of walls) {
+     *   await snaptrude.design.update.wall(wall, { type: wallType.id })
+     * }
+     * ```
+     */
+    abstract wall(component: ComponentHandle, updates: PluginWallUpdates): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Edit a **slab's** thickness and/or overhang — the same commands the
+     * properties panel's Thickness field and Overhang slider drive. Sparse: only
+     * the fields you provide change. Undoable; the slab rebuilds and dimension
+     * lines refresh. Both values are in **engine units** (the same convention as
+     * `design.doors.setWidth`); thickness must be `> 0`, overhang is an absolute
+     * offset (negative insets the slab) and re-applying the current overhang is
+     * a no-op.
+     *
+     * Throws when the handle is not a slab, when it is locked, when the handle is
+     * gone/forged, when `overhang` is set on a slab that has no overhang (plinth /
+     * basement slabs, or overhang disabled), or when no field is provided.
+     *
+     * @param component - The slab to edit
+     * @param updates - Sparse {@linkcode PluginSlabUpdates} (at least one field)
+     * @returns the affected slab
+     *
+     * @examplePrompt Set this slab's thickness to 250mm
+     * @examplePrompt Make the floor slab 300 thick
+     * @examplePrompt Give this slab a 200 overhang
+     * @examplePrompt Remove the overhang on every slab on level 2
+     *
+     * # Example
+     * ```ts
+     * const [slab] = await snaptrude.design.query.listSlabs()
+     * await snaptrude.design.update.slab(slab, { thickness: 250, overhang: 200 })
+     * ```
+     */
+    abstract slab(component: ComponentHandle, updates: PluginSlabUpdates): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Edit a **floor's** thickness — the slab-family updater for floors (shares
+     * the slab thickness command). Undoable. Thickness is in **engine units**
+     * (the `design.doors.setWidth` convention) and must be `> 0`. Floors have no
+     * Overhang control, so `overhang` is rejected with `PRECONDITION_FAILED`.
+     *
+     * Throws when the handle is not a floor, when it is locked, when the handle
+     * is gone/forged, when `overhang` is provided, or when no field is provided.
+     *
+     * @param component - The floor to edit
+     * @param updates - {@linkcode PluginSlabUpdates} (a `thickness`)
+     * @returns the affected floor
+     *
+     * @examplePrompt Make this floor 200mm thick
+     * @examplePrompt Set every floor to a 250 thickness
+     * @examplePrompt Thicken the ground floor slab to 300
+     *
+     * # Example
+     * ```ts
+     * const [floor] = await snaptrude.design.query.listFloors()
+     * await snaptrude.design.update.floor(floor, { thickness: 200 })
+     * ```
+     */
+    abstract floor(component: ComponentHandle, updates: PluginSlabUpdates): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Edit a **roof's** thickness and/or overhang — the same commands the roof
+     * panel's Thickness field and Overhang slider drive (shares the slab-family
+     * machinery). Sparse: only the fields you provide change. Undoable. Both
+     * values are in **engine units** (the `design.doors.setWidth` convention);
+     * thickness must be `> 0`, overhang is an absolute offset (negative insets
+     * the roof) and re-applying the current overhang is a no-op.
+     *
+     * Throws when the handle is not a roof, when it is locked, when the handle is
+     * gone/forged, when `overhang` is set on a roof whose overhang is disabled,
+     * or when no field is provided.
+     *
+     * @param component - The roof to edit
+     * @param updates - Sparse {@linkcode PluginSlabUpdates} (at least one field)
+     * @returns the affected roof
+     *
+     * @examplePrompt Make this roof 300mm thick
+     * @examplePrompt Set the roof slab thickness to 250
+     * @examplePrompt Give the roof a 600 overhang
+     * @examplePrompt Pull the roof overhang back to 0
+     *
+     * # Example
+     * ```ts
+     * const [roof] = await snaptrude.design.query.listRoofs()
+     * await snaptrude.design.update.roof(roof, { overhang: 600 })
+     * ```
+     */
+    abstract roof(component: ComponentHandle, updates: PluginSlabUpdates): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Edit a **ceiling's** thickness — the slab-family updater for ceilings
+     * (shares the slab thickness command). Undoable. Thickness is in **engine
+     * units** (the `design.doors.setWidth` convention) and must be `> 0`.
+     * Ceilings have no Overhang control, so `overhang` is rejected with
+     * `PRECONDITION_FAILED`.
+     *
+     * Throws when the handle is not a ceiling, when it is locked, when the handle
+     * is gone/forged, when `overhang` is provided, or when no field is provided.
+     *
+     * @param component - The ceiling to edit
+     * @param updates - {@linkcode PluginSlabUpdates} (a `thickness`)
+     * @returns the affected ceiling
+     *
+     * @examplePrompt Make this ceiling 150mm thick
+     * @examplePrompt Set every ceiling to a 100 thickness
+     * @examplePrompt Thicken the ceiling to 200
+     *
+     * # Example
+     * ```ts
+     * const [ceiling] = await snaptrude.design.query.listCeilings()
+     * await snaptrude.design.update.ceiling(ceiling, { thickness: 150 })
+     * ```
+     */
+    abstract ceiling(component: ComponentHandle, updates: PluginSlabUpdates): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Set a component's **absolute world elevation** — moves it vertically so its
+     * base (the bounding-box bottom, world Y) lands at `elevation`. Composed over
+     * the canonical command-backed move machinery, so it is undoable and persisted
+     * exactly like dragging the element up or down; per-type invariants (e.g. a
+     * staircase's base offset) stay in sync. `elevation` is in **engine units**
+     * (the `design.doors.setWidth` convention). Re-applying the current elevation
+     * is a no-op.
+     *
+     * Throws when the component is locked or the handle is gone/forged.
+     *
+     * @param component - The component to move vertically
+     * @param elevation - Target world elevation of the component's base (engine units)
+     * @returns the affected component
+     *
+     * @examplePrompt Set this element's elevation to 3000
+     * @examplePrompt Raise this mass so its base sits at 3 metres
+     * @examplePrompt Drop the selected slab to elevation 0
+     * @examplePrompt Put this staircase's base at 3200
+     *
+     * # Example
+     * ```ts
+     * // Sit the roof slab exactly at the top of a 3m storey
+     * const [roof] = await snaptrude.design.query.listRoofs()
+     * await snaptrude.design.update.setElevation(roof, 3000)
+     * ```
+     */
+    abstract setElevation(component: ComponentHandle, elevation: number): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Set a component's **base offset** — its vertical distance above its own
+     * storey's base level. Moves the component so its base lands at
+     * `storeyBase + offset`, composed over the same command-backed move machinery
+     * as {@linkcode setElevation} (undoable, persisted, per-type invariants kept
+     * in sync). Use this instead of {@linkcode setElevation} when you want an
+     * offset relative to the storey rather than an absolute world height.
+     * `offset` is in **engine units** (the `design.doors.setWidth` convention);
+     * `0` sits the base flush with the storey base. Re-applying the current
+     * offset is a no-op.
+     *
+     * Throws when the component is locked, when it has no storey to offset from,
+     * or when the handle is gone/forged.
+     *
+     * @param component - The component to offset
+     * @param offset - Distance of the component's base above its storey base (engine units)
+     * @returns the affected component
+     *
+     * @examplePrompt Lift this element 300 above its floor
+     * @examplePrompt Set this staircase's base offset to 0
+     * @examplePrompt Raise the selected mass 500 off the storey base
+     * @examplePrompt Offset this slab 150 above the floor level
+     *
+     * # Example
+     * ```ts
+     * const [stair] = await snaptrude.design.query.listStaircases()
+     * await snaptrude.design.update.setBaseOffset(stair, 0)
+     * ```
+     */
+    abstract setBaseOffset(component: ComponentHandle, offset: number): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Reassign one or more components to another **storey** — the same operation
+     * as the properties panel's Story dropdown, and it works across element kinds
+     * exactly like the panel (walls, slabs, masses, furniture, staircases, ...).
+     * Each component is moved vertically to the target storey's level (per-kind
+     * placement rules — e.g. a slab sits at the storey base, a wall on it) and
+     * its storey assignment, children, and dimension lines update together as
+     * **one undoable operation**.
+     *
+     * `storey` is an integer storey number in the `entity.story` convention
+     * (`1` is the ground storey, `-1` the first basement; `0` does not exist)
+     * and **must already exist** in each component's building — this call never
+     * creates storeys (use `core.storeys.create` first). Components already on
+     * the target storey are skipped (no-op) and are not echoed in `affected`.
+     *
+     * Throws when the target storey does not exist, when any component is
+     * locked, or when a handle is gone/forged — all before anything moves
+     * (all-or-nothing).
+     *
+     * @param components - The components to reassign
+     * @param storey - Target storey number (integer, `entity.story` convention)
+     * @returns the components actually reassigned
+     *
+     * @examplePrompt Move this sofa to storey 2
+     * @examplePrompt Put the selected walls on the first basement level
+     * @examplePrompt Send everything on this storey up one level
+     * @examplePrompt Reassign these slabs to storey 3
+     *
+     * # Example
+     * ```ts
+     * // Move the current selection up to storey 2
+     * const selection = await snaptrude.design.selection.get()
+     * const { affected } = await snaptrude.design.update.setStorey(selection, 2)
+     * console.log("moved", affected.length, "components")
+     * ```
+     */
+    abstract setStorey(components: ComponentHandle[], storey: number): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * 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. Canonical home of the
+     * update formerly at `entity.buildableEnvelope.update` (now deprecated).
+     *
+     * @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
+     *
+     * # Example
+     * ```ts
+     * const { buildableEnvelopeId } = await snaptrude.design.update.buildableEnvelope(
+     *   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,
+     * )
+     * ```
+     */
+    abstract buildableEnvelope(buildableEnvelopeId: string, sitePolygon: PluginBuildableEnvelopePolygonVertex[], lengthUnit: "ft" | "m", setbacks: PluginBuildableEnvelopeSetbackTier[], verticalCap: PluginBuildableEnvelopeVerticalCap, floorToFloor: number, farRatio?: number, lotCoverageMaxPct?: number): PluginApiReturn<PluginBuildableEnvelopeUpdateResult>;
 }
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/update/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAiB,MAAM,kBAAkB,CAAA;AACjE,OAAO,EAKL,uBAAuB,EACxB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMrC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF,+DAA+D;AAC/D,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEjF,wEAAwE;AACxE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIhC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAA;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;iBAmBpC,CAAA;AACJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAErF;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;iBAG1C,CAAA;AACF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;GAKG;AACH,8BAAsB,qBAAqB;;IAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;aACa,QAAQ,CAAC,SAAS,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC,OAAO,CAAC;IAE7F;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,KAAK,CACnB,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE;QACP,UAAU,CAAC,EAAE,0BAA0B,CAAA;QACvC,QAAQ,CAAC,EAAE,yBAAyB,CAAA;KACrC,GACA,eAAe,CAAC,uBAAuB,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;aACa,MAAM,CAAC,KAAK,EAAE,qBAAqB,EAAE,GAAG,eAAe,CAAC,uBAAuB,EAAE,CAAC;IAElG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;aACa,SAAS,CACvB,UAAU,EAAE,eAAe,EAAE,EAC7B,MAAM,EAAE,2BAA2B,GAClC,eAAe,CAAC,wBAAwB,CAAC;CAC7C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/update/index.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,98 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../types";
+import { ComponentHandle } from "../../handles";
+import { PluginDesignChangeResult } from "./lock";
+/**
+ * `snaptrude.design.visibility.*` — hide, isolate, and reveal scene entities.
+ *
+ * Visibility is a per-component user flag (the same one the "Hide" / "Isolate" /
+ * "Show All" toolbar and right-click actions toggle). Every method here commits
+ * an undoable command and echoes the affected entities as
+ * {@linkcode PluginDesignChangeResult}.
+ *
+ * Accessed via `snaptrude.design.visibility`.
+ */
+export declare abstract class PluginDesignVisibilityApi {
+    constructor();
+    /**
+     * Hide entities from the viewport — the same as the "Hide" action. Undoable.
+     * Hosted door/window/void children ride along with their wall. Already-hidden
+     * entities stay hidden.
+     *
+     * @param components Entities to hide
+     * @returns The affected entities (echoing the input handles)
+     *
+     * @examplePrompt Hide the selected walls
+     * @examplePrompt Conceal these masses so I can see behind them
+     * @examplePrompt Hide every column on this floor
+     * @examplePrompt Make this furniture disappear from view
+     *
+     * # Example
+     * ```ts
+     * const walls = await snaptrude.design.query.listWalls({ storeys: [1] })
+     * const { affected } = await snaptrude.design.visibility.hide(walls)
+     * ```
+     */
+    abstract hide(components: ComponentHandle[]): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Isolate entities — hide everything else so only the given entities remain
+     * visible (the "Isolate" / solo action). Undoable. Reverse it with
+     * {@linkcode PluginDesignVisibilityApi.showAll}.
+     *
+     * @param components Entities to keep visible; everything else is hidden
+     * @returns The isolated entities (echoing the input handles)
+     *
+     * @examplePrompt Isolate the selected room so I can focus on it
+     * @examplePrompt Show only these walls and hide the rest
+     * @examplePrompt Solo this mass
+     * @examplePrompt Hide everything except the staircase
+     *
+     * # Example
+     * ```ts
+     * const [room] = await snaptrude.design.selection.get()
+     * await snaptrude.design.visibility.isolate([room])
+     * ```
+     */
+    abstract isolate(components: ComponentHandle[]): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Reveal everything hidden on the active story — the "Show All" action, which
+     * also exits an isolate. Undoable.
+     *
+     * @returns The entities that were made visible
+     *
+     * @examplePrompt Show everything again
+     * @examplePrompt Unhide all the hidden objects
+     * @examplePrompt Exit isolate mode
+     * @examplePrompt Reveal everything I hid earlier
+     *
+     * # Example
+     * ```ts
+     * const { affected } = await snaptrude.design.visibility.showAll()
+     * console.log(`Revealed ${affected.length} entities`)
+     * ```
+     */
+    abstract showAll(): PluginApiReturn<PluginDesignChangeResult>;
+}
+/**
+ * Arguments for {@linkcode PluginDesignVisibilityApi.hide}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `components` | {@linkcode ComponentHandle}`[]` | Entities to hide |
+ */
+export declare const PluginDesignVisibilityHideArgs: z.ZodObject<{
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDesignVisibilityHideArgs = z.infer<typeof PluginDesignVisibilityHideArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignVisibilityApi.isolate}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `components` | {@linkcode ComponentHandle}`[]` | Entities to keep visible |
+ */
+export declare const PluginDesignVisibilityIsolateArgs: z.ZodObject<{
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDesignVisibilityIsolateArgs = z.infer<typeof PluginDesignVisibilityIsolateArgs>;
+//# sourceMappingURL=visibility.d.ts.map

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

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

package/dist/api/entity/buildableEnvelope.d.ts

@@ -52,6 +52,8 @@ export declare abstract class PluginBuildableEnvelopeApi {
      *   12,
      * )
      * ```
+     *
+     * @deprecated Use `design.create.buildableEnvelope`
      */
     abstract create(sitePolygon: PluginBuildableEnvelopePolygonVertex[], lengthUnit: "ft" | "m", setbacks: PluginBuildableEnvelopeSetbackTier[], verticalCap: PluginBuildableEnvelopeVerticalCap, floorToFloor: number, farRatio?: number, lotCoverageMaxPct?: number): PluginApiReturn<PluginBuildableEnvelopeCreateResult>;
     /**
@@ -95,6 +97,8 @@ export declare abstract class PluginBuildableEnvelopeApi {
      *   12,
      * )
      * ```
+     *
+     * @deprecated Use `design.update.buildableEnvelope`
      */
     abstract update(buildableEnvelopeId: string, sitePolygon: PluginBuildableEnvelopePolygonVertex[], lengthUnit: "ft" | "m", setbacks: PluginBuildableEnvelopeSetbackTier[], verticalCap: PluginBuildableEnvelopeVerticalCap, floorToFloor: number, farRatio?: number, lotCoverageMaxPct?: number): PluginApiReturn<PluginBuildableEnvelopeUpdateResult>;
 }

package/dist/api/entity/buildableEnvelope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildableEnvelope.d.ts","sourceRoot":"","sources":["../../../src/api/entity/buildableEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;GASG;AACH,8BAAsB,0BAA0B;;IAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;aACa,MAAM,CACpB,WAAW,EAAE,oCAAoC,EAAE,EACnD,UAAU,EAAE,IAAI,GAAG,GAAG,EACtB,QAAQ,EAAE,kCAAkC,EAAE,EAC9C,WAAW,EAAE,kCAAkC,EAC/C,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,iBAAiB,CAAC,EAAE,MAAM,GACzB,eAAe,CAAC,mCAAmC,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;aACa,MAAM,CACpB,mBAAmB,EAAE,MAAM,EAC3B,WAAW,EAAE,oCAAoC,EAAE,EACnD,UAAU,EAAE,IAAI,GAAG,GAAG,EACtB,QAAQ,EAAE,kCAAkC,EAAE,EAC9C,WAAW,EAAE,kCAAkC,EAC/C,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,iBAAiB,CAAC,EAAE,MAAM,GACzB,eAAe,CAAC,mCAAmC,CAAC;CACxD;AAED;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC;;;kEAG/C,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC;;;;;;4BAS7C,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kCAAkC;;;;;kBAKpC,CAAA;AAEX,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AA+BD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;kBAWZ,CAAA;AAElC,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;kBAErC,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;kBAYZ,CAAA;AAElC,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;kBAErC,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA"}
+{"version":3,"file":"buildableEnvelope.d.ts","sourceRoot":"","sources":["../../../src/api/entity/buildableEnvelope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C;;;;;;;;;GASG;AACH,8BAAsB,0BAA0B;;IAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;aACa,MAAM,CACpB,WAAW,EAAE,oCAAoC,EAAE,EACnD,UAAU,EAAE,IAAI,GAAG,GAAG,EACtB,QAAQ,EAAE,kCAAkC,EAAE,EAC9C,WAAW,EAAE,kCAAkC,EAC/C,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,iBAAiB,CAAC,EAAE,MAAM,GACzB,eAAe,CAAC,mCAAmC,CAAC;IAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;aACa,MAAM,CACpB,mBAAmB,EAAE,MAAM,EAC3B,WAAW,EAAE,oCAAoC,EAAE,EACnD,UAAU,EAAE,IAAI,GAAG,GAAG,EACtB,QAAQ,EAAE,kCAAkC,EAAE,EAC9C,WAAW,EAAE,kCAAkC,EAC/C,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,EACjB,iBAAiB,CAAC,EAAE,MAAM,GACzB,eAAe,CAAC,mCAAmC,CAAC;CACxD;AAED;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC;;;kEAG/C,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kCAAkC;;;;;;4BAS7C,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kCAAkC;;;;;kBAKpC,CAAA;AAEX,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,kCAAkC,CAC1C,CAAA;AA+BD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;kBAWZ,CAAA;AAElC,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;kBAErC,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;kBAYZ,CAAA;AAElC,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,iCAAiC,CACzC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC;;kBAErC,CAAA;AAEX,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,mCAAmC,CAC3C,CAAA"}

package/dist/api/entity/referenceLine.d.ts

@@ -47,6 +47,8 @@ export declare abstract class PluginReferenceLineApi {
      *
      * const { referenceLineIds } = await snaptrude.entity.referenceLine.createMulti(profile)
      * ```
+     *
+     * @deprecated Use `design.create.referenceLines`
      */
     abstract createMulti(profile: ProfileHandle): PluginApiReturn<PluginReferenceLineCreateMultiResult>;
     /**
@@ -73,6 +75,8 @@ export declare abstract class PluginReferenceLineApi {
      * // 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`
      */
     abstract get(referenceLineId: string, properties: z.infer<typeof PluginReferenceLineGetProperty>[]): PluginApiReturn<PluginReferenceLineGetResult>;
     /**
@@ -95,6 +99,8 @@ export declare abstract class PluginReferenceLineApi {
      * const { referenceLineIds } = await snaptrude.entity.referenceLine.getAll()
      * console.log(`Project has ${referenceLineIds.length} reference lines`)
      * ```
+     *
+     * @deprecated Use `design.query.listReferenceLines`
      */
     abstract getAll(): PluginApiReturn<PluginReferenceLineGetAllResult>;
     /**
@@ -115,6 +121,8 @@ export declare abstract class PluginReferenceLineApi {
      * ```ts
      * await snaptrude.entity.referenceLine.delete("some-ref-line-id")
      * ```
+     *
+     * @deprecated Use `design.delete.entities`
      */
     abstract delete(referenceLineId: string): PluginApiReturn<PluginReferenceLineDeleteResult>;
 }
@@ -126,7 +134,7 @@ export declare abstract class PluginReferenceLineApi {
  * | `profile` | {@linkcode ProfileHandle} | Profile handle whose curves define reference lines |
  */
 export declare const PluginReferenceLineCreateMultiArgs: z.ZodObject<{
-    profile: z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Handle<"profile">, string>>;
+    profile: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../..").Handle<"profile">, string>>;
 }, z.core.$strip>;
 export type PluginReferenceLineCreateMultiArgs = z.infer<typeof PluginReferenceLineCreateMultiArgs>;
 /**
@@ -172,7 +180,7 @@ export type PluginReferenceLineGetArgs = z.infer<typeof PluginReferenceLineGetAr
  * {@linkcode PluginReferenceLineGetArgs.properties} will be present.
  */
 export declare const PluginReferenceLineGetResult: z.ZodObject<{
-    curve: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Handle<"line">, string>>, z.ZodPipe<z.ZodString, z.ZodTransform<import("../..").Handle<"arc">, string>>]>>;
+    curve: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../..").Handle<"arc">, string>>]>>;
 }, z.core.$strip>;
 export type PluginReferenceLineGetResult = z.infer<typeof PluginReferenceLineGetResult>;
 /**

package/dist/api/entity/referenceLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"referenceLine.d.ts","sourceRoot":"","sources":["../../../src/api/entity/referenceLine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAe,MAAM,eAAe,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,8BAAsB,sBAAsB;;IAG1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;aACa,WAAW,CACzB,OAAO,EAAE,aAAa,GACrB,eAAe,CAAC,oCAAoC,CAAC;IAExD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;aACa,GAAG,CACjB,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,EAAE,GAC3D,eAAe,CAAC,4BAA4B,CAAC;IAEhD;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,MAAM,IAAI,eAAe,CAAC,+BAA+B,CAAC;IAE1E;;;;;;;;;;;;;;;;;;OAkBG;aACa,MAAM,CACpB,eAAe,EAAE,MAAM,GACtB,eAAe,CAAC,+BAA+B,CAAC;CACpD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC;;iBAE7C,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAEnG;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC;;iBAE/C,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAEvG;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;EAEzC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;;;iBAGrC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B;;iBAI7B,CAAA;AAEZ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEvF;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;iBAE1C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;iBAExC,CAAA;AAEF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF,8FAA8F;AAC9F,MAAM,MAAM,+BAA+B,GAAG,IAAI,CAAA"}
+{"version":3,"file":"referenceLine.d.ts","sourceRoot":"","sources":["../../../src/api/entity/referenceLine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,aAAa,EAAe,MAAM,eAAe,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,8BAAsB,sBAAsB;;IAG1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;aACa,WAAW,CACzB,OAAO,EAAE,aAAa,GACrB,eAAe,CAAC,oCAAoC,CAAC;IAExD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;aACa,GAAG,CACjB,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,EAAE,GAC3D,eAAe,CAAC,4BAA4B,CAAC;IAEhD;;;;;;;;;;;;;;;;;;;;;;OAsBG;aACa,MAAM,IAAI,eAAe,CAAC,+BAA+B,CAAC;IAE1E;;;;;;;;;;;;;;;;;;;;OAoBG;aACa,MAAM,CACpB,eAAe,EAAE,MAAM,GACtB,eAAe,CAAC,+BAA+B,CAAC;CACpD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC;;iBAE7C,CAAA;AAEF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAEnG;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC;;iBAE/C,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAEvG;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B;;EAEzC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;;;iBAGrC,CAAA;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B;;iBAI7B,CAAA;AAEZ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEvF;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;iBAE1C,CAAA;AAEF,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AAE7F;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B;;iBAExC,CAAA;AAEF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEzF,8FAA8F;AAC9F,MAAM,MAAM,+BAA+B,GAAG,IAAI,CAAA"}