@snaptrude/plugin-core 0.9.11 → 0.9.13

package/dist/index.js

@@ -2414,6 +2414,7 @@ var PluginEntityType = z46.enum([
   "curtainWall",
   "mullion",
   "panel",
+  "parametricComponent",
   "grid"
 ]);
 var PluginEntityFilter = z46.object({
@@ -3094,52 +3095,105 @@ var PluginDesignTypesGetArgs = z62.object({
   typeId: z62.string()
 });
 
-// src/api/design/grids.ts
+// src/api/design/family.ts
 import * as z63 from "zod";
-var PluginGridLineTagPolicy = z63.enum(["rewrite", "preserve"]);
-var PluginGridLineAddress = z63.object({
-  wing: z63.number().int().nonnegative(),
-  line: z63.number().int().nonnegative()
-});
-var PluginGridWingEntry = z63.object({
-  wing: z63.number().int().nonnegative(),
-  spacing: z63.number().positive().finite().optional(),
-  count: z63.number().int().min(1).optional(),
-  spanMin: z63.number().finite().optional(),
-  spanMax: z63.number().finite().optional()
-});
-var PluginDesignGridsUpdateWingsArgs = z63.object({
+var PluginDesignFamilyApi = class {
+  constructor() {
+  }
+};
+var PluginFamilyBundleSchema = z63.object({
+  root: z63.record(z63.string(), z63.unknown()),
+  deps: z63.record(z63.string(), z63.record(z63.string(), z63.unknown())).optional()
+});
+var PluginFamilySnapshotOption = z63.union([
+  z63.boolean(),
+  z63.object({
+    views: z63.array(z63.enum(["iso", "front", "right", "top"])).optional(),
+    /** Pixels per tile (square), 64–2048; default 512. */
+    tileSize: z63.number().optional()
+  })
+]);
+var PluginDesignFamilyPrepareArgs = z63.object({
+  bundle: PluginFamilyBundleSchema.optional(),
+  spec: PluginFamilyBundleSchema.optional(),
+  snapshot: PluginFamilySnapshotOption.optional()
+});
+var PluginDesignFamilyFlexArgs = z63.object({
+  values: z63.record(z63.string(), z63.union([z63.number(), z63.string()])),
+  snapshot: PluginFamilySnapshotOption.optional()
+});
+var PluginDesignFamilyCreateArgs = z63.object({
+  name: z63.string().optional(),
+  teamId: z63.string().optional()
+});
+var PluginDesignFamilyDeleteArgs = z63.object({
+  id: z63.string().optional(),
+  instances: z63.boolean().optional()
+});
+var PluginDesignFamilyPlaceArgs = z63.object({
+  id: z63.string().optional(),
+  version: z63.number().int().positive().optional(),
+  position: Vec3Components.optional(),
+  rotation: z63.number().optional(),
+  values: z63.record(z63.string(), z63.union([z63.number(), z63.string()])).optional(),
+  storey: z63.number().int().optional()
+});
+var PluginDesignFamilyGetParametersArgs = z63.object({
+  component: ComponentHandle,
+  /** Also return a picture of this instance (its recipe re-run at its values, with its paint). */
+  snapshot: PluginFamilySnapshotOption.optional()
+});
+var PluginDesignFamilySetParametersArgs = z63.object({
+  component: ComponentHandle,
+  values: z63.record(z63.string(), z63.union([z63.number(), z63.string()]))
+});
+
+// src/api/design/grids.ts
+import * as z64 from "zod";
+var PluginGridLineTagPolicy = z64.enum(["rewrite", "preserve"]);
+var PluginGridLineAddress = z64.object({
+  wing: z64.number().int().nonnegative(),
+  line: z64.number().int().nonnegative()
+});
+var PluginGridWingEntry = z64.object({
+  wing: z64.number().int().nonnegative(),
+  spacing: z64.number().positive().finite().optional(),
+  count: z64.number().int().min(1).optional(),
+  spanMin: z64.number().finite().optional(),
+  spanMax: z64.number().finite().optional()
+});
+var PluginDesignGridsUpdateWingsArgs = z64.object({
   grid: ComponentHandle,
-  wings: z63.array(PluginGridWingEntry).min(1)
-});
-var PluginGridLineEntry = z63.object({
-  wing: z63.number().int().nonnegative(),
-  line: z63.number().int().nonnegative(),
-  tag: z63.string().min(1).optional(),
-  distanceToPrevious: z63.number().positive().finite().optional(),
-  distanceToNext: z63.number().positive().finite().optional(),
+  wings: z64.array(PluginGridWingEntry).min(1)
+});
+var PluginGridLineEntry = z64.object({
+  wing: z64.number().int().nonnegative(),
+  line: z64.number().int().nonnegative(),
+  tag: z64.string().min(1).optional(),
+  distanceToPrevious: z64.number().positive().finite().optional(),
+  distanceToNext: z64.number().positive().finite().optional(),
   props: PluginGridStyleOptions.optional(),
-  visible: z63.literal(false).optional()
+  visible: z64.literal(false).optional()
 }).superRefine((entry, ctx) => {
   if (entry.distanceToPrevious !== void 0 && entry.distanceToNext !== void 0) {
     ctx.addIssue({
-      code: z63.ZodIssueCode.custom,
+      code: z64.ZodIssueCode.custom,
       message: "distanceToPrevious and distanceToNext are mutually exclusive on one line entry"
     });
   }
 });
-var PluginDesignGridsUpdateLinesArgs = z63.object({
+var PluginDesignGridsUpdateLinesArgs = z64.object({
   grid: ComponentHandle,
-  lines: z63.array(PluginGridLineEntry).min(1)
+  lines: z64.array(PluginGridLineEntry).min(1)
 });
-var PluginDesignGridsAddLineArgs = z63.object({
+var PluginDesignGridsAddLineArgs = z64.object({
   grid: ComponentHandle,
-  wing: z63.number().int().nonnegative(),
-  position: z63.number().finite()
+  wing: z64.number().int().nonnegative(),
+  position: z64.number().finite()
 });
-var PluginDesignGridsRemoveLinesArgs = z63.object({
+var PluginDesignGridsRemoveLinesArgs = z64.object({
   grid: ComponentHandle,
-  lines: z63.array(PluginGridLineAddress).min(1),
+  lines: z64.array(PluginGridLineAddress).min(1),
   tagPolicy: PluginGridLineTagPolicy.optional()
 });
 var PluginDesignGridsApi = class {
@@ -3154,37 +3208,37 @@ var PluginDesignApi = class {
 };
 
 // src/api/entity/buildableEnvelope.ts
-import * as z64 from "zod";
+import * as z65 from "zod";
 var PluginBuildableEnvelopeApi = class {
   constructor() {
   }
 };
-var PluginBuildableEnvelopePolygonVertex = z64.union([
-  z64.object({ x: z64.number().finite(), z: z64.number().finite() }).strict(),
-  z64.tuple([z64.number().finite(), z64.number().finite()])
+var PluginBuildableEnvelopePolygonVertex = z65.union([
+  z65.object({ x: z65.number().finite(), z: z65.number().finite() }).strict(),
+  z65.tuple([z65.number().finite(), z65.number().finite()])
 ]);
-var PluginBuildableEnvelopeVerticalCap = z64.discriminatedUnion("kind", [
-  z64.object({
-    kind: z64.literal("max_height"),
-    maxHeight: z64.number().finite().positive()
+var PluginBuildableEnvelopeVerticalCap = z65.discriminatedUnion("kind", [
+  z65.object({
+    kind: z65.literal("max_height"),
+    maxHeight: z65.number().finite().positive()
   }).strict(),
-  z64.object({
-    kind: z64.literal("max_floors"),
-    maxFloors: z64.number().finite().int().positive()
+  z65.object({
+    kind: z65.literal("max_floors"),
+    maxFloors: z65.number().finite().int().positive()
   }).strict()
 ]);
-var PluginBuildableEnvelopeSetbackTier = z64.object({
-  aboveHeight: z64.number().finite().nonnegative(),
-  front: z64.number().finite().nonnegative(),
-  side: z64.number().finite().nonnegative(),
-  rear: z64.number().finite().nonnegative()
+var PluginBuildableEnvelopeSetbackTier = z65.object({
+  aboveHeight: z65.number().finite().nonnegative(),
+  front: z65.number().finite().nonnegative(),
+  side: z65.number().finite().nonnegative(),
+  rear: z65.number().finite().nonnegative()
 }).strict();
 function refineSetbackTiers(args, ctx) {
   const tiers = args.setbacks;
   if (tiers.length === 0) return;
   if (tiers[0].aboveHeight !== 0) {
     ctx.addIssue({
-      code: z64.ZodIssueCode.custom,
+      code: z65.ZodIssueCode.custom,
       path: ["setbacks", 0, "aboveHeight"],
       message: "Ground tier required: setbacks[0].aboveHeight must be 0."
     });
@@ -3192,66 +3246,66 @@ function refineSetbackTiers(args, ctx) {
   for (let i = 1; i < tiers.length; i++) {
     if (!(tiers[i].aboveHeight > tiers[i - 1].aboveHeight)) {
       ctx.addIssue({
-        code: z64.ZodIssueCode.custom,
+        code: z65.ZodIssueCode.custom,
         path: ["setbacks", i, "aboveHeight"],
         message: "Setback tiers must be ordered by strictly increasing aboveHeight."
       });
     }
   }
 }
-var PluginBuildableEnvelopeCreateArgs = z64.object({
-  sitePolygon: z64.array(PluginBuildableEnvelopePolygonVertex).min(3),
-  lengthUnit: z64.union([z64.literal("ft"), z64.literal("m")]),
-  setbacks: z64.array(PluginBuildableEnvelopeSetbackTier).min(1),
+var PluginBuildableEnvelopeCreateArgs = z65.object({
+  sitePolygon: z65.array(PluginBuildableEnvelopePolygonVertex).min(3),
+  lengthUnit: z65.union([z65.literal("ft"), z65.literal("m")]),
+  setbacks: z65.array(PluginBuildableEnvelopeSetbackTier).min(1),
   verticalCap: PluginBuildableEnvelopeVerticalCap,
-  floorToFloor: z64.number().finite().positive(),
-  farRatio: z64.number().finite().positive().optional(),
-  lotCoverageMaxPct: z64.number().finite().min(0).max(100).optional()
+  floorToFloor: z65.number().finite().positive(),
+  farRatio: z65.number().finite().positive().optional(),
+  lotCoverageMaxPct: z65.number().finite().min(0).max(100).optional()
 }).strict().superRefine(refineSetbackTiers);
-var PluginBuildableEnvelopeCreateResult = z64.object({
-  buildableEnvelopeId: z64.string().min(1)
+var PluginBuildableEnvelopeCreateResult = z65.object({
+  buildableEnvelopeId: z65.string().min(1)
 }).strict();
-var PluginBuildableEnvelopeUpdateArgs = z64.object({
-  buildableEnvelopeId: z64.string().min(1),
-  sitePolygon: z64.array(PluginBuildableEnvelopePolygonVertex).min(3),
-  lengthUnit: z64.union([z64.literal("ft"), z64.literal("m")]),
-  setbacks: z64.array(PluginBuildableEnvelopeSetbackTier).min(1),
+var PluginBuildableEnvelopeUpdateArgs = z65.object({
+  buildableEnvelopeId: z65.string().min(1),
+  sitePolygon: z65.array(PluginBuildableEnvelopePolygonVertex).min(3),
+  lengthUnit: z65.union([z65.literal("ft"), z65.literal("m")]),
+  setbacks: z65.array(PluginBuildableEnvelopeSetbackTier).min(1),
   verticalCap: PluginBuildableEnvelopeVerticalCap,
-  floorToFloor: z64.number().finite().positive(),
-  farRatio: z64.number().finite().positive().optional(),
-  lotCoverageMaxPct: z64.number().finite().min(0).max(100).optional()
+  floorToFloor: z65.number().finite().positive(),
+  farRatio: z65.number().finite().positive().optional(),
+  lotCoverageMaxPct: z65.number().finite().min(0).max(100).optional()
 }).strict().superRefine(refineSetbackTiers);
-var PluginBuildableEnvelopeUpdateResult = z64.object({
-  buildableEnvelopeId: z64.string().min(1)
+var PluginBuildableEnvelopeUpdateResult = z65.object({
+  buildableEnvelopeId: z65.string().min(1)
 }).strict();
 
 // src/api/entity/referenceLine.ts
-import * as z65 from "zod";
+import * as z66 from "zod";
 var PluginReferenceLineApi = class {
   constructor() {
   }
 };
-var PluginReferenceLineCreateMultiArgs = z65.object({
+var PluginReferenceLineCreateMultiArgs = z66.object({
   profile: ProfileHandle
 });
-var PluginReferenceLineCreateMultiResult = z65.object({
-  referenceLineIds: z65.array(z65.string())
+var PluginReferenceLineCreateMultiResult = z66.object({
+  referenceLineIds: z66.array(z66.string())
 });
-var PluginReferenceLineGetProperty = z65.enum([
+var PluginReferenceLineGetProperty = z66.enum([
   "curve"
 ]);
-var PluginReferenceLineGetArgs = z65.object({
-  referenceLineId: z65.string(),
-  properties: z65.array(PluginReferenceLineGetProperty)
+var PluginReferenceLineGetArgs = z66.object({
+  referenceLineId: z66.string(),
+  properties: z66.array(PluginReferenceLineGetProperty)
 });
-var PluginReferenceLineGetResult = z65.object({
+var PluginReferenceLineGetResult = z66.object({
   curve: CurveHandle
 }).partial();
-var PluginReferenceLineGetAllResult = z65.object({
-  referenceLineIds: z65.array(z65.string())
+var PluginReferenceLineGetAllResult = z66.object({
+  referenceLineIds: z66.array(z66.string())
 });
-var PluginReferenceLineDeleteArgs = z65.object({
-  referenceLineId: z65.string()
+var PluginReferenceLineDeleteArgs = z66.object({
+  referenceLineId: z66.string()
 });
 
 // src/api/entity/index.ts
@@ -3261,27 +3315,27 @@ var PluginEntityApi = class {
 };
 
 // src/api/program/departments.ts
-import * as z67 from "zod";
+import * as z68 from "zod";
 
 // src/api/program/metrics.ts
-import * as z66 from "zod";
+import * as z67 from "zod";
 var PluginProgramMetricsApi = class {
   constructor() {
   }
 };
-var PluginAreaUnit = z66.enum(["ft2", "m2"]);
-var PluginProgramDepartmentMetric = z66.object({
-  departmentId: z66.string(),
-  name: z66.string(),
-  targetArea: z66.number().nullable(),
-  allocatedArea: z66.number()
+var PluginAreaUnit = z67.enum(["ft2", "m2"]);
+var PluginProgramDepartmentMetric = z67.object({
+  departmentId: z67.string(),
+  name: z67.string(),
+  targetArea: z67.number().nullable(),
+  allocatedArea: z67.number()
 });
-var PluginProgramMetricsSummary = z66.object({
+var PluginProgramMetricsSummary = z67.object({
   units: PluginAreaUnit,
-  totalTargetArea: z66.number(),
-  totalAllocatedArea: z66.number(),
-  unassignedArea: z66.number(),
-  departments: z66.array(PluginProgramDepartmentMetric)
+  totalTargetArea: z67.number(),
+  totalAllocatedArea: z67.number(),
+  unassignedArea: z67.number(),
+  departments: z67.array(PluginProgramDepartmentMetric)
 }).refine(
   (s) => {
     const summed = s.unassignedArea + s.departments.reduce((acc, d) => acc + d.allocatedArea, 0);
@@ -3298,19 +3352,19 @@ var PluginProgramDepartmentsApi = class {
   constructor() {
   }
 };
-var PluginProgramDepartment = z67.object({
-  id: z67.string(),
-  name: z67.string(),
-  color: z67.string(),
-  targetArea: z67.number().nullable(),
-  targetCount: z67.number()
+var PluginProgramDepartment = z68.object({
+  id: z68.string(),
+  name: z68.string(),
+  color: z68.string(),
+  targetArea: z68.number().nullable(),
+  targetCount: z68.number()
 });
-var PluginProgramDepartmentsListResult = z67.object({
+var PluginProgramDepartmentsListResult = z68.object({
   units: PluginAreaUnit,
-  departments: z67.array(PluginProgramDepartment)
+  departments: z68.array(PluginProgramDepartment)
 });
-var PluginProgramDepartmentsGetArgs = z67.object({
-  departmentId: z67.string()
+var PluginProgramDepartmentsGetArgs = z68.object({
+  departmentId: z68.string()
 });
 var PluginProgramDepartmentsGetResult = PluginProgramDepartment.extend(
   {
@@ -3320,115 +3374,115 @@ var PluginProgramDepartmentsGetResult = PluginProgramDepartment.extend(
 var PluginProgramDepartmentRecord = PluginProgramDepartment.extend({
   units: PluginAreaUnit
 });
-var PluginProgramDepartmentsCreateArgs = z67.object({
-  name: z67.string(),
-  color: z67.string()
+var PluginProgramDepartmentsCreateArgs = z68.object({
+  name: z68.string(),
+  color: z68.string()
 });
-var PluginProgramDepartmentsCreateResult = z67.object({
-  departmentId: z67.string()
+var PluginProgramDepartmentsCreateResult = z68.object({
+  departmentId: z68.string()
 });
-var PluginProgramDepartmentsUpdateArgs = z67.object({
-  departmentId: z67.string(),
-  name: z67.string().optional(),
-  color: z67.string().optional()
+var PluginProgramDepartmentsUpdateArgs = z68.object({
+  departmentId: z68.string(),
+  name: z68.string().optional(),
+  color: z68.string().optional()
 });
 var PluginProgramDepartmentsUpdateResult = PluginProgramDepartmentRecord;
-var PluginProgramDepartmentsAssignArgs = z67.object({
-  departmentId: z67.string(),
-  spaceIds: z67.array(ComponentHandle).min(1)
+var PluginProgramDepartmentsAssignArgs = z68.object({
+  departmentId: z68.string(),
+  spaceIds: z68.array(ComponentHandle).min(1)
 });
-var PluginProgramDepartmentsAssignResult = z67.object({
-  departmentId: z67.string(),
-  spaceIds: z67.array(ComponentHandle)
+var PluginProgramDepartmentsAssignResult = z68.object({
+  departmentId: z68.string(),
+  spaceIds: z68.array(ComponentHandle)
 });
-var PluginProgramDepartmentsUnassignArgs = z67.object({
-  spaceIds: z67.array(ComponentHandle).min(1)
+var PluginProgramDepartmentsUnassignArgs = z68.object({
+  spaceIds: z68.array(ComponentHandle).min(1)
 });
-var PluginProgramDepartmentsUnassignResult = z67.object({
-  spaceIds: z67.array(ComponentHandle)
+var PluginProgramDepartmentsUnassignResult = z68.object({
+  spaceIds: z68.array(ComponentHandle)
 });
-var PluginProgramDepartmentsSetTargetAreaArgs = z67.object({
-  departmentId: z67.string(),
-  targetArea: z67.number(),
+var PluginProgramDepartmentsSetTargetAreaArgs = z68.object({
+  departmentId: z68.string(),
+  targetArea: z68.number(),
   units: PluginAreaUnit.optional()
 });
 var PluginProgramDepartmentsSetTargetAreaResult = PluginProgramDepartmentRecord;
-var PluginProgramDepartmentsSetTargetCountArgs = z67.object({
-  departmentId: z67.string(),
-  targetCount: z67.number().int().nonnegative()
+var PluginProgramDepartmentsSetTargetCountArgs = z68.object({
+  departmentId: z68.string(),
+  targetCount: z68.number().int().nonnegative()
 });
 var PluginProgramDepartmentsSetTargetCountResult = PluginProgramDepartmentRecord;
-var PluginProgramDepartmentsDeleteArgs = z67.object({
-  departmentId: z67.string()
+var PluginProgramDepartmentsDeleteArgs = z68.object({
+  departmentId: z68.string()
 });
-var PluginProgramDepartmentsDeleteResult = z67.object({
-  departmentId: z67.string(),
-  reassignedSpaceIds: z67.array(ComponentHandle)
+var PluginProgramDepartmentsDeleteResult = z68.object({
+  departmentId: z68.string(),
+  reassignedSpaceIds: z68.array(ComponentHandle)
 });
 
 // src/api/program/adjacency.ts
-import * as z68 from "zod";
+import * as z69 from "zod";
 var PluginProgramAdjacencyApi = class {
   constructor() {
   }
 };
-var PluginAdjacencyLevel = z68.enum(["department", "space"]);
-var PluginProgramAdjacencyGetMatrixArgs = z68.object({
+var PluginAdjacencyLevel = z69.enum(["department", "space"]);
+var PluginProgramAdjacencyGetMatrixArgs = z69.object({
   level: PluginAdjacencyLevel,
-  ids: z68.array(z68.string()).optional()
+  ids: z69.array(z69.string()).optional()
 });
-var PluginProgramAdjacencyGetMatrixResult = z68.object({
-  ids: z68.array(z68.string()),
-  departmentIds: z68.array(z68.string().nullable()).optional(),
-  matrix: z68.array(z68.array(z68.number()))
+var PluginProgramAdjacencyGetMatrixResult = z69.object({
+  ids: z69.array(z69.string()),
+  departmentIds: z69.array(z69.string().nullable()).optional(),
+  matrix: z69.array(z69.array(z69.number()))
 });
-var PluginProgramAdjacencyComputeResult = z68.object({
-  success: z68.boolean(),
-  error: z68.string().optional()
+var PluginProgramAdjacencyComputeResult = z69.object({
+  success: z69.boolean(),
+  error: z69.string().optional()
 });
 
 // src/api/program/layout.ts
-import * as z69 from "zod";
+import * as z70 from "zod";
 var PluginProgramLayoutApi = class {
   constructor() {
   }
 };
-var PluginProgramLayoutRunArgs = z69.object({
-  spaceIds: z69.array(z69.string()).optional(),
-  departmentIds: z69.array(z69.string()).optional(),
-  envelopeId: z69.string().optional(),
-  autoCommit: z69.boolean().optional()
+var PluginProgramLayoutRunArgs = z70.object({
+  spaceIds: z70.array(z70.string()).optional(),
+  departmentIds: z70.array(z70.string()).optional(),
+  envelopeId: z70.string().optional(),
+  autoCommit: z70.boolean().optional()
 });
-var PluginProgramLayoutRunResult = z69.object({
-  success: z69.boolean(),
-  error: z69.string().optional()
+var PluginProgramLayoutRunResult = z70.object({
+  success: z70.boolean(),
+  error: z70.string().optional()
 });
-var PluginProgramLayoutJobStatus = z69.enum([
+var PluginProgramLayoutJobStatus = z70.enum([
   "running",
   "active",
   "inactive",
   "pendingReview"
 ]);
-var PluginProgramLayoutJobState = z69.object({
+var PluginProgramLayoutJobState = z70.object({
   status: PluginProgramLayoutJobStatus,
-  totalSolutions: z69.number().int().optional()
+  totalSolutions: z70.number().int().optional()
 });
 var PluginProgramLayoutStateResult = PluginProgramLayoutJobState.nullable();
-var PluginProgramLayoutApplySolutionArgs = z69.object({
-  index: z69.number().int().min(0)
+var PluginProgramLayoutApplySolutionArgs = z70.object({
+  index: z70.number().int().min(0)
 });
-var PluginProgramLayoutApplyResult = z69.object({
-  success: z69.boolean(),
-  error: z69.string().optional()
+var PluginProgramLayoutApplyResult = z70.object({
+  success: z70.boolean(),
+  error: z70.string().optional()
 });
-var PluginProgramLayoutStackResult = z69.object({
-  success: z69.boolean(),
-  skippedStoreys: z69.array(z69.number()),
-  error: z69.string().optional()
+var PluginProgramLayoutStackResult = z70.object({
+  success: z70.boolean(),
+  skippedStoreys: z70.array(z70.number()),
+  error: z70.string().optional()
 });
 
 // src/api/program/spreadsheet.ts
-import * as z70 from "zod";
+import * as z71 from "zod";
 var PluginProgramSpreadsheetApi = class {
   constructor() {
   }
@@ -3445,85 +3499,85 @@ var PluginProgramSpreadsheetDatasetsApi = class {
   constructor() {
   }
 };
-var PluginSpreadsheetCell = z70.union([
-  z70.string(),
-  z70.number(),
-  z70.boolean(),
-  z70.null()
+var PluginSpreadsheetCell = z71.union([
+  z71.string(),
+  z71.number(),
+  z71.boolean(),
+  z71.null()
 ]);
-var PluginSpreadsheetAlign = z70.enum(["left", "center", "right"]);
-var PluginSpreadsheetColumn = z70.object({
-  key: z70.string(),
-  header: z70.string(),
-  width: z70.number().optional(),
-  format: z70.string().optional(),
+var PluginSpreadsheetAlign = z71.enum(["left", "center", "right"]);
+var PluginSpreadsheetColumn = z71.object({
+  key: z71.string(),
+  header: z71.string(),
+  width: z71.number().optional(),
+  format: z71.string().optional(),
   align: PluginSpreadsheetAlign.optional()
 });
-var PluginSpreadsheetTotal = z70.object({
-  column: z70.string(),
-  fn: z70.enum(["sum", "avg", "count", "min", "max"]),
-  label: z70.string().optional()
-});
-var PluginProgramSpreadsheetRenderArgs = z70.object({
-  sheetName: z70.string(),
-  columns: z70.array(PluginSpreadsheetColumn),
-  rows: z70.array(z70.record(z70.string(), PluginSpreadsheetCell)),
-  title: z70.string().optional(),
-  startCell: z70.string().optional(),
-  whenExists: z70.enum(["replace", "error"]).optional(),
-  asTable: z70.boolean().optional(),
-  freezeHeader: z70.boolean().optional(),
-  totals: z70.array(PluginSpreadsheetTotal).optional()
-});
-var PluginProgramSpreadsheetRenderResult = z70.object({
-  sheetName: z70.string(),
-  range: z70.string(),
-  headerRange: z70.string(),
-  rowCount: z70.number(),
-  colCount: z70.number(),
-  tableName: z70.string().nullable(),
-  replaced: z70.boolean()
-});
-var PluginProgramSpreadsheetRenderDatasetArgs = z70.object({
-  sheetName: z70.string().optional(),
-  title: z70.string().optional(),
-  filter: z70.string().optional()
-});
-var PluginSpreadsheetExportFormat = z70.enum(["xlsx", "pdf", "csv"]);
-var PluginProgramSpreadsheetExportArgs = z70.object({
+var PluginSpreadsheetTotal = z71.object({
+  column: z71.string(),
+  fn: z71.enum(["sum", "avg", "count", "min", "max"]),
+  label: z71.string().optional()
+});
+var PluginProgramSpreadsheetRenderArgs = z71.object({
+  sheetName: z71.string(),
+  columns: z71.array(PluginSpreadsheetColumn),
+  rows: z71.array(z71.record(z71.string(), PluginSpreadsheetCell)),
+  title: z71.string().optional(),
+  startCell: z71.string().optional(),
+  whenExists: z71.enum(["replace", "error"]).optional(),
+  asTable: z71.boolean().optional(),
+  freezeHeader: z71.boolean().optional(),
+  totals: z71.array(PluginSpreadsheetTotal).optional()
+});
+var PluginProgramSpreadsheetRenderResult = z71.object({
+  sheetName: z71.string(),
+  range: z71.string(),
+  headerRange: z71.string(),
+  rowCount: z71.number(),
+  colCount: z71.number(),
+  tableName: z71.string().nullable(),
+  replaced: z71.boolean()
+});
+var PluginProgramSpreadsheetRenderDatasetArgs = z71.object({
+  sheetName: z71.string().optional(),
+  title: z71.string().optional(),
+  filter: z71.string().optional()
+});
+var PluginSpreadsheetExportFormat = z71.enum(["xlsx", "pdf", "csv"]);
+var PluginProgramSpreadsheetExportArgs = z71.object({
   format: PluginSpreadsheetExportFormat,
-  fileName: z70.string().optional(),
-  sheetName: z70.string().optional()
+  fileName: z71.string().optional(),
+  sheetName: z71.string().optional()
 });
-var PluginProgramSpreadsheetExportResult = z70.object({
+var PluginProgramSpreadsheetExportResult = z71.object({
   format: PluginSpreadsheetExportFormat,
-  fileName: z70.string(),
-  mimeType: z70.string(),
-  dataBase64: z70.string()
-});
-var PluginSpreadsheetSheetInfo = z70.object({
-  name: z70.string(),
-  index: z70.number(),
-  visible: z70.boolean(),
-  rowCount: z70.number(),
-  colCount: z70.number()
-});
-var PluginProgramSpreadsheetListSheetsResult = z70.object({
-  sheets: z70.array(PluginSpreadsheetSheetInfo),
-  activeSheet: z70.string().nullable()
-});
-var PluginProgramSpreadsheetGetSheetDataArgs = z70.object({
-  sheetName: z70.string(),
-  range: z70.string().optional(),
-  header: z70.boolean().optional()
-});
-var PluginProgramSpreadsheetGetSheetDataResult = z70.object({
-  sheetName: z70.string(),
-  range: z70.string(),
-  values: z70.array(z70.array(PluginSpreadsheetCell)),
-  records: z70.array(z70.record(z70.string(), PluginSpreadsheetCell)).optional()
-});
-var PluginSpreadsheetChartType = z70.enum([
+  fileName: z71.string(),
+  mimeType: z71.string(),
+  dataBase64: z71.string()
+});
+var PluginSpreadsheetSheetInfo = z71.object({
+  name: z71.string(),
+  index: z71.number(),
+  visible: z71.boolean(),
+  rowCount: z71.number(),
+  colCount: z71.number()
+});
+var PluginProgramSpreadsheetListSheetsResult = z71.object({
+  sheets: z71.array(PluginSpreadsheetSheetInfo),
+  activeSheet: z71.string().nullable()
+});
+var PluginProgramSpreadsheetGetSheetDataArgs = z71.object({
+  sheetName: z71.string(),
+  range: z71.string().optional(),
+  header: z71.boolean().optional()
+});
+var PluginProgramSpreadsheetGetSheetDataResult = z71.object({
+  sheetName: z71.string(),
+  range: z71.string(),
+  values: z71.array(z71.array(PluginSpreadsheetCell)),
+  records: z71.array(z71.record(z71.string(), PluginSpreadsheetCell)).optional()
+});
+var PluginSpreadsheetChartType = z71.enum([
   "column",
   "bar",
   "line",
@@ -3531,262 +3585,262 @@ var PluginSpreadsheetChartType = z70.enum([
   "area",
   "scatter"
 ]);
-var PluginProgramSpreadsheetAddChartArgs = z70.object({
-  sheetName: z70.string(),
+var PluginProgramSpreadsheetAddChartArgs = z71.object({
+  sheetName: z71.string(),
   chartType: PluginSpreadsheetChartType,
-  dataRange: z70.string(),
-  title: z70.string().optional(),
-  position: z70.object({ x: z70.number(), y: z70.number() }).optional(),
-  size: z70.object({ width: z70.number(), height: z70.number() }).optional()
-});
-var PluginProgramSpreadsheetAddChartResult = z70.object({
-  chartId: z70.string()
-});
-var PluginProgramSpreadsheetHighlightCellsArgs = z70.object({
-  sheetName: z70.string(),
-  range: z70.string(),
-  color: z70.string().optional(),
-  bold: z70.boolean().optional()
-});
-var PluginProgramSpreadsheetHighlightCellsResult = z70.object({
-  sheetName: z70.string(),
-  range: z70.string()
-});
-var PluginSpreadsheetProgramRow = z70.object({
-  departmentId: z70.string(),
-  name: z70.string(),
-  targetArea: z70.number().nullable(),
-  allocatedArea: z70.number(),
-  variance: z70.number().nullable()
-});
-var PluginProgramSpreadsheetGetProgramResult = z70.object({
+  dataRange: z71.string(),
+  title: z71.string().optional(),
+  position: z71.object({ x: z71.number(), y: z71.number() }).optional(),
+  size: z71.object({ width: z71.number(), height: z71.number() }).optional()
+});
+var PluginProgramSpreadsheetAddChartResult = z71.object({
+  chartId: z71.string()
+});
+var PluginProgramSpreadsheetHighlightCellsArgs = z71.object({
+  sheetName: z71.string(),
+  range: z71.string(),
+  color: z71.string().optional(),
+  bold: z71.boolean().optional()
+});
+var PluginProgramSpreadsheetHighlightCellsResult = z71.object({
+  sheetName: z71.string(),
+  range: z71.string()
+});
+var PluginSpreadsheetProgramRow = z71.object({
+  departmentId: z71.string(),
+  name: z71.string(),
+  targetArea: z71.number().nullable(),
+  allocatedArea: z71.number(),
+  variance: z71.number().nullable()
+});
+var PluginProgramSpreadsheetGetProgramResult = z71.object({
   units: PluginAreaUnit,
-  rows: z70.array(PluginSpreadsheetProgramRow),
-  totalTargetArea: z70.number(),
-  totalAllocatedArea: z70.number(),
-  generatedAt: z70.string()
-});
-var PluginSpreadsheetTakeoffRow = z70.object({
-  objectType: z70.string(),
-  category: z70.string(),
-  family: z70.string(),
-  quantity: z70.number(),
-  unit: z70.string()
-});
-var PluginProgramSpreadsheetGetTakeoffResult = z70.object({
-  rows: z70.array(PluginSpreadsheetTakeoffRow),
-  rowCount: z70.number(),
-  generatedAt: z70.string()
-});
-var PluginSpreadsheetMaterialTakeoffRow = z70.object({
-  objectType: z70.string(),
-  family: z70.string(),
-  material: z70.string(),
-  quantity: z70.number(),
-  unit: z70.string()
-});
-var PluginProgramSpreadsheetGetMaterialTakeoffResult = z70.object({
-  rows: z70.array(PluginSpreadsheetMaterialTakeoffRow),
-  rowCount: z70.number(),
-  generatedAt: z70.string()
-});
-var PluginSpreadsheetWhenExists = z70.enum(["reuse", "replace", "error"]);
-var PluginProgramSpreadsheetCreateSheetArgs = z70.object({
-  name: z70.string(),
+  rows: z71.array(PluginSpreadsheetProgramRow),
+  totalTargetArea: z71.number(),
+  totalAllocatedArea: z71.number(),
+  generatedAt: z71.string()
+});
+var PluginSpreadsheetTakeoffRow = z71.object({
+  objectType: z71.string(),
+  category: z71.string(),
+  family: z71.string(),
+  quantity: z71.number(),
+  unit: z71.string()
+});
+var PluginProgramSpreadsheetGetTakeoffResult = z71.object({
+  rows: z71.array(PluginSpreadsheetTakeoffRow),
+  rowCount: z71.number(),
+  generatedAt: z71.string()
+});
+var PluginSpreadsheetMaterialTakeoffRow = z71.object({
+  objectType: z71.string(),
+  family: z71.string(),
+  material: z71.string(),
+  quantity: z71.number(),
+  unit: z71.string()
+});
+var PluginProgramSpreadsheetGetMaterialTakeoffResult = z71.object({
+  rows: z71.array(PluginSpreadsheetMaterialTakeoffRow),
+  rowCount: z71.number(),
+  generatedAt: z71.string()
+});
+var PluginSpreadsheetWhenExists = z71.enum(["reuse", "replace", "error"]);
+var PluginProgramSpreadsheetCreateSheetArgs = z71.object({
+  name: z71.string(),
   whenExists: PluginSpreadsheetWhenExists.optional()
 });
-var PluginProgramSpreadsheetCreateSheetResult = z70.object({
-  sheetName: z70.string(),
-  replaced: z70.boolean(),
-  sheetIndex: z70.number().nullable()
-});
-var PluginProgramSpreadsheetSetValuesArgs = z70.object({
-  sheetName: z70.string(),
-  values: z70.array(z70.array(PluginSpreadsheetCell)),
-  startCell: z70.string().optional()
-});
-var PluginProgramSpreadsheetSetValuesResult = z70.object({
-  sheetName: z70.string(),
-  startCell: z70.string(),
-  rowCount: z70.number(),
-  colCount: z70.number()
-});
-var PluginSpreadsheetFormula = z70.object({
-  cell: z70.string(),
-  formula: z70.string()
-});
-var PluginProgramSpreadsheetSetFormulasArgs = z70.object({
-  sheetName: z70.string(),
-  formulas: z70.array(PluginSpreadsheetFormula)
-});
-var PluginProgramSpreadsheetSetFormulasResult = z70.object({
-  sheetName: z70.string(),
-  count: z70.number()
-});
-var PluginSpreadsheetFontWeight = z70.enum(["normal", "bold"]);
-var PluginSpreadsheetFontStyle = z70.enum(["normal", "italic"]);
-var PluginSpreadsheetHorizontalAlign = z70.enum([
+var PluginProgramSpreadsheetCreateSheetResult = z71.object({
+  sheetName: z71.string(),
+  replaced: z71.boolean(),
+  sheetIndex: z71.number().nullable()
+});
+var PluginProgramSpreadsheetSetValuesArgs = z71.object({
+  sheetName: z71.string(),
+  values: z71.array(z71.array(PluginSpreadsheetCell)),
+  startCell: z71.string().optional()
+});
+var PluginProgramSpreadsheetSetValuesResult = z71.object({
+  sheetName: z71.string(),
+  startCell: z71.string(),
+  rowCount: z71.number(),
+  colCount: z71.number()
+});
+var PluginSpreadsheetFormula = z71.object({
+  cell: z71.string(),
+  formula: z71.string()
+});
+var PluginProgramSpreadsheetSetFormulasArgs = z71.object({
+  sheetName: z71.string(),
+  formulas: z71.array(PluginSpreadsheetFormula)
+});
+var PluginProgramSpreadsheetSetFormulasResult = z71.object({
+  sheetName: z71.string(),
+  count: z71.number()
+});
+var PluginSpreadsheetFontWeight = z71.enum(["normal", "bold"]);
+var PluginSpreadsheetFontStyle = z71.enum(["normal", "italic"]);
+var PluginSpreadsheetHorizontalAlign = z71.enum([
   "left",
   "center",
   "right",
   "general"
 ]);
-var PluginSpreadsheetVerticalAlign = z70.enum([
+var PluginSpreadsheetVerticalAlign = z71.enum([
   "top",
   "center",
   "bottom"
 ]);
-var PluginSpreadsheetCellStyle = z70.object({
-  backColor: z70.string().optional(),
-  foreColor: z70.string().optional(),
-  font: z70.string().optional(),
-  fontFamily: z70.string().optional(),
-  fontSize: z70.number().optional(),
+var PluginSpreadsheetCellStyle = z71.object({
+  backColor: z71.string().optional(),
+  foreColor: z71.string().optional(),
+  font: z71.string().optional(),
+  fontFamily: z71.string().optional(),
+  fontSize: z71.number().optional(),
   fontWeight: PluginSpreadsheetFontWeight.optional(),
   fontStyle: PluginSpreadsheetFontStyle.optional(),
-  formatter: z70.string().optional(),
+  formatter: z71.string().optional(),
   horizontalAlign: PluginSpreadsheetHorizontalAlign.optional(),
   verticalAlign: PluginSpreadsheetVerticalAlign.optional()
 });
-var PluginSpreadsheetRangeStyle = z70.object({
-  range: z70.string(),
+var PluginSpreadsheetRangeStyle = z71.object({
+  range: z71.string(),
   style: PluginSpreadsheetCellStyle
 });
-var PluginProgramSpreadsheetSetStylesArgs = z70.object({
-  sheetName: z70.string(),
-  ranges: z70.array(PluginSpreadsheetRangeStyle)
+var PluginProgramSpreadsheetSetStylesArgs = z71.object({
+  sheetName: z71.string(),
+  ranges: z71.array(PluginSpreadsheetRangeStyle)
 });
-var PluginProgramSpreadsheetSetStylesResult = z70.object({
-  sheetName: z70.string(),
-  count: z70.number()
+var PluginProgramSpreadsheetSetStylesResult = z71.object({
+  sheetName: z71.string(),
+  count: z71.number()
 });
-var PluginProgramSpreadsheetMergeCellsArgs = z70.object({
-  sheetName: z70.string(),
-  range: z70.string(),
+var PluginProgramSpreadsheetMergeCellsArgs = z71.object({
+  sheetName: z71.string(),
+  range: z71.string(),
   value: PluginSpreadsheetCell.optional()
 });
-var PluginProgramSpreadsheetMergeCellsResult = z70.object({
-  sheetName: z70.string(),
-  range: z70.string()
+var PluginProgramSpreadsheetMergeCellsResult = z71.object({
+  sheetName: z71.string(),
+  range: z71.string()
 });
-var PluginSpreadsheetConditionalRuleType = z70.enum(["dataBar"]);
-var PluginSpreadsheetConditionalRule = z70.object({
+var PluginSpreadsheetConditionalRuleType = z71.enum(["dataBar"]);
+var PluginSpreadsheetConditionalRule = z71.object({
   type: PluginSpreadsheetConditionalRuleType,
-  color: z70.string().optional()
+  color: z71.string().optional()
 });
-var PluginProgramSpreadsheetAddConditionalFormattingArgs = z70.object({
-  sheetName: z70.string(),
-  range: z70.string(),
+var PluginProgramSpreadsheetAddConditionalFormattingArgs = z71.object({
+  sheetName: z71.string(),
+  range: z71.string(),
   rule: PluginSpreadsheetConditionalRule
 });
-var PluginProgramSpreadsheetAddConditionalFormattingResult = z70.object({
-  sheetName: z70.string(),
-  range: z70.string(),
-  created: z70.boolean()
+var PluginProgramSpreadsheetAddConditionalFormattingResult = z71.object({
+  sheetName: z71.string(),
+  range: z71.string(),
+  created: z71.boolean()
 });
-var PluginProgramSpreadsheetRecalculateArgs = z70.object({
-  sheetName: z70.string().optional()
+var PluginProgramSpreadsheetRecalculateArgs = z71.object({
+  sheetName: z71.string().optional()
 });
-var PluginProgramSpreadsheetRecalculateResult = z70.object({
-  scope: z70.enum(["sheet", "workbook"]),
-  sheetName: z70.string().nullable()
+var PluginProgramSpreadsheetRecalculateResult = z71.object({
+  scope: z71.enum(["sheet", "workbook"]),
+  sheetName: z71.string().nullable()
 });
-var PluginSpreadsheetTransactionMethod = z70.enum([
+var PluginSpreadsheetTransactionMethod = z71.enum([
   "createSheet",
   "setValues",
   "setFormulas",
   "setStyles",
   "mergeCells"
 ]);
-var PluginSpreadsheetTransactionOp = z70.object({
+var PluginSpreadsheetTransactionOp = z71.object({
   method: PluginSpreadsheetTransactionMethod,
-  args: z70.unknown()
-});
-var PluginProgramSpreadsheetTransactionArgs = z70.object({
-  operations: z70.array(PluginSpreadsheetTransactionOp),
-  label: z70.string().optional()
-});
-var PluginProgramSpreadsheetTransactionResult = z70.object({
-  label: z70.string(),
-  operationCount: z70.number(),
-  results: z70.array(z70.unknown())
-});
-var PluginProgramSpreadsheetRunScriptArgs = z70.object({
-  script: z70.string()
-});
-var PluginProgramSpreadsheetRunScriptResult = z70.object({
-  result: z70.unknown()
-});
-var PluginSpreadsheetAuditStatus = z70.enum(["success", "error"]);
-var PluginSpreadsheetAuditEntry = z70.object({
-  id: z70.string(),
-  pluginId: z70.string(),
-  method: z70.string(),
-  label: z70.string().optional(),
-  sheetName: z70.string().optional(),
-  timestamp: z70.string(),
+  args: z71.unknown()
+});
+var PluginProgramSpreadsheetTransactionArgs = z71.object({
+  operations: z71.array(PluginSpreadsheetTransactionOp),
+  label: z71.string().optional()
+});
+var PluginProgramSpreadsheetTransactionResult = z71.object({
+  label: z71.string(),
+  operationCount: z71.number(),
+  results: z71.array(z71.unknown())
+});
+var PluginProgramSpreadsheetRunScriptArgs = z71.object({
+  script: z71.string()
+});
+var PluginProgramSpreadsheetRunScriptResult = z71.object({
+  result: z71.unknown()
+});
+var PluginSpreadsheetAuditStatus = z71.enum(["success", "error"]);
+var PluginSpreadsheetAuditEntry = z71.object({
+  id: z71.string(),
+  pluginId: z71.string(),
+  method: z71.string(),
+  label: z71.string().optional(),
+  sheetName: z71.string().optional(),
+  timestamp: z71.string(),
   status: PluginSpreadsheetAuditStatus,
-  summary: z70.string().optional()
+  summary: z71.string().optional()
 });
-var PluginProgramSpreadsheetGetAuditLogArgs = z70.object({
-  limit: z70.number().optional()
+var PluginProgramSpreadsheetGetAuditLogArgs = z71.object({
+  limit: z71.number().optional()
 });
-var PluginProgramSpreadsheetGetAuditLogResult = z70.object({
-  entries: z70.array(PluginSpreadsheetAuditEntry)
+var PluginProgramSpreadsheetGetAuditLogResult = z71.object({
+  entries: z71.array(PluginSpreadsheetAuditEntry)
 });
-var PluginProgramSpreadsheetPingResult = z70.object({
-  pong: z70.boolean()
+var PluginProgramSpreadsheetPingResult = z71.object({
+  pong: z71.boolean()
 });
-var PluginSpreadsheetTemplateScope = z70.enum(["project", "global"]);
-var PluginProgramSpreadsheetTemplatesCreateArgs = z70.object({
-  name: z70.string(),
-  sheetName: z70.string(),
+var PluginSpreadsheetTemplateScope = z71.enum(["project", "global"]);
+var PluginProgramSpreadsheetTemplatesCreateArgs = z71.object({
+  name: z71.string(),
+  sheetName: z71.string(),
   scope: PluginSpreadsheetTemplateScope.optional()
 });
-var PluginProgramSpreadsheetTemplatesCreateResult = z70.object({
-  id: z70.string(),
-  name: z70.string(),
+var PluginProgramSpreadsheetTemplatesCreateResult = z71.object({
+  id: z71.string(),
+  name: z71.string(),
   scope: PluginSpreadsheetTemplateScope,
-  sheetName: z70.string()
+  sheetName: z71.string()
 });
-var PluginProgramSpreadsheetTemplatesApplyArgs = z70.object({
-  name: z70.string(),
-  targetSheetName: z70.string()
+var PluginProgramSpreadsheetTemplatesApplyArgs = z71.object({
+  name: z71.string(),
+  targetSheetName: z71.string()
 });
-var PluginProgramSpreadsheetTemplatesApplyResult = z70.object({
-  name: z70.string(),
-  targetSheetName: z70.string()
+var PluginProgramSpreadsheetTemplatesApplyResult = z71.object({
+  name: z71.string(),
+  targetSheetName: z71.string()
 });
-var PluginSpreadsheetBindingSource = z70.discriminatedUnion("dataset", [
-  z70.object({ dataset: z70.literal("takeoff") }),
-  z70.object({ dataset: z70.literal("plugin"), name: z70.string() })
+var PluginSpreadsheetBindingSource = z71.discriminatedUnion("dataset", [
+  z71.object({ dataset: z71.literal("takeoff") }),
+  z71.object({ dataset: z71.literal("plugin"), name: z71.string() })
 ]);
-var PluginSpreadsheetBindingMode = z70.enum(["replaceRange"]);
-var PluginSpreadsheetBindingTarget = z70.object({
-  sheetName: z70.string(),
-  startCell: z70.string().optional()
-});
-var PluginSpreadsheetBinding = z70.object({
-  id: z70.string(),
-  name: z70.string(),
-  pluginId: z70.string(),
+var PluginSpreadsheetBindingMode = z71.enum(["replaceRange"]);
+var PluginSpreadsheetBindingTarget = z71.object({
+  sheetName: z71.string(),
+  startCell: z71.string().optional()
+});
+var PluginSpreadsheetBinding = z71.object({
+  id: z71.string(),
+  name: z71.string(),
+  pluginId: z71.string(),
   source: PluginSpreadsheetBindingSource,
-  target: z70.object({
-    sheetName: z70.string(),
-    startCell: z70.string()
+  target: z71.object({
+    sheetName: z71.string(),
+    startCell: z71.string()
   }),
   mode: PluginSpreadsheetBindingMode,
-  createdAt: z70.string(),
-  updatedAt: z70.string()
+  createdAt: z71.string(),
+  updatedAt: z71.string()
 });
-var PluginSpreadsheetBindingRefresh = z70.object({
-  id: z70.string(),
-  name: z70.string(),
-  sheetName: z70.string(),
-  rowCount: z70.number()
+var PluginSpreadsheetBindingRefresh = z71.object({
+  id: z71.string(),
+  name: z71.string(),
+  sheetName: z71.string(),
+  rowCount: z71.number()
 });
-var PluginProgramSpreadsheetBindingsCreateArgs = z70.object({
-  name: z70.string(),
+var PluginProgramSpreadsheetBindingsCreateArgs = z71.object({
+  name: z71.string(),
   source: PluginSpreadsheetBindingSource,
   target: PluginSpreadsheetBindingTarget,
   mode: PluginSpreadsheetBindingMode.optional()
@@ -3794,296 +3848,296 @@ var PluginProgramSpreadsheetBindingsCreateArgs = z70.object({
 var PluginProgramSpreadsheetBindingsCreateResult = PluginSpreadsheetBinding.extend({
   refresh: PluginSpreadsheetBindingRefresh
 });
-var PluginProgramSpreadsheetBindingsRefreshArgs = z70.object({
-  name: z70.string().optional()
+var PluginProgramSpreadsheetBindingsRefreshArgs = z71.object({
+  name: z71.string().optional()
 });
-var PluginProgramSpreadsheetBindingsRefreshResult = z70.object({
-  refreshed: z70.array(PluginSpreadsheetBindingRefresh)
+var PluginProgramSpreadsheetBindingsRefreshResult = z71.object({
+  refreshed: z71.array(PluginSpreadsheetBindingRefresh)
 });
-var PluginProgramSpreadsheetBindingsListResult = z70.object({
-  bindings: z70.array(PluginSpreadsheetBinding)
+var PluginProgramSpreadsheetBindingsListResult = z71.object({
+  bindings: z71.array(PluginSpreadsheetBinding)
 });
-var PluginProgramSpreadsheetDatasetsSetArgs = z70.object({
-  name: z70.string(),
-  columns: z70.array(PluginSpreadsheetColumn).min(1),
-  rows: z70.array(z70.record(z70.string(), PluginSpreadsheetCell)).max(1e4)
+var PluginProgramSpreadsheetDatasetsSetArgs = z71.object({
+  name: z71.string(),
+  columns: z71.array(PluginSpreadsheetColumn).min(1),
+  rows: z71.array(z71.record(z71.string(), PluginSpreadsheetCell)).max(1e4)
 });
-var PluginProgramSpreadsheetDatasetsSetResult = z70.object({
-  name: z70.string(),
-  rowCount: z70.number()
+var PluginProgramSpreadsheetDatasetsSetResult = z71.object({
+  name: z71.string(),
+  rowCount: z71.number()
 });
-var PluginSpreadsheetDataset = z70.object({
-  name: z70.string(),
-  rowCount: z70.number(),
-  updatedAt: z70.string()
+var PluginSpreadsheetDataset = z71.object({
+  name: z71.string(),
+  rowCount: z71.number(),
+  updatedAt: z71.string()
 });
-var PluginProgramSpreadsheetDatasetsListResult = z70.object({
-  datasets: z70.array(PluginSpreadsheetDataset)
+var PluginProgramSpreadsheetDatasetsListResult = z71.object({
+  datasets: z71.array(PluginSpreadsheetDataset)
 });
-var PluginProgramSpreadsheetAddImageArgs = z70.object({
-  sheetName: z70.string(),
-  image: z70.object({
-    dataUri: z70.string().max(2097152, "image.dataUri exceeds the 2 MB limit").regex(
+var PluginProgramSpreadsheetAddImageArgs = z71.object({
+  sheetName: z71.string(),
+  image: z71.object({
+    dataUri: z71.string().max(2097152, "image.dataUri exceeds the 2 MB limit").regex(
       /^data:image\/(png|jpeg|svg\+xml);base64,/,
       "image.dataUri must be a base64 data:image/png, jpeg, or svg+xml URI"
     )
   }),
-  anchorCell: z70.string().optional(),
-  size: z70.object({ width: z70.number(), height: z70.number() }).optional(),
-  name: z70.string().optional()
-});
-var PluginProgramSpreadsheetAddImageResult = z70.object({
-  sheetName: z70.string(),
-  name: z70.string()
-});
-var PluginSpreadsheetCustomSheet = z70.object({
-  sheetName: z70.string(),
-  groupBy: z70.array(z70.string()),
-  properties: z70.array(z70.string()),
-  groupColors: z70.record(z70.string(), z70.string()),
-  proposalId: z70.string().nullable()
-});
-var PluginSpreadsheetCustomSheetConfig = z70.object({
-  groupBy: z70.array(z70.string().trim().min(1)).max(10).optional(),
-  properties: z70.array(z70.string()).max(50).optional(),
-  groupColors: z70.record(z70.string(), z70.string()).optional()
+  anchorCell: z71.string().optional(),
+  size: z71.object({ width: z71.number(), height: z71.number() }).optional(),
+  name: z71.string().optional()
+});
+var PluginProgramSpreadsheetAddImageResult = z71.object({
+  sheetName: z71.string(),
+  name: z71.string()
+});
+var PluginSpreadsheetCustomSheet = z71.object({
+  sheetName: z71.string(),
+  groupBy: z71.array(z71.string()),
+  properties: z71.array(z71.string()),
+  groupColors: z71.record(z71.string(), z71.string()),
+  proposalId: z71.string().nullable()
+});
+var PluginSpreadsheetCustomSheetConfig = z71.object({
+  groupBy: z71.array(z71.string().trim().min(1)).max(10).optional(),
+  properties: z71.array(z71.string()).max(50).optional(),
+  groupColors: z71.record(z71.string(), z71.string()).optional()
 });
 var PluginProgramSpreadsheetCreateCustomSheetArgs = PluginSpreadsheetCustomSheetConfig.extend({
-  name: z70.string().trim().min(1)
+  name: z71.string().trim().min(1)
 });
 var PluginProgramSpreadsheetUpdateCustomSheetArgs = PluginSpreadsheetCustomSheetConfig.extend({
-  sheetName: z70.string().trim().min(1)
+  sheetName: z71.string().trim().min(1)
 });
 var PluginProgramSpreadsheetCustomSheetResult = PluginSpreadsheetCustomSheet;
-var PluginProgramSpreadsheetGetCustomSheetArgs = z70.object({
-  sheetName: z70.string().trim().min(1)
+var PluginProgramSpreadsheetGetCustomSheetArgs = z71.object({
+  sheetName: z71.string().trim().min(1)
 });
 var PluginProgramSpreadsheetGetCustomSheetResult = PluginSpreadsheetCustomSheet.nullable();
-var PluginProgramSpreadsheetListCustomSheetsResult = z70.object({
-  sheets: z70.array(PluginSpreadsheetCustomSheet)
+var PluginProgramSpreadsheetListCustomSheetsResult = z71.object({
+  sheets: z71.array(PluginSpreadsheetCustomSheet)
 });
-var PluginSpreadsheetCustomSheetProperty = z70.object({
-  id: z70.string(),
-  name: z70.string(),
-  groupable: z70.boolean(),
-  custom: z70.boolean()
+var PluginSpreadsheetCustomSheetProperty = z71.object({
+  id: z71.string(),
+  name: z71.string(),
+  groupable: z71.boolean(),
+  custom: z71.boolean()
 });
-var PluginProgramSpreadsheetListCustomSheetPropertiesResult = z70.object({
-  properties: z70.array(PluginSpreadsheetCustomSheetProperty)
+var PluginProgramSpreadsheetListCustomSheetPropertiesResult = z71.object({
+  properties: z71.array(PluginSpreadsheetCustomSheetProperty)
 });
 
 // src/api/program/site.ts
-import * as z71 from "zod";
+import * as z72 from "zod";
 var PluginProgramSiteApi = class {
   constructor() {
   }
 };
-var PluginSiteAnalysisRow = z71.object({
-  category: z71.string().min(1),
-  description: z71.string(),
-  quantity: z71.union([z71.string(), z71.number()]),
-  unit: z71.string()
+var PluginSiteAnalysisRow = z72.object({
+  category: z72.string().min(1),
+  description: z72.string(),
+  quantity: z72.union([z72.string(), z72.number()]),
+  unit: z72.string()
 });
-var PluginSiteAnalysisUpdateOptions = z71.object({
-  siteLocation: z71.object({ lat: z71.number(), lng: z71.number() }).optional(),
+var PluginSiteAnalysisUpdateOptions = z72.object({
+  siteLocation: z72.object({ lat: z72.number(), lng: z72.number() }).optional(),
   /** JSON-encoded polygon string written to the Site Polygon row. */
-  sitePolygon: z71.string().optional()
+  sitePolygon: z72.string().optional()
 }).nullish();
-var PluginProgramSiteAnalysisResult = z71.object({
-  sheetName: z71.string(),
-  siteLocation: z71.object({ lat: z71.number(), lng: z71.number() }).nullable(),
-  sitePolygon: z71.string().nullable(),
-  rows: z71.array(PluginSiteAnalysisRow)
+var PluginProgramSiteAnalysisResult = z72.object({
+  sheetName: z72.string(),
+  siteLocation: z72.object({ lat: z72.number(), lng: z72.number() }).nullable(),
+  sitePolygon: z72.string().nullable(),
+  rows: z72.array(PluginSiteAnalysisRow)
 }).nullable();
-var PluginProgramSiteAnalysisUpdateResult = z71.object({
-  sheetName: z71.string(),
+var PluginProgramSiteAnalysisUpdateResult = z72.object({
+  sheetName: z72.string(),
   /** Constraint rows on the sheet after the write. */
-  rowCount: z71.number(),
-  updatedRows: z71.number(),
-  appendedRows: z71.number()
+  rowCount: z72.number(),
+  updatedRows: z72.number(),
+  appendedRows: z72.number()
 });
-var PluginSiteFootprintPoint = z71.object({
-  x: z71.number(),
-  z: z71.number()
+var PluginSiteFootprintPoint = z72.object({
+  x: z72.number(),
+  z: z72.number()
 });
-var PluginSiteGeoPoint = z71.object({
-  lat: z71.number(),
-  lng: z71.number(),
-  alt: z71.number()
+var PluginSiteGeoPoint = z72.object({
+  lat: z72.number(),
+  lng: z72.number(),
+  alt: z72.number()
 });
-var PluginSitePolygon = z71.object({
-  id: z71.string(),
-  area: z71.number(),
-  label: z71.string(),
-  footprint: z71.array(PluginSiteFootprintPoint)
+var PluginSitePolygon = z72.object({
+  id: z72.string(),
+  area: z72.number(),
+  label: z72.string(),
+  footprint: z72.array(PluginSiteFootprintPoint)
 });
-var PluginProgramSiteSnapshot = z71.object({
+var PluginProgramSiteSnapshot = z72.object({
   units: PluginAreaUnit,
-  totalArea: z71.number(),
-  polygonCount: z71.number(),
-  polygons: z71.array(PluginSitePolygon)
+  totalArea: z72.number(),
+  polygonCount: z72.number(),
+  polygons: z72.array(PluginSitePolygon)
 });
-var PluginProgramSiteAreaResult = z71.object({
+var PluginProgramSiteAreaResult = z72.object({
   units: PluginAreaUnit,
-  area: z71.number()
+  area: z72.number()
 });
-var PluginProgramSiteListPolygonsResult = z71.object({
+var PluginProgramSiteListPolygonsResult = z72.object({
   units: PluginAreaUnit,
-  polygons: z71.array(PluginSitePolygon)
+  polygons: z72.array(PluginSitePolygon)
 });
-var PluginProgramSiteListGeoPolygonsResult = z71.object({
-  polygons: z71.array(z71.array(PluginSiteGeoPoint))
+var PluginProgramSiteListGeoPolygonsResult = z72.object({
+  polygons: z72.array(z72.array(PluginSiteGeoPoint))
 });
-var PluginSiteLatLng = z71.object({
-  lat: z71.number(),
-  lng: z71.number()
+var PluginSiteLatLng = z72.object({
+  lat: z72.number(),
+  lng: z72.number()
 });
-var PluginSiteBounds = z71.object({
-  north: z71.number(),
-  south: z71.number(),
-  east: z71.number(),
-  west: z71.number()
+var PluginSiteBounds = z72.object({
+  north: z72.number(),
+  south: z72.number(),
+  east: z72.number(),
+  west: z72.number()
 });
-var PluginSiteContextParcel = z71.object({
-  footprint: z71.array(PluginSiteLatLng),
-  area: z71.number()
+var PluginSiteContextParcel = z72.object({
+  footprint: z72.array(PluginSiteLatLng),
+  area: z72.number()
 });
-var PluginProgramSiteContext = z71.object({
+var PluginProgramSiteContext = z72.object({
   center: PluginSiteLatLng,
   bounds: PluginSiteBounds,
-  widthInM: z71.number(),
-  heightInM: z71.number(),
-  zoom: z71.number(),
-  parcels: z71.array(PluginSiteContextParcel)
+  widthInM: z72.number(),
+  heightInM: z72.number(),
+  zoom: z72.number(),
+  parcels: z72.array(PluginSiteContextParcel)
 });
 var PluginProgramSiteContextResult = PluginProgramSiteContext.nullable();
-var PluginProgramSiteLocation = z71.object({
-  latitude: z71.number(),
-  longitude: z71.number()
+var PluginProgramSiteLocation = z72.object({
+  latitude: z72.number(),
+  longitude: z72.number()
 });
 var PluginProgramSiteLocationResult = PluginProgramSiteLocation.nullable();
-var PluginProgramSiteNorthAngleResult = z71.number().nullable();
-var PluginProgramSiteTimezoneResult = z71.string().nullable();
-var PluginProgramSiteWeather = z71.object({
-  weatherFileId: z71.string(),
-  station: z71.string(),
-  checksum: z71.string(),
-  selectionMethod: z71.enum([
+var PluginProgramSiteNorthAngleResult = z72.number().nullable();
+var PluginProgramSiteTimezoneResult = z72.string().nullable();
+var PluginProgramSiteWeather = z72.object({
+  weatherFileId: z72.string(),
+  station: z72.string(),
+  checksum: z72.string(),
+  selectionMethod: z72.enum([
     "nearest-station",
     "user-upload",
     "project-override"
   ])
 });
 var PluginProgramSiteWeatherResult = PluginProgramSiteWeather.nullable();
-var PluginProgramSiteEdgeRole = z71.enum(["front", "side", "rear"]);
-var PluginProgramSiteEdge = z71.object({
-  edgeIndex: z71.number().int().nonnegative(),
-  start: z71.object({ x: z71.number(), z: z71.number() }),
-  end: z71.object({ x: z71.number(), z: z71.number() }),
-  lengthMeters: z71.number(),
+var PluginProgramSiteEdgeRole = z72.enum(["front", "side", "rear"]);
+var PluginProgramSiteEdge = z72.object({
+  edgeIndex: z72.number().int().nonnegative(),
+  start: z72.object({ x: z72.number(), z: z72.number() }),
+  end: z72.object({ x: z72.number(), z: z72.number() }),
+  lengthMeters: z72.number(),
   role: PluginProgramSiteEdgeRole,
-  roleSource: z71.enum(["override", "heuristic"]),
-  setbackMeters: z71.number().nullable()
+  roleSource: z72.enum(["override", "heuristic"]),
+  setbackMeters: z72.number().nullable()
 });
-var PluginProgramSiteEdgesEntry = z71.object({
-  siteId: z71.string(),
-  buildableEnvelopeId: z71.string().nullable(),
-  usingLiveSiteBoundary: z71.boolean(),
-  staleOverridesDropped: z71.boolean(),
-  edges: z71.array(PluginProgramSiteEdge)
+var PluginProgramSiteEdgesEntry = z72.object({
+  siteId: z72.string(),
+  buildableEnvelopeId: z72.string().nullable(),
+  usingLiveSiteBoundary: z72.boolean(),
+  staleOverridesDropped: z72.boolean(),
+  edges: z72.array(PluginProgramSiteEdge)
 });
-var PluginProgramSiteListEdgesResult = z71.object({
-  lengthUnit: z71.literal("m"),
-  sites: z71.array(PluginProgramSiteEdgesEntry)
+var PluginProgramSiteListEdgesResult = z72.object({
+  lengthUnit: z72.literal("m"),
+  sites: z72.array(PluginProgramSiteEdgesEntry)
 });
 
 // src/api/program/cores.ts
-import * as z72 from "zod";
+import * as z73 from "zod";
 var PluginProgramCoresApi = class {
   constructor() {
   }
 };
-var PluginProgramCore = z72.object({
-  id: z72.string(),
-  groupId: z72.string(),
-  storey: z72.number()
+var PluginProgramCore = z73.object({
+  id: z73.string(),
+  groupId: z73.string(),
+  storey: z73.number()
 });
-var PluginProgramCoresListResult = z72.object({
-  cores: z72.array(PluginProgramCore)
+var PluginProgramCoresListResult = z73.object({
+  cores: z73.array(PluginProgramCore)
 });
-var PluginProgramCoresIsCoreArgs = z72.object({
-  id: z72.string()
+var PluginProgramCoresIsCoreArgs = z73.object({
+  id: z73.string()
 });
 
 // src/api/program/classification.ts
-import * as z73 from "zod";
+import * as z74 from "zod";
 var PluginProgramClassificationApi = class {
   constructor() {
   }
 };
-var PluginClassificationOption = z73.object({
-  value: z73.string(),
-  label: z73.string()
+var PluginClassificationOption = z74.object({
+  value: z74.string(),
+  label: z74.string()
 });
-var PluginProgramClassificationTypesResult = z73.object({
-  spaceTypes: z73.array(PluginClassificationOption),
-  areaClasses: z73.array(PluginClassificationOption),
-  massTypes: z73.array(PluginClassificationOption)
+var PluginProgramClassificationTypesResult = z74.object({
+  spaceTypes: z74.array(PluginClassificationOption),
+  areaClasses: z74.array(PluginClassificationOption),
+  massTypes: z74.array(PluginClassificationOption)
 });
-var PluginProgramClassificationListTagsArgs = z73.object({
-  id: z73.string()
+var PluginProgramClassificationListTagsArgs = z74.object({
+  id: z74.string()
 });
-var PluginSpaceTag = z73.object({
-  tagId: z73.string(),
-  tagName: z73.string(),
-  color: z73.string(),
-  categoryId: z73.string()
+var PluginSpaceTag = z74.object({
+  tagId: z74.string(),
+  tagName: z74.string(),
+  color: z74.string(),
+  categoryId: z74.string()
 });
-var PluginProgramClassificationTagsResult = z73.object({
-  tagIds: z73.array(z73.string()),
-  tagsByCategory: z73.record(z73.string(), PluginSpaceTag)
+var PluginProgramClassificationTagsResult = z74.object({
+  tagIds: z74.array(z74.string()),
+  tagsByCategory: z74.record(z74.string(), PluginSpaceTag)
 });
 
 // src/api/program/areas.ts
-import * as z74 from "zod";
+import * as z75 from "zod";
 var PluginProgramAreasApi = class {
   constructor() {
   }
 };
-var PluginProgramAreaSummary = z74.object({
-  count: z74.number().int(),
-  hiddenCount: z74.number().int(),
-  carpet: z74.number(),
-  builtUp: z74.number(),
-  excluded: z74.number(),
-  farBuiltUp: z74.number(),
-  siteArea: z74.number(),
-  achievedFar: z74.number().nullable(),
-  targetFar: z74.number(),
-  deviation: z74.number(),
+var PluginProgramAreaSummary = z75.object({
+  count: z75.number().int(),
+  hiddenCount: z75.number().int(),
+  carpet: z75.number(),
+  builtUp: z75.number(),
+  excluded: z75.number(),
+  farBuiltUp: z75.number(),
+  siteArea: z75.number(),
+  achievedFar: z75.number().nullable(),
+  targetFar: z75.number(),
+  deviation: z75.number(),
   areaUnit: PluginAreaUnit
 });
-var PluginProgramAreaGroup = z74.object({
-  groupId: z74.string(),
-  name: z74.string(),
-  color: z74.string(),
-  carpet: z74.number(),
-  builtUp: z74.number(),
-  excluded: z74.number(),
-  count: z74.number().int(),
-  targetArea: z74.number(),
+var PluginProgramAreaGroup = z75.object({
+  groupId: z75.string(),
+  name: z75.string(),
+  color: z75.string(),
+  carpet: z75.number(),
+  builtUp: z75.number(),
+  excluded: z75.number(),
+  count: z75.number().int(),
+  targetArea: z75.number(),
   targetUnit: PluginAreaUnit
 });
-var PluginProgramAreaMember = z74.object({
+var PluginProgramAreaMember = z75.object({
   id: ComponentHandle,
-  label: z74.string(),
+  label: z75.string(),
   areaClass: PluginAreaClass,
-  carpet: z74.number(),
-  builtUp: z74.number(),
-  excluded: z74.number(),
-  isVisible: z74.boolean()
+  carpet: z75.number(),
+  builtUp: z75.number(),
+  excluded: z75.number(),
+  isVisible: z75.boolean()
 });
-var PluginProgramAreaGroupBy = z74.enum([
+var PluginProgramAreaGroupBy = z75.enum([
   "labels",
   "storeys",
   "buildings",
@@ -4091,137 +4145,137 @@ var PluginProgramAreaGroupBy = z74.enum([
   "tagCategories"
 ]);
 var PluginProgramAreasGetResult = PluginProgramAreaSummary;
-var PluginProgramAreasListArgs = z74.object({
+var PluginProgramAreasListArgs = z75.object({
   groupBy: PluginProgramAreaGroupBy,
-  categoryId: z74.string().optional()
+  categoryId: z75.string().optional()
 }).refine((v) => v.groupBy !== "tagCategories" || v.categoryId != null, {
   message: 'categoryId is required when groupBy is "tagCategories"'
 });
-var PluginProgramAreasListResult = z74.object({
-  groups: z74.array(PluginProgramAreaGroup)
+var PluginProgramAreasListResult = z75.object({
+  groups: z75.array(PluginProgramAreaGroup)
 });
-var PluginProgramAreasListMembersArgs = z74.object({
+var PluginProgramAreasListMembersArgs = z75.object({
   groupBy: PluginProgramAreaGroupBy,
-  groupId: z74.string(),
-  categoryId: z74.string().optional()
+  groupId: z75.string(),
+  categoryId: z75.string().optional()
 }).refine((v) => v.groupBy !== "tagCategories" || v.categoryId != null, {
   message: 'categoryId is required when groupBy is "tagCategories"'
 });
-var PluginProgramAreasListMembersResult = z74.object({
-  members: z74.array(PluginProgramAreaMember)
+var PluginProgramAreasListMembersResult = z75.object({
+  members: z75.array(PluginProgramAreaMember)
 });
-var PluginProgramAreasUpdateArgs = z74.object({
-  targetFar: z74.number().min(0).optional(),
-  siteArea: z74.number().positive().optional(),
-  deviation: z74.number().min(0).max(100).optional()
+var PluginProgramAreasUpdateArgs = z75.object({
+  targetFar: z75.number().min(0).optional(),
+  siteArea: z75.number().positive().optional(),
+  deviation: z75.number().min(0).max(100).optional()
 });
 var PluginProgramAreasUpdateResult = PluginProgramAreaSummary;
 var PluginProgramAreasRefreshResult = PluginProgramAreaSummary;
 
 // src/api/program/metadata.ts
-import * as z75 from "zod";
+import * as z76 from "zod";
 var PluginProgramMetadataApi = class {
   constructor() {
   }
 };
-var PluginProgramMetadataHeader = z75.object({
-  headerId: z75.string(),
-  name: z75.string(),
-  description: z75.string(),
-  columnIndex: z75.number()
+var PluginProgramMetadataHeader = z76.object({
+  headerId: z76.string(),
+  name: z76.string(),
+  description: z76.string(),
+  columnIndex: z76.number()
 });
-var PluginProgramMetadataListHeadersResult = z75.object({
-  headers: z75.array(PluginProgramMetadataHeader)
+var PluginProgramMetadataListHeadersResult = z76.object({
+  headers: z76.array(PluginProgramMetadataHeader)
 });
-var PluginProgramMetadataCreateHeaderArgs = z75.object({
-  name: z75.string().trim().min(1),
-  description: z75.string().optional()
+var PluginProgramMetadataCreateHeaderArgs = z76.object({
+  name: z76.string().trim().min(1),
+  description: z76.string().optional()
 });
 var PluginProgramMetadataCreateHeaderResult = PluginProgramMetadataHeader;
-var PluginProgramMetadataRecord = z75.object({
+var PluginProgramMetadataRecord = z76.object({
   spaceId: ComponentHandle,
-  values: z75.record(z75.string(), PluginSpreadsheetCell)
+  values: z76.record(z76.string(), PluginSpreadsheetCell)
 });
-var PluginProgramMetadataGetArgs = z75.object({
+var PluginProgramMetadataGetArgs = z76.object({
   spaceId: ComponentHandle
 });
 var PluginProgramMetadataGetResult = PluginProgramMetadataRecord.nullable();
-var PluginProgramMetadataListArgs = z75.object({
-  spaceIds: z75.array(ComponentHandle).optional()
+var PluginProgramMetadataListArgs = z76.object({
+  spaceIds: z76.array(ComponentHandle).optional()
 });
-var PluginProgramMetadataListResult = z75.object({
-  records: z75.array(PluginProgramMetadataRecord)
+var PluginProgramMetadataListResult = z76.object({
+  records: z76.array(PluginProgramMetadataRecord)
 });
-var PluginProgramMetadataUpdateArgs = z75.object({
+var PluginProgramMetadataUpdateArgs = z76.object({
   spaceId: ComponentHandle,
-  values: z75.record(z75.string(), PluginSpreadsheetCell).refine((v) => Object.keys(v).length > 0, "values must not be empty")
+  values: z76.record(z76.string(), PluginSpreadsheetCell).refine((v) => Object.keys(v).length > 0, "values must not be empty")
 });
 var PluginProgramMetadataUpdateResult = PluginProgramMetadataRecord;
 var PluginProgramMetadataUpdateItem = PluginProgramMetadataUpdateArgs;
 var PLUGIN_PROGRAM_METADATA_BATCH_LIMIT = 1e3;
-var PluginProgramMetadataUpdateManyArgs = z75.object({
-  items: z75.array(PluginProgramMetadataUpdateItem).min(1).max(PLUGIN_PROGRAM_METADATA_BATCH_LIMIT)
+var PluginProgramMetadataUpdateManyArgs = z76.object({
+  items: z76.array(PluginProgramMetadataUpdateItem).min(1).max(PLUGIN_PROGRAM_METADATA_BATCH_LIMIT)
 });
-var PluginProgramMetadataUpdateManyResult = z75.object({
-  records: z75.array(PluginProgramMetadataRecord)
+var PluginProgramMetadataUpdateManyResult = z76.object({
+  records: z76.array(PluginProgramMetadataRecord)
 });
 
 // src/api/program/labels.ts
-import * as z76 from "zod";
+import * as z77 from "zod";
 var PluginProgramLabelsApi = class {
   constructor() {
   }
 };
-var PluginProgramLabel = z76.object({
-  id: z76.string(),
-  name: z76.string(),
-  color: z76.string(),
-  departmentId: z76.string(),
-  targetArea: z76.number().nullable(),
-  targetCount: z76.number(),
-  storey: z76.number().nullable()
+var PluginProgramLabel = z77.object({
+  id: z77.string(),
+  name: z77.string(),
+  color: z77.string(),
+  departmentId: z77.string(),
+  targetArea: z77.number().nullable(),
+  targetCount: z77.number(),
+  storey: z77.number().nullable()
 });
 var PluginProgramLabelRecord = PluginProgramLabel.extend({
   units: PluginAreaUnit
 });
-var PluginProgramLabelsListResult = z76.object({
+var PluginProgramLabelsListResult = z77.object({
   units: PluginAreaUnit,
-  labels: z76.array(PluginProgramLabel)
+  labels: z77.array(PluginProgramLabel)
 });
-var PluginProgramLabelsGetArgs = z76.object({
-  labelId: z76.string()
+var PluginProgramLabelsGetArgs = z77.object({
+  labelId: z77.string()
 });
 var PluginProgramLabelsGetResult = PluginProgramLabelRecord.nullable();
-var PluginProgramLabelCreateItem = z76.object({
-  name: z76.string().trim().min(1),
-  targetArea: z76.number().finite().nonnegative().optional(),
-  targetCount: z76.number().int().nonnegative().optional(),
-  departmentId: z76.string().optional(),
-  departmentName: z76.string().optional(),
-  color: z76.string().optional(),
-  storey: z76.number().int().optional(),
-  height: z76.number().finite().positive().optional(),
-  width: z76.number().finite().positive().optional()
+var PluginProgramLabelCreateItem = z77.object({
+  name: z77.string().trim().min(1),
+  targetArea: z77.number().finite().nonnegative().optional(),
+  targetCount: z77.number().int().nonnegative().optional(),
+  departmentId: z77.string().optional(),
+  departmentName: z77.string().optional(),
+  color: z77.string().optional(),
+  storey: z77.number().int().optional(),
+  height: z77.number().finite().positive().optional(),
+  width: z77.number().finite().positive().optional()
 });
 var PLUGIN_PROGRAM_LABELS_BATCH_LIMIT = 500;
-var PluginProgramLabelsCreateArgs = z76.object({
-  items: z76.array(PluginProgramLabelCreateItem).min(1).max(PLUGIN_PROGRAM_LABELS_BATCH_LIMIT),
+var PluginProgramLabelsCreateArgs = z77.object({
+  items: z77.array(PluginProgramLabelCreateItem).min(1).max(PLUGIN_PROGRAM_LABELS_BATCH_LIMIT),
   units: PluginAreaUnit.optional(),
-  createSpaces: z76.boolean().optional()
+  createSpaces: z77.boolean().optional()
 });
-var PluginProgramLabelsCreateResult = z76.object({
-  labelIds: z76.array(z76.string()),
-  createdSpaces: z76.boolean()
+var PluginProgramLabelsCreateResult = z77.object({
+  labelIds: z77.array(z77.string()),
+  createdSpaces: z77.boolean()
 });
-var PluginProgramLabelsSetTargetAreaArgs = z76.object({
-  labelId: z76.string(),
-  targetArea: z76.number().finite().nonnegative(),
+var PluginProgramLabelsSetTargetAreaArgs = z77.object({
+  labelId: z77.string(),
+  targetArea: z77.number().finite().nonnegative(),
   units: PluginAreaUnit.optional()
 });
 var PluginProgramLabelsSetTargetAreaResult = PluginProgramLabelRecord;
-var PluginProgramLabelsSetTargetCountArgs = z76.object({
-  labelId: z76.string(),
-  targetCount: z76.number().int().nonnegative()
+var PluginProgramLabelsSetTargetCountArgs = z77.object({
+  labelId: z77.string(),
+  targetCount: z77.number().int().nonnegative()
 });
 var PluginProgramLabelsSetTargetCountResult = PluginProgramLabelRecord;
 
@@ -4232,72 +4286,72 @@ var PluginProgramApi = class {
 };
 
 // src/api/presentation/views.ts
-import * as z77 from "zod";
+import * as z78 from "zod";
 var PluginPresentationViewsApi = class {
   constructor() {
   }
 };
-var PluginPresentationViewType = z77.enum(["2d", "3d"]);
-var PluginPresentationView = z77.object({
-  id: z77.string(),
-  name: z77.string(),
+var PluginPresentationViewType = z78.enum(["2d", "3d"]);
+var PluginPresentationView = z78.object({
+  id: z78.string(),
+  name: z78.string(),
   type: PluginPresentationViewType,
-  isActive: z77.boolean(),
-  storey: z77.number().nullable()
+  isActive: z78.boolean(),
+  storey: z78.number().nullable()
 });
-var PluginPresentationViewsListResult = z77.object({
-  views: z77.array(PluginPresentationView)
+var PluginPresentationViewsListResult = z78.object({
+  views: z78.array(PluginPresentationView)
 });
-var PluginPresentationViewsGetArgs = z77.object({
-  id: z77.string()
+var PluginPresentationViewsGetArgs = z78.object({
+  id: z78.string()
 });
 var PluginPresentationViewsGetResult = PluginPresentationView.nullable();
-var PluginPresentationImageFormat = z77.enum(["png", "jpeg"]);
-var PluginPresentationViewsCaptureArgs = z77.object({
-  viewId: z77.string().optional(),
+var PluginPresentationImageFormat = z78.enum(["png", "jpeg"]);
+var PluginPresentationViewsCaptureArgs = z78.object({
+  viewId: z78.string().optional(),
   format: PluginPresentationImageFormat.optional(),
-  resolution: z77.string().optional()
+  resolution: z78.string().optional()
 });
-var PluginPresentationViewsCaptureResult = z77.object({
-  image: z77.string()
+var PluginPresentationViewsCaptureResult = z78.object({
+  image: z78.string()
 });
-var PluginPresentationViewsSetActiveArgs = z77.object({
-  id: z77.string()
+var PluginPresentationViewsSetActiveArgs = z78.object({
+  id: z78.string()
 });
-var PluginPresentationViewsSetActiveResult = z77.object({
-  id: z77.string()
+var PluginPresentationViewsSetActiveResult = z78.object({
+  id: z78.string()
 });
-var PluginPresentationViewsCreateArgs = z77.object({
-  name: z77.string().optional(),
-  kind: z77.enum(["view", "sitePlan"]).optional(),
-  storey: z77.number().optional()
+var PluginPresentationViewsCreateArgs = z78.object({
+  name: z78.string().optional(),
+  kind: z78.enum(["view", "sitePlan"]).optional(),
+  storey: z78.number().optional()
 });
 var PluginPresentationViewsCreateResult = PluginPresentationView;
-var PluginPresentationViewColorMode = z77.union([
-  z77.enum(["monochrome", "texture", "department"]),
-  z77.templateLiteral(["tag:", z77.string()])
+var PluginPresentationViewColorMode = z78.union([
+  z78.enum(["monochrome", "texture", "department"]),
+  z78.templateLiteral(["tag:", z78.string()])
 ]);
-var PluginPresentationViewLabel = z77.enum([
+var PluginPresentationViewLabel = z78.enum([
   "objectLabels",
   "areas",
   "department"
 ]);
-var PluginPresentationViewMode = z77.enum(["perspective", "isometric"]);
-var PluginPresentationViewSettings = z77.object({
-  backgroundColor: z77.string(),
+var PluginPresentationViewMode = z78.enum(["perspective", "isometric"]);
+var PluginPresentationViewSettings = z78.object({
+  backgroundColor: z78.string(),
   colorMode: PluginPresentationViewColorMode,
   viewMode: PluginPresentationViewMode,
-  showAxis: z77.boolean(),
-  showEdges: z77.boolean(),
-  showLabels: z77.boolean(),
-  labels: z77.array(PluginPresentationViewLabel)
+  showAxis: z78.boolean(),
+  showEdges: z78.boolean(),
+  showLabels: z78.boolean(),
+  labels: z78.array(PluginPresentationViewLabel)
 });
-var PluginPresentationViewsGetSettingsArgs = z77.object({
-  id: z77.string()
+var PluginPresentationViewsGetSettingsArgs = z78.object({
+  id: z78.string()
 });
 var PluginPresentationViewsGetSettingsResult = PluginPresentationViewSettings.nullable();
-var PluginPresentationViewsUpdateSettingsArgs = z77.object({
-  id: z77.string(),
+var PluginPresentationViewsUpdateSettingsArgs = z78.object({
+  id: z78.string(),
   settings: PluginPresentationViewSettings.partial()
 }).refine(
   (v) => !(v.settings.showLabels === false && (v.settings.labels?.length ?? 0) > 0),
@@ -4310,28 +4364,28 @@ var PluginPresentationViewsUpdateSettingsArgs = z77.object({
     message: "Contradictory patch: showLabels cannot be true with an explicitly empty labels list \u2014 pass a non-empty list, or omit labels to apply the defaults"
   }
 );
-var PluginPresentationViewsUpdateSettingsResult = z77.object({
-  id: z77.string()
+var PluginPresentationViewsUpdateSettingsResult = z78.object({
+  id: z78.string()
 });
-var PluginPresentationViewsRenameArgs = z77.object({
-  id: z77.string(),
-  name: z77.string().trim().min(1)
+var PluginPresentationViewsRenameArgs = z78.object({
+  id: z78.string(),
+  name: z78.string().trim().min(1)
 });
 var PluginPresentationViewsRenameResult = PluginPresentationView;
-var PluginPresentationViewsDeleteArgs = z77.object({
-  id: z77.string()
+var PluginPresentationViewsDeleteArgs = z78.object({
+  id: z78.string()
 });
-var PluginPresentationViewsDeleteResult = z77.object({
-  id: z77.string()
+var PluginPresentationViewsDeleteResult = z78.object({
+  id: z78.string()
 });
 
 // src/api/presentation/sheets.ts
-import * as z78 from "zod";
+import * as z79 from "zod";
 var PluginPresentationSheetsApi = class {
   constructor() {
   }
 };
-var PluginSheetSize = z78.enum([
+var PluginSheetSize = z79.enum([
   "ANSI_A",
   "ANSI_B",
   "ANSI_C",
@@ -4349,140 +4403,140 @@ var PluginSheetSize = z78.enum([
   "ISO_A1",
   "ISO_A0"
 ]);
-var PluginSheetOrientation = z78.enum(["landscape", "portrait"]);
-var PluginSheetMargin = z78.union([
-  z78.literal(0),
-  z78.literal(0.25),
-  z78.literal(0.5),
-  z78.literal(0.75),
-  z78.literal(1)
+var PluginSheetOrientation = z79.enum(["landscape", "portrait"]);
+var PluginSheetMargin = z79.union([
+  z79.literal(0),
+  z79.literal(0.25),
+  z79.literal(0.5),
+  z79.literal(0.75),
+  z79.literal(1)
 ]);
-var PluginPresentationSheet = z78.object({
-  id: z78.string(),
-  name: z78.string(),
+var PluginPresentationSheet = z79.object({
+  id: z79.string(),
+  name: z79.string(),
   size: PluginSheetSize.nullable(),
   orientation: PluginSheetOrientation.nullable(),
   margin: PluginSheetMargin.nullable()
 });
-var PluginSheetPosition = z78.object({
-  x: z78.number(),
-  y: z78.number()
+var PluginSheetPosition = z79.object({
+  x: z79.number(),
+  y: z79.number()
 });
-var PluginPresentationSheetsListResult = z78.object({
-  sheets: z78.array(PluginPresentationSheet)
+var PluginPresentationSheetsListResult = z79.object({
+  sheets: z79.array(PluginPresentationSheet)
 });
-var PluginPresentationSheetsGetArgs = z78.object({
-  id: z78.string()
+var PluginPresentationSheetsGetArgs = z79.object({
+  id: z79.string()
 });
 var PluginPresentationSheetsGetResult = PluginPresentationSheet.nullable();
-var PluginPresentationSheetsCreateArgs = z78.object({
-  name: z78.string().optional(),
+var PluginPresentationSheetsCreateArgs = z79.object({
+  name: z79.string().optional(),
   size: PluginSheetSize.optional(),
   orientation: PluginSheetOrientation.optional()
 });
-var PluginPresentationSheetsSetSizeArgs = z78.object({
-  sheetId: z78.string(),
+var PluginPresentationSheetsSetSizeArgs = z79.object({
+  sheetId: z79.string(),
   size: PluginSheetSize,
   orientation: PluginSheetOrientation.optional()
 });
-var PluginPresentationSheetsSetMarginArgs = z78.object({
-  sheetId: z78.string(),
+var PluginPresentationSheetsSetMarginArgs = z79.object({
+  sheetId: z79.string(),
   margin: PluginSheetMargin
 });
-var PluginPresentationSheetsPlaceArgs = z78.object({
-  sheetId: z78.string(),
-  viewId: z78.string(),
+var PluginPresentationSheetsPlaceArgs = z79.object({
+  sheetId: z79.string(),
+  viewId: z79.string(),
   position: PluginSheetPosition.optional(),
-  scale: z78.number().positive().optional()
+  scale: z79.number().positive().optional()
 });
-var PluginPresentationSheetsPlaceResult = z78.object({
-  shapeId: z78.string()
+var PluginPresentationSheetsPlaceResult = z79.object({
+  shapeId: z79.string()
 });
-var PluginPresentationSheetsRenameArgs = z78.object({
-  sheetId: z78.string(),
-  name: z78.string().trim().min(1)
+var PluginPresentationSheetsRenameArgs = z79.object({
+  sheetId: z79.string(),
+  name: z79.string().trim().min(1)
 });
-var PluginPresentationSheetsDeleteArgs = z78.object({
-  sheetId: z78.string()
+var PluginPresentationSheetsDeleteArgs = z79.object({
+  sheetId: z79.string()
 });
-var PluginPresentationSheetsDeleteResult = z78.object({
-  id: z78.string()
+var PluginPresentationSheetsDeleteResult = z79.object({
+  id: z79.string()
 });
-var PluginPresentationSheetsReorderArgs = z78.object({
-  sheetId: z78.string(),
-  index: z78.number().int().min(0)
+var PluginPresentationSheetsReorderArgs = z79.object({
+  sheetId: z79.string(),
+  index: z79.number().int().min(0)
 });
-var PluginPresentationSheetsSetActiveArgs = z78.object({
-  sheetId: z78.string()
+var PluginPresentationSheetsSetActiveArgs = z79.object({
+  sheetId: z79.string()
 });
-var PluginPresentationSheetsUpdatePlacedViewArgs = z78.object({
-  sheetId: z78.string().optional()
+var PluginPresentationSheetsUpdatePlacedViewArgs = z79.object({
+  sheetId: z79.string().optional()
 });
-var PluginPresentationSheetsUpdatePlacedViewResult = z78.object({
-  shapeIds: z78.array(z78.string())
+var PluginPresentationSheetsUpdatePlacedViewResult = z79.object({
+  shapeIds: z79.array(z79.string())
 });
 
 // src/api/presentation/placedViews.ts
-import * as z79 from "zod";
+import * as z80 from "zod";
 var PluginPresentationPlacedViewsApi = class {
   constructor() {
   }
 };
-var PluginPlacedViewCropPoint = z79.object({
-  x: z79.number().min(0).max(1),
-  y: z79.number().min(0).max(1)
+var PluginPlacedViewCropPoint = z80.object({
+  x: z80.number().min(0).max(1),
+  y: z80.number().min(0).max(1)
 });
-var PluginPlacedViewCrop = z79.object({
+var PluginPlacedViewCrop = z80.object({
   topLeft: PluginPlacedViewCropPoint,
   bottomRight: PluginPlacedViewCropPoint
 }).refine(
   (c) => c.topLeft.x < c.bottomRight.x && c.topLeft.y < c.bottomRight.y,
   { message: "topLeft must be strictly less than bottomRight on both axes" }
 );
-var PluginPlacedView = z79.object({
-  shapeId: z79.string(),
-  sheetId: z79.string().nullable(),
-  title: z79.string(),
-  viewId: z79.string(),
+var PluginPlacedView = z80.object({
+  shapeId: z80.string(),
+  sheetId: z80.string().nullable(),
+  title: z80.string(),
+  viewId: z80.string(),
   position: PluginSheetPosition,
-  size: z79.object({ width: z79.number(), height: z79.number() }),
-  scale: z79.number().nullable(),
-  is3d: z79.boolean(),
-  rotation: z79.number(),
+  size: z80.object({ width: z80.number(), height: z80.number() }),
+  scale: z80.number().nullable(),
+  is3d: z80.boolean(),
+  rotation: z80.number(),
   crop: PluginPlacedViewCrop.nullable(),
-  isUnlinked: z79.boolean()
+  isUnlinked: z80.boolean()
 });
-var PluginPresentationPlacedViewsListArgs = z79.object({
-  sheetId: z79.string().optional()
+var PluginPresentationPlacedViewsListArgs = z80.object({
+  sheetId: z80.string().optional()
 });
-var PluginPresentationPlacedViewsListResult = z79.object({
-  placedViews: z79.array(PluginPlacedView)
+var PluginPresentationPlacedViewsListResult = z80.object({
+  placedViews: z80.array(PluginPlacedView)
 });
-var PluginPresentationPlacedViewsGetArgs = z79.object({
-  shapeId: z79.string()
+var PluginPresentationPlacedViewsGetArgs = z80.object({
+  shapeId: z80.string()
 });
-var PluginPresentationPlacedViewsMoveArgs = z79.object({
-  shapeId: z79.string(),
+var PluginPresentationPlacedViewsMoveArgs = z80.object({
+  shapeId: z80.string(),
   position: PluginSheetPosition,
-  sheetId: z79.string().optional()
+  sheetId: z80.string().optional()
 });
-var PluginPresentationPlacedViewsScaleArgs = z79.object({
-  shapeId: z79.string(),
-  factor: z79.number().finite().min(0.01).max(100)
+var PluginPresentationPlacedViewsScaleArgs = z80.object({
+  shapeId: z80.string(),
+  factor: z80.number().finite().min(0.01).max(100)
 });
-var PluginPresentationPlacedViewsSetScaleArgs = z79.object({
-  shapeId: z79.string(),
-  scale: z79.number().positive()
+var PluginPresentationPlacedViewsSetScaleArgs = z80.object({
+  shapeId: z80.string(),
+  scale: z80.number().positive()
 });
-var PluginPresentationPlacedViewsSetCropArgs = z79.object({
-  shapeId: z79.string(),
+var PluginPresentationPlacedViewsSetCropArgs = z80.object({
+  shapeId: z80.string(),
   crop: PluginPlacedViewCrop.nullable()
 });
-var PluginPresentationPlacedViewsSetRotationArgs = z79.object({
-  shapeId: z79.string().min(1),
-  rotation: z79.number().finite()
+var PluginPresentationPlacedViewsSetRotationArgs = z80.object({
+  shapeId: z80.string().min(1),
+  rotation: z80.number().finite()
 });
-var PluginViewSettingCategory = z79.enum([
+var PluginViewSettingCategory = z80.enum([
   "Site",
   "Topography",
   "Space",
@@ -4494,7 +4548,7 @@ var PluginViewSettingCategory = z79.enum([
   "Adjacency Line",
   "Landscape elements"
 ]);
-var PluginViewLineStyle = z79.enum([
+var PluginViewLineStyle = z80.enum([
   "solid",
   "dashed",
   "dashdot",
@@ -4503,62 +4557,62 @@ var PluginViewLineStyle = z79.enum([
   "phantom",
   "propertyLine"
 ]);
-var PluginPlacedViewStylePatch = z79.object({
-  hide: z79.boolean().optional(),
+var PluginPlacedViewStylePatch = z80.object({
+  hide: z80.boolean().optional(),
   lineStyle: PluginViewLineStyle.optional(),
-  lineColor: z79.string().regex(/^#?[0-9a-fA-F]{6}$/, "lineColor must be a 6-digit hex color").optional(),
-  dashLength: z79.number().finite().positive().optional(),
-  lineWidth: z79.number().finite().min(0).optional(),
-  cutWidth: z79.number().finite().min(0).optional(),
-  projectionWidth: z79.number().finite().min(0).optional(),
-  treeLineWidth: z79.number().finite().min(0).optional(),
-  parkingLineWidth: z79.number().finite().min(0).optional(),
-  colorMode: z79.string().refine(
+  lineColor: z80.string().regex(/^#?[0-9a-fA-F]{6}$/, "lineColor must be a 6-digit hex color").optional(),
+  dashLength: z80.number().finite().positive().optional(),
+  lineWidth: z80.number().finite().min(0).optional(),
+  cutWidth: z80.number().finite().min(0).optional(),
+  projectionWidth: z80.number().finite().min(0).optional(),
+  treeLineWidth: z80.number().finite().min(0).optional(),
+  parkingLineWidth: z80.number().finite().min(0).optional(),
+  colorMode: z80.string().refine(
     (v) => ["department", "texture", "monochrome"].includes(v) || v.startsWith("tag:"),
     { message: "colorMode must be department, texture, monochrome, or tag:<tagCategoryId>" }
   ).optional(),
-  opacity: z79.number().finite().min(0).max(100).optional(),
-  mapOpacity: z79.number().finite().min(0).max(100).optional(),
-  buildingOpacity: z79.number().finite().min(0).max(100).optional(),
-  mapHide: z79.boolean().optional(),
-  buildingHide: z79.boolean().optional(),
-  noBuilding: z79.boolean().optional(),
-  viewStyle: z79.enum(["NONE", "FILLET", "BUBBLE"]).optional(),
-  radius: z79.number().finite().min(0).optional(),
-  inset: z79.number().finite().min(0).optional()
+  opacity: z80.number().finite().min(0).max(100).optional(),
+  mapOpacity: z80.number().finite().min(0).max(100).optional(),
+  buildingOpacity: z80.number().finite().min(0).max(100).optional(),
+  mapHide: z80.boolean().optional(),
+  buildingHide: z80.boolean().optional(),
+  noBuilding: z80.boolean().optional(),
+  viewStyle: z80.enum(["NONE", "FILLET", "BUBBLE"]).optional(),
+  radius: z80.number().finite().min(0).optional(),
+  inset: z80.number().finite().min(0).optional()
 }).strict().refine((p) => Object.keys(p).length > 0, { message: "patch must set at least one setting" });
-var PluginViewLabelType = z79.enum(["objectLabels", "department", "areas"]);
-var PluginViewFontVariantPatch = z79.object({
-  fontFamily: z79.string().min(1).optional(),
-  fontWeight: z79.string().regex(/^\d{3}$/, 'fontWeight must be a numeric string like "400" or "700"').optional(),
-  fontStyle: z79.enum(["normal", "italic"]).optional(),
-  fontSize: z79.number().finite().positive().max(200).optional()
+var PluginViewLabelType = z80.enum(["objectLabels", "department", "areas"]);
+var PluginViewFontVariantPatch = z80.object({
+  fontFamily: z80.string().min(1).optional(),
+  fontWeight: z80.string().regex(/^\d{3}$/, 'fontWeight must be a numeric string like "400" or "700"').optional(),
+  fontStyle: z80.enum(["normal", "italic"]).optional(),
+  fontSize: z80.number().finite().positive().max(200).optional()
 }).strict();
-var PluginPlacedViewFontStylesPatch = z79.object({
-  visibleTypes: z79.array(PluginViewLabelType).optional(),
+var PluginPlacedViewFontStylesPatch = z80.object({
+  visibleTypes: z80.array(PluginViewLabelType).optional(),
   objectLabels: PluginViewFontVariantPatch.optional(),
   department: PluginViewFontVariantPatch.optional(),
   areas: PluginViewFontVariantPatch.optional()
 }).strict().refine((p) => Object.keys(p).length > 0, { message: "patch must set at least one field" });
-var PluginPlacedViewsUpdateStylesArgs = z79.object({
-  shapeId: z79.string().min(1),
+var PluginPlacedViewsUpdateStylesArgs = z80.object({
+  shapeId: z80.string().min(1),
   category: PluginViewSettingCategory,
   patch: PluginPlacedViewStylePatch
 });
-var PluginPlacedViewsUpdateFontStylesArgs = z79.object({
-  shapeId: z79.string().min(1),
+var PluginPlacedViewsUpdateFontStylesArgs = z80.object({
+  shapeId: z80.string().min(1),
   category: PluginViewSettingCategory,
   patch: PluginPlacedViewFontStylesPatch
 });
-var PluginPlacedViewsMoveLabelArgs = z79.object({
-  labelId: z79.string().min(1),
+var PluginPlacedViewsMoveLabelArgs = z80.object({
+  labelId: z80.string().min(1),
   position: PluginSheetPosition
 });
-var PluginPlacedViewsSetLabelHiddenArgs = z79.object({
-  labelId: z79.string().min(1),
-  hidden: z79.boolean()
+var PluginPlacedViewsSetLabelHiddenArgs = z80.object({
+  labelId: z80.string().min(1),
+  hidden: z80.boolean()
 });
-var PluginCanvasShapeOrigin = z79.enum([
+var PluginCanvasShapeOrigin = z80.enum([
   "view",
   "aiOutput",
   "diagram",
@@ -4567,65 +4621,65 @@ var PluginCanvasShapeOrigin = z79.enum([
   "image",
   "other"
 ]);
-var PluginPlacedViewsMoveShapeArgs = z79.object({
-  shapeId: z79.string().min(1),
+var PluginPlacedViewsMoveShapeArgs = z80.object({
+  shapeId: z80.string().min(1),
   position: PluginSheetPosition,
-  sheetId: z79.string().optional()
+  sheetId: z80.string().optional()
 });
-var PluginPlacedViewsResizeShapeArgs = z79.object({
-  shapeId: z79.string().min(1),
-  factor: z79.number().finite().min(0.01).max(100)
+var PluginPlacedViewsResizeShapeArgs = z80.object({
+  shapeId: z80.string().min(1),
+  factor: z80.number().finite().min(0.01).max(100)
 });
-var PluginPresentationPlacedViewsRotateShapeArgs = z79.object({
-  shapeId: z79.string().min(1),
-  rotation: z79.number().finite()
+var PluginPresentationPlacedViewsRotateShapeArgs = z80.object({
+  shapeId: z80.string().min(1),
+  rotation: z80.number().finite()
 });
-var PluginPlacedViewsDeleteShapesArgs = z79.object({
-  shapeIds: z79.array(z79.string().min(1)).min(1).max(500)
+var PluginPlacedViewsDeleteShapesArgs = z80.object({
+  shapeIds: z80.array(z80.string().min(1)).min(1).max(500)
 });
-var PluginPlacedViewsSetOpacityArgs = z79.object({
-  shapeId: z79.string().min(1),
-  opacity: z79.number().finite().min(0).max(1)
+var PluginPlacedViewsSetOpacityArgs = z80.object({
+  shapeId: z80.string().min(1),
+  opacity: z80.number().finite().min(0).max(1)
 });
-var PluginPlacedViewsSetMaskArgs = z79.object({
-  shapeId: z79.string().min(1),
-  enabled: z79.boolean()
+var PluginPlacedViewsSetMaskArgs = z80.object({
+  shapeId: z80.string().min(1),
+  enabled: z80.boolean()
 });
 
 // src/api/presentation/diagrams.ts
-import * as z80 from "zod";
+import * as z81 from "zod";
 var PluginPresentationDiagramsApi = class {
   constructor() {
   }
 };
-var PluginPresentationDiagramsPlaceArgs = z80.object({
-  sheetId: z80.string(),
-  urls: z80.array(z80.string()),
-  position: z80.object({ x: z80.number(), y: z80.number() }).optional()
+var PluginPresentationDiagramsPlaceArgs = z81.object({
+  sheetId: z81.string(),
+  urls: z81.array(z81.string()),
+  position: z81.object({ x: z81.number(), y: z81.number() }).optional()
 });
-var PluginPresentationDiagramsPlaceResult = z80.object({
-  shapeIds: z80.array(z80.string())
+var PluginPresentationDiagramsPlaceResult = z81.object({
+  shapeIds: z81.array(z81.string())
 });
-var PluginPresentationSiteDiagramType = z80.enum([
+var PluginPresentationSiteDiagramType = z81.enum([
   "location",
   "streetview",
   "climate"
 ]);
-var PluginPresentationDiagramsGenerateSiteArgs = z80.object({
-  types: z80.array(PluginPresentationSiteDiagramType).min(1).optional()
+var PluginPresentationDiagramsGenerateSiteArgs = z81.object({
+  types: z81.array(PluginPresentationSiteDiagramType).min(1).optional()
 });
-var PluginPresentationDiagramsGenerateResult = z80.object({
-  sheetIds: z80.array(z80.string())
+var PluginPresentationDiagramsGenerateResult = z81.object({
+  sheetIds: z81.array(z81.string())
 });
 
 // src/api/presentation/annotate.ts
-import * as z81 from "zod";
+import * as z82 from "zod";
 var PluginPresentationAnnotateApi = class {
   constructor() {
   }
 };
-var PluginAnnotateTextSize = z81.enum(["s", "m", "l", "xl"]);
-var PluginAnnotateTextColor = z81.enum([
+var PluginAnnotateTextSize = z82.enum(["s", "m", "l", "xl"]);
+var PluginAnnotateTextColor = z82.enum([
   "black",
   "grey",
   "light-violet",
@@ -4640,23 +4694,23 @@ var PluginAnnotateTextColor = z81.enum([
   "red",
   "white"
 ]);
-var PluginPresentationAnnotateTextArgs = z81.object({
-  sheetId: z81.string(),
-  text: z81.string(),
-  position: z81.object({ x: z81.number(), y: z81.number() }).optional(),
+var PluginPresentationAnnotateTextArgs = z82.object({
+  sheetId: z82.string(),
+  text: z82.string(),
+  position: z82.object({ x: z82.number(), y: z82.number() }).optional(),
   size: PluginAnnotateTextSize.optional(),
   color: PluginAnnotateTextColor.optional(),
-  fontFamily: z81.string().min(1).optional(),
-  fontWeight: z81.string().regex(
+  fontFamily: z82.string().min(1).optional(),
+  fontWeight: z82.string().regex(
     /^\d{3}(-italic)?$/,
     'fontWeight must be a numeric string like "400" or "700", optionally with the "-italic" suffix'
   ).optional(),
-  fontSizePx: z81.number().finite().positive().optional()
+  fontSizePx: z82.number().finite().positive().optional()
 });
-var PluginPresentationAnnotateTextResult = z81.object({
-  shapeId: z81.string()
+var PluginPresentationAnnotateTextResult = z82.object({
+  shapeId: z82.string()
 });
-var PluginAnnotateGeoKind = z81.enum([
+var PluginAnnotateGeoKind = z82.enum([
   "rectangle",
   "ellipse",
   "triangle",
@@ -4674,358 +4728,358 @@ var PluginAnnotateGeoKind = z81.enum([
   "arrow-right",
   "arrow-down"
 ]);
-var PluginAnnotateFill = z81.enum(["none", "semi", "solid", "pattern"]);
-var PluginPresentationAnnotateArrowArgs = z81.object({
-  sheetId: z81.string(),
-  start: z81.object({ x: z81.number(), y: z81.number() }),
-  end: z81.object({ x: z81.number(), y: z81.number() }),
+var PluginAnnotateFill = z82.enum(["none", "semi", "solid", "pattern"]);
+var PluginPresentationAnnotateArrowArgs = z82.object({
+  sheetId: z82.string(),
+  start: z82.object({ x: z82.number(), y: z82.number() }),
+  end: z82.object({ x: z82.number(), y: z82.number() }),
   color: PluginAnnotateTextColor.optional(),
   size: PluginAnnotateTextSize.optional()
 });
-var PluginPresentationAnnotateNoteArgs = z81.object({
-  sheetId: z81.string(),
-  text: z81.string(),
-  position: z81.object({ x: z81.number(), y: z81.number() }).optional(),
+var PluginPresentationAnnotateNoteArgs = z82.object({
+  sheetId: z82.string(),
+  text: z82.string(),
+  position: z82.object({ x: z82.number(), y: z82.number() }).optional(),
   color: PluginAnnotateTextColor.optional(),
   size: PluginAnnotateTextSize.optional()
 });
-var PluginPresentationAnnotateShapeArgs = z81.object({
-  sheetId: z81.string(),
+var PluginPresentationAnnotateShapeArgs = z82.object({
+  sheetId: z82.string(),
   kind: PluginAnnotateGeoKind,
-  bounds: z81.object({
-    x: z81.number(),
-    y: z81.number(),
-    w: z81.number().positive(),
-    h: z81.number().positive()
+  bounds: z82.object({
+    x: z82.number(),
+    y: z82.number(),
+    w: z82.number().positive(),
+    h: z82.number().positive()
   }),
   color: PluginAnnotateTextColor.optional(),
   fill: PluginAnnotateFill.optional()
 });
-var PluginPresentationAnnotateResult = z81.object({
-  shapeId: z81.string()
+var PluginPresentationAnnotateResult = z82.object({
+  shapeId: z82.string()
 });
 
 // src/api/presentation/shapes.ts
-import * as z82 from "zod";
+import * as z83 from "zod";
 var PluginPresentationShapesApi = class {
   constructor() {
   }
 };
-var PluginPresentationShapeSpec = z82.discriminatedUnion("type", [
-  z82.object({
-    type: z82.literal("text"),
-    text: z82.string(),
-    position: z82.object({ x: z82.number(), y: z82.number() }).optional(),
+var PluginPresentationShapeSpec = z83.discriminatedUnion("type", [
+  z83.object({
+    type: z83.literal("text"),
+    text: z83.string(),
+    position: z83.object({ x: z83.number(), y: z83.number() }).optional(),
     size: PluginAnnotateTextSize.optional(),
     color: PluginAnnotateTextColor.optional()
   }),
-  z82.object({
-    type: z82.literal("note"),
-    text: z82.string(),
-    position: z82.object({ x: z82.number(), y: z82.number() }).optional(),
+  z83.object({
+    type: z83.literal("note"),
+    text: z83.string(),
+    position: z83.object({ x: z83.number(), y: z83.number() }).optional(),
     color: PluginAnnotateTextColor.optional(),
     size: PluginAnnotateTextSize.optional()
   }),
-  z82.object({
-    type: z82.literal("arrow"),
-    start: z82.object({ x: z82.number(), y: z82.number() }),
-    end: z82.object({ x: z82.number(), y: z82.number() }),
+  z83.object({
+    type: z83.literal("arrow"),
+    start: z83.object({ x: z83.number(), y: z83.number() }),
+    end: z83.object({ x: z83.number(), y: z83.number() }),
     color: PluginAnnotateTextColor.optional(),
     size: PluginAnnotateTextSize.optional()
   }),
-  z82.object({
-    type: z82.literal("geo"),
+  z83.object({
+    type: z83.literal("geo"),
     kind: PluginAnnotateGeoKind,
-    bounds: z82.object({
-      x: z82.number(),
-      y: z82.number(),
-      w: z82.number().positive(),
-      h: z82.number().positive()
+    bounds: z83.object({
+      x: z83.number(),
+      y: z83.number(),
+      w: z83.number().positive(),
+      h: z83.number().positive()
     }),
     color: PluginAnnotateTextColor.optional(),
     fill: PluginAnnotateFill.optional()
   })
 ]);
-var PluginPresentationShapeType = z82.enum([
+var PluginPresentationShapeType = z83.enum([
   "text",
   "note",
   "arrow",
   "geo"
 ]);
-var PluginPresentationShapesUpsertArgs = z82.object({
-  key: z82.string().min(1),
+var PluginPresentationShapesUpsertArgs = z83.object({
+  key: z83.string().min(1),
   shape: PluginPresentationShapeSpec,
-  sheetId: z82.string().optional()
+  sheetId: z83.string().optional()
 });
-var PluginPresentationShapesUpsertResult = z82.object({
-  shapeId: z82.string(),
-  created: z82.boolean()
+var PluginPresentationShapesUpsertResult = z83.object({
+  shapeId: z83.string(),
+  created: z83.boolean()
 });
-var PluginPresentationShapesRemoveArgs = z82.object({
-  key: z82.string().min(1)
+var PluginPresentationShapesRemoveArgs = z83.object({
+  key: z83.string().min(1)
 });
-var PluginPresentationShapesListResult = z82.object({
-  shapes: z82.array(
-    z82.object({
-      key: z82.string(),
-      shapeId: z82.string(),
+var PluginPresentationShapesListResult = z83.object({
+  shapes: z83.array(
+    z83.object({
+      key: z83.string(),
+      shapeId: z83.string(),
       type: PluginPresentationShapeType
     })
   )
 });
 
 // src/api/presentation/tables.ts
-import * as z83 from "zod";
+import * as z84 from "zod";
 var PluginPresentationTablesApi = class {
   constructor() {
   }
 };
-var PluginPresentationTablesPlaceArgs = z83.object({
-  sheetId: z83.string().min(1),
-  rows: z83.array(z83.array(z83.string()).min(1)).min(1).refine((rows) => rows.reduce((n, r) => n + r.length, 0) <= 1e4, {
+var PluginPresentationTablesPlaceArgs = z84.object({
+  sheetId: z84.string().min(1),
+  rows: z84.array(z84.array(z84.string()).min(1)).min(1).refine((rows) => rows.reduce((n, r) => n + r.length, 0) <= 1e4, {
     message: "table exceeds the 10000-cell cap"
   }),
-  position: z83.object({ x: z83.number(), y: z83.number() }).optional()
+  position: z84.object({ x: z84.number(), y: z84.number() }).optional()
 });
 
 // src/api/presentation/slideshow.ts
-import * as z84 from "zod";
+import * as z85 from "zod";
 var PluginPresentationSlideshowApi = class {
   constructor() {
   }
 };
-var PluginPresentationSlideshowStartArgs = z84.object({
-  sheetIds: z84.array(z84.string().min(1)).optional(),
-  startIndex: z84.number().int().min(0).optional()
+var PluginPresentationSlideshowStartArgs = z85.object({
+  sheetIds: z85.array(z85.string().min(1)).optional(),
+  startIndex: z85.number().int().min(0).optional()
 });
-var PluginPresentationSlideshowState = z84.object({
-  running: z84.boolean(),
-  index: z84.number().int().nullable()
+var PluginPresentationSlideshowState = z85.object({
+  running: z85.boolean(),
+  index: z85.number().int().nullable()
 });
 
 // src/api/presentation/import.ts
-import * as z85 from "zod";
+import * as z86 from "zod";
 var PluginPresentationImportApi = class {
   constructor() {
   }
 };
-var PluginPresentationImportArgs = z85.object({
-  url: z85.string().optional(),
-  dataUrl: z85.string().optional(),
-  position: z85.object({ x: z85.number(), y: z85.number() }).optional()
+var PluginPresentationImportArgs = z86.object({
+  url: z86.string().optional(),
+  dataUrl: z86.string().optional(),
+  position: z86.object({ x: z86.number(), y: z86.number() }).optional()
 }).refine((a) => Boolean(a.url) || Boolean(a.dataUrl), {
   message: "Provide a url or a dataUrl"
 });
-var PluginPresentationImportResult = z85.object({
-  shapeIds: z85.array(z85.string())
+var PluginPresentationImportResult = z86.object({
+  shapeIds: z86.array(z86.string())
 });
 
 // src/api/presentation/aiInspiration.ts
-import * as z86 from "zod";
-var JsonPrimitive = z86.union([z86.string(), z86.number(), z86.boolean(), z86.null()]);
-var JsonValue = z86.lazy(
-  () => z86.union([JsonPrimitive, z86.array(JsonValue), z86.record(z86.string(), JsonValue)])
+import * as z87 from "zod";
+var JsonPrimitive = z87.union([z87.string(), z87.number(), z87.boolean(), z87.null()]);
+var JsonValue = z87.lazy(
+  () => z87.union([JsonPrimitive, z87.array(JsonValue), z87.record(z87.string(), JsonValue)])
 );
-var PluginAIInspirationRunMode = z86.enum(["blocking", "job"]);
-var PluginAIInspirationOutputKind = z86.enum([
+var PluginAIInspirationRunMode = z87.enum(["blocking", "job"]);
+var PluginAIInspirationOutputKind = z87.enum([
   "source",
   "image",
   "video"
 ]);
-var PluginAIInspirationModelOutput = z86.enum(["image", "video"]);
-var PluginAIInspirationRuntimeProvider = z86.enum(["gpt", "fal"]);
-var PluginAIInspirationPromptStrategy = z86.enum([
+var PluginAIInspirationModelOutput = z87.enum(["image", "video"]);
+var PluginAIInspirationRuntimeProvider = z87.enum(["gpt", "fal"]);
+var PluginAIInspirationPromptStrategy = z87.enum([
   "gpt-image",
   "fal-image",
   "fal-video"
 ]);
-var PluginAIInspirationShapeKind = z86.enum(["image", "view", "video"]);
-var PluginAIInspirationVideoMode = z86.enum([
+var PluginAIInspirationShapeKind = z87.enum(["image", "view", "video"]);
+var PluginAIInspirationVideoMode = z87.enum([
   "animate",
   "references",
   "keyframes"
 ]);
-var PluginAIInspirationVideoMotion = z86.enum([
+var PluginAIInspirationVideoMotion = z87.enum([
   "auto",
   "slow-dolly",
   "subtle-orbit",
   "reveal"
 ]);
-var PluginAIInspirationVideoDuration = z86.enum(["4s", "6s", "8s"]);
-var PluginAIInspirationJobStatus = z86.enum([
+var PluginAIInspirationVideoDuration = z87.enum(["4s", "6s", "8s"]);
+var PluginAIInspirationJobStatus = z87.enum([
   "queued",
   "running",
   "completed",
   "failed",
   "cancelled"
 ]);
-var PluginAIInspirationWorkflowRunState = z86.enum([
+var PluginAIInspirationWorkflowRunState = z87.enum([
   "current",
   "stale",
   "running",
   "failed",
   "superseded"
 ]);
-var PluginAIInspirationRegionHint = z86.object({
-  x: z86.number().finite(),
-  y: z86.number().finite(),
-  w: z86.number().finite().positive(),
-  h: z86.number().finite().positive()
-});
-var PluginAIInspirationPoint = z86.object({
-  x: z86.number().finite(),
-  y: z86.number().finite()
-});
-var PluginAIInspirationTextAnnotation = z86.object({
-  text: z86.string().min(1),
-  x: z86.number().finite().optional(),
-  y: z86.number().finite().optional()
-});
-var PluginAIInspirationSketchGuidance = z86.object({
-  visualShapeIds: z86.array(z86.string()).optional(),
-  textAnnotations: z86.array(PluginAIInspirationTextAnnotation).optional()
-});
-var PluginAIInspirationSiteOptions = z86.object({
-  includeSatellite: z86.boolean().optional(),
-  includeStreetView: z86.boolean().optional(),
-  includeAerial: z86.boolean().optional(),
-  aerialBearing: z86.number().finite().optional(),
-  aerialPitch: z86.number().finite().optional(),
-  selectedDiagramIds: z86.array(z86.string()).optional(),
-  location: z86.object({
-    lat: z86.number().finite(),
-    lng: z86.number().finite()
+var PluginAIInspirationRegionHint = z87.object({
+  x: z87.number().finite(),
+  y: z87.number().finite(),
+  w: z87.number().finite().positive(),
+  h: z87.number().finite().positive()
+});
+var PluginAIInspirationPoint = z87.object({
+  x: z87.number().finite(),
+  y: z87.number().finite()
+});
+var PluginAIInspirationTextAnnotation = z87.object({
+  text: z87.string().min(1),
+  x: z87.number().finite().optional(),
+  y: z87.number().finite().optional()
+});
+var PluginAIInspirationSketchGuidance = z87.object({
+  visualShapeIds: z87.array(z87.string()).optional(),
+  textAnnotations: z87.array(PluginAIInspirationTextAnnotation).optional()
+});
+var PluginAIInspirationSiteOptions = z87.object({
+  includeSatellite: z87.boolean().optional(),
+  includeStreetView: z87.boolean().optional(),
+  includeAerial: z87.boolean().optional(),
+  aerialBearing: z87.number().finite().optional(),
+  aerialPitch: z87.number().finite().optional(),
+  selectedDiagramIds: z87.array(z87.string()).optional(),
+  location: z87.object({
+    lat: z87.number().finite(),
+    lng: z87.number().finite()
   }).optional()
 });
-var PluginAIInspirationAppliedPreset = z86.object({
-  source: z86.enum(["curated", "user"]),
-  presetId: z86.string().min(1),
-  name: z86.string().min(1),
-  savedPresetKind: z86.enum(["prompt", "style"]).optional(),
-  stylePrompt: z86.string().optional(),
-  modelId: z86.string().optional(),
-  referenceImages: z86.array(
-    z86.object({
-      url: z86.string().min(1),
-      label: z86.string().optional(),
-      weight: z86.number().finite().optional()
+var PluginAIInspirationAppliedPreset = z87.object({
+  source: z87.enum(["curated", "user"]),
+  presetId: z87.string().min(1),
+  name: z87.string().min(1),
+  savedPresetKind: z87.enum(["prompt", "style"]).optional(),
+  stylePrompt: z87.string().optional(),
+  modelId: z87.string().optional(),
+  referenceImages: z87.array(
+    z87.object({
+      url: z87.string().min(1),
+      label: z87.string().optional(),
+      weight: z87.number().finite().optional()
     })
   ).optional(),
-  siteDefaults: z86.object({
-    includeSatellite: z86.boolean().optional(),
-    includeStreetView: z86.boolean().optional(),
-    includeAerial: z86.boolean().optional()
+  siteDefaults: z87.object({
+    includeSatellite: z87.boolean().optional(),
+    includeStreetView: z87.boolean().optional(),
+    includeAerial: z87.boolean().optional()
   }).optional()
 });
-var PluginAIInspirationVideoOptions = z86.object({
+var PluginAIInspirationVideoOptions = z87.object({
   mode: PluginAIInspirationVideoMode.optional(),
-  endFrameShapeId: z86.string().optional(),
+  endFrameShapeId: z87.string().optional(),
   motion: PluginAIInspirationVideoMotion.optional(),
   duration: PluginAIInspirationVideoDuration.optional()
 });
-var PluginAIInspirationModel = z86.object({
-  id: z86.string(),
-  label: z86.string(),
-  supportsMultiImage: z86.boolean(),
+var PluginAIInspirationModel = z87.object({
+  id: z87.string(),
+  label: z87.string(),
+  supportsMultiImage: z87.boolean(),
   output: PluginAIInspirationModelOutput,
-  isDefault: z86.boolean().optional()
+  isDefault: z87.boolean().optional()
 });
-var PluginAIInspirationModelCapability = z86.object({
-  id: z86.string(),
+var PluginAIInspirationModelCapability = z87.object({
+  id: z87.string(),
   output: PluginAIInspirationModelOutput,
   provider: PluginAIInspirationRuntimeProvider,
-  supportsRegionEdit: z86.boolean(),
-  supportsReferenceImages: z86.boolean(),
-  supportsStylePresets: z86.boolean(),
-  supportsSiteContext: z86.boolean(),
-  supportsSketchGuidance: z86.boolean(),
-  supportsKeyframes: z86.boolean(),
-  maxExtraImages: z86.number().int().nonnegative(),
+  supportsRegionEdit: z87.boolean(),
+  supportsReferenceImages: z87.boolean(),
+  supportsStylePresets: z87.boolean(),
+  supportsSiteContext: z87.boolean(),
+  supportsSketchGuidance: z87.boolean(),
+  supportsKeyframes: z87.boolean(),
+  maxExtraImages: z87.number().int().nonnegative(),
   promptStrategy: PluginAIInspirationPromptStrategy
 });
-var PluginAIInspirationListModelsResult = z86.object({
-  defaultModelId: z86.string(),
-  models: z86.array(PluginAIInspirationModel)
+var PluginAIInspirationListModelsResult = z87.object({
+  defaultModelId: z87.string(),
+  models: z87.array(PluginAIInspirationModel)
 });
-var PluginAIInspirationGetModelCapabilitiesArgs = z86.object({
-  modelId: z86.string().min(1)
+var PluginAIInspirationGetModelCapabilitiesArgs = z87.object({
+  modelId: z87.string().min(1)
 });
-var PluginAIInspirationGetModelCapabilitiesResult = z86.object({
+var PluginAIInspirationGetModelCapabilitiesResult = z87.object({
   capability: PluginAIInspirationModelCapability
 });
-var PluginAIInspirationShapeRef = z86.object({
-  shapeId: z86.string(),
-  assetId: z86.string().optional(),
+var PluginAIInspirationShapeRef = z87.object({
+  shapeId: z87.string(),
+  assetId: z87.string().optional(),
   kind: PluginAIInspirationShapeKind,
-  name: z86.string().optional(),
-  width: z86.number().finite().optional(),
-  height: z86.number().finite().optional(),
+  name: z87.string().optional(),
+  width: z87.number().finite().optional(),
+  height: z87.number().finite().optional(),
   outputType: PluginAIInspirationOutputKind.optional(),
-  sourceUrl: z86.string().optional()
-});
-var PluginAIInspirationListSourcesArgs = z86.object({
-  includeGenerated: z86.boolean().optional(),
-  includeSourceUrl: z86.boolean().optional()
-});
-var PluginAIInspirationListSourcesResult = z86.object({
-  sources: z86.array(PluginAIInspirationShapeRef)
-});
-var PluginAIInspirationGetSelectionResult = z86.object({
-  selectedShapeIds: z86.array(z86.string()),
-  sources: z86.array(PluginAIInspirationShapeRef)
-});
-var PluginAIInspirationPresetReferenceImage = z86.object({
-  url: z86.string(),
-  label: z86.string().optional(),
-  weight: z86.number().finite().optional()
-});
-var PluginAIInspirationPreset = z86.object({
-  id: z86.string(),
-  name: z86.string(),
-  source: z86.enum(["curated", "user"]),
-  modelId: z86.string(),
-  categoryId: z86.string().optional(),
-  categoryLabel: z86.string().optional(),
-  description: z86.string().optional(),
-  previewImageUrl: z86.string().optional(),
-  prompt: z86.string().optional(),
-  stylePrompt: z86.string().optional(),
-  tags: z86.array(z86.string()).optional(),
-  referenceImages: z86.array(PluginAIInspirationPresetReferenceImage).optional(),
+  sourceUrl: z87.string().optional()
+});
+var PluginAIInspirationListSourcesArgs = z87.object({
+  includeGenerated: z87.boolean().optional(),
+  includeSourceUrl: z87.boolean().optional()
+});
+var PluginAIInspirationListSourcesResult = z87.object({
+  sources: z87.array(PluginAIInspirationShapeRef)
+});
+var PluginAIInspirationGetSelectionResult = z87.object({
+  selectedShapeIds: z87.array(z87.string()),
+  sources: z87.array(PluginAIInspirationShapeRef)
+});
+var PluginAIInspirationPresetReferenceImage = z87.object({
+  url: z87.string(),
+  label: z87.string().optional(),
+  weight: z87.number().finite().optional()
+});
+var PluginAIInspirationPreset = z87.object({
+  id: z87.string(),
+  name: z87.string(),
+  source: z87.enum(["curated", "user"]),
+  modelId: z87.string(),
+  categoryId: z87.string().optional(),
+  categoryLabel: z87.string().optional(),
+  description: z87.string().optional(),
+  previewImageUrl: z87.string().optional(),
+  prompt: z87.string().optional(),
+  stylePrompt: z87.string().optional(),
+  tags: z87.array(z87.string()).optional(),
+  referenceImages: z87.array(PluginAIInspirationPresetReferenceImage).optional(),
   siteDefaults: PluginAIInspirationAppliedPreset.shape.siteDefaults.optional()
 });
-var PluginAIInspirationPresetCategory = z86.object({
-  id: z86.string(),
-  label: z86.string(),
-  description: z86.string().optional()
+var PluginAIInspirationPresetCategory = z87.object({
+  id: z87.string(),
+  label: z87.string(),
+  description: z87.string().optional()
 });
-var PluginAIInspirationGetPresetCatalogResult = z86.object({
-  categories: z86.array(PluginAIInspirationPresetCategory),
-  presets: z86.array(PluginAIInspirationPreset)
+var PluginAIInspirationGetPresetCatalogResult = z87.object({
+  categories: z87.array(PluginAIInspirationPresetCategory),
+  presets: z87.array(PluginAIInspirationPreset)
 });
-var PluginAIInspirationOutput = z86.object({
-  outputType: z86.enum(["image", "video"]),
-  shapeId: z86.string(),
-  assetId: z86.string(),
-  outputUrl: z86.string().optional(),
+var PluginAIInspirationOutput = z87.object({
+  outputType: z87.enum(["image", "video"]),
+  shapeId: z87.string(),
+  assetId: z87.string(),
+  outputUrl: z87.string().optional(),
   position: PluginAIInspirationPoint.optional()
 });
-var PluginAIInspirationDebugSummary = z86.record(z86.string(), JsonValue);
-var PluginAIInspirationRunMetadata = z86.object({
-  geometryFidelity: z86.string().optional(),
+var PluginAIInspirationDebugSummary = z87.record(z87.string(), JsonValue);
+var PluginAIInspirationRunMetadata = z87.object({
+  geometryFidelity: z87.string().optional(),
   debugSummary: PluginAIInspirationDebugSummary.optional(),
-  streetViewComposite: z86.object({
-    used: z86.boolean(),
-    renderMode: z86.enum(["prompt_refs_default", "masked_composite_pilot"]),
-    backgroundLabel: z86.string().optional()
+  streetViewComposite: z87.object({
+    used: z87.boolean(),
+    renderMode: z87.enum(["prompt_refs_default", "masked_composite_pilot"]),
+    backgroundLabel: z87.string().optional()
   }).optional()
 });
-var PluginAIInspirationGenerateArgs = z86.object({
-  sourceShapeId: z86.string().min(1),
-  prompt: z86.string().min(1).max(8e3),
-  modelId: z86.string().optional(),
-  referenceShapeIds: z86.array(z86.string()).max(12).optional(),
-  referenceStrength: z86.enum(["low", "medium", "high"]).optional(),
+var PluginAIInspirationGenerateArgs = z87.object({
+  sourceShapeId: z87.string().min(1),
+  prompt: z87.string().min(1).max(8e3),
+  modelId: z87.string().optional(),
+  referenceShapeIds: z87.array(z87.string()).max(12).optional(),
+  referenceStrength: z87.enum(["low", "medium", "high"]).optional(),
   appliedPreset: PluginAIInspirationAppliedPreset.optional(),
   site: PluginAIInspirationSiteOptions.optional(),
   regionHint: PluginAIInspirationRegionHint.optional(),
@@ -5033,129 +5087,129 @@ var PluginAIInspirationGenerateArgs = z86.object({
   video: PluginAIInspirationVideoOptions.optional(),
   runMode: PluginAIInspirationRunMode.optional()
 });
-var PluginAIInspirationRunResult = z86.object({
-  jobId: z86.string().optional(),
+var PluginAIInspirationRunResult = z87.object({
+  jobId: z87.string().optional(),
   output: PluginAIInspirationOutput.optional(),
-  outputs: z86.array(PluginAIInspirationOutput).optional(),
+  outputs: z87.array(PluginAIInspirationOutput).optional(),
   metadata: PluginAIInspirationRunMetadata.optional()
 });
-var PluginAIInspirationRefineArgs = z86.object({
-  sourceShapeId: z86.string().min(1),
-  upscaleFactor: z86.union([z86.literal(1.5), z86.literal(2), z86.literal(4)]).optional(),
+var PluginAIInspirationRefineArgs = z87.object({
+  sourceShapeId: z87.string().min(1),
+  upscaleFactor: z87.union([z87.literal(1.5), z87.literal(2), z87.literal(4)]).optional(),
   runMode: PluginAIInspirationRunMode.optional()
 });
-var PluginAIInspirationJobProgress = z86.object({
-  currentStep: z86.number().int().nonnegative().optional(),
-  totalSteps: z86.number().int().nonnegative().optional(),
-  message: z86.string().optional()
+var PluginAIInspirationJobProgress = z87.object({
+  currentStep: z87.number().int().nonnegative().optional(),
+  totalSteps: z87.number().int().nonnegative().optional(),
+  message: z87.string().optional()
 });
-var PluginAIInspirationJob = z86.object({
-  jobId: z86.string(),
+var PluginAIInspirationJob = z87.object({
+  jobId: z87.string(),
   status: PluginAIInspirationJobStatus,
-  createdAt: z86.number(),
-  updatedAt: z86.number(),
-  completedAt: z86.number().optional(),
-  method: z86.string(),
+  createdAt: z87.number(),
+  updatedAt: z87.number(),
+  completedAt: z87.number().optional(),
+  method: z87.string(),
   progress: PluginAIInspirationJobProgress.optional(),
   result: PluginAIInspirationRunResult.optional(),
-  error: z86.string().optional()
+  error: z87.string().optional()
 });
-var PluginAIInspirationJobArgs = z86.object({
-  jobId: z86.string().min(1)
+var PluginAIInspirationJobArgs = z87.object({
+  jobId: z87.string().min(1)
 });
-var PluginAIInspirationGetJobResult = z86.object({
+var PluginAIInspirationGetJobResult = z87.object({
   job: PluginAIInspirationJob
 });
-var PluginAIInspirationCancelJobResult = z86.object({
+var PluginAIInspirationCancelJobResult = z87.object({
   job: PluginAIInspirationJob
 });
-var PluginAIInspirationListJobsResult = z86.object({
-  jobs: z86.array(PluginAIInspirationJob)
+var PluginAIInspirationListJobsResult = z87.object({
+  jobs: z87.array(PluginAIInspirationJob)
 });
-var PluginAIInspirationWorkflowVideoConfig = z86.object({
-  mode: z86.string().optional(),
-  motion: z86.string().optional(),
-  duration: z86.string().optional(),
-  endFrameShapeId: z86.string().optional()
+var PluginAIInspirationWorkflowVideoConfig = z87.object({
+  mode: z87.string().optional(),
+  motion: z87.string().optional(),
+  duration: z87.string().optional(),
+  endFrameShapeId: z87.string().optional()
 });
-var PluginAIInspirationGenerationInputSnapshot = z86.object({
-  version: z86.literal(1),
-  meta: z86.record(z86.string(), JsonValue),
+var PluginAIInspirationGenerationInputSnapshot = z87.object({
+  version: z87.literal(1),
+  meta: z87.record(z87.string(), JsonValue),
   regionHint: PluginAIInspirationRegionHint.optional(),
-  sketchGuidance: z86.record(z86.string(), JsonValue).optional(),
-  sourceCameraHeading: z86.number().finite().optional()
-});
-var PluginAIInspirationWorkflowOperation = z86.object({
-  type: z86.enum(["generate-image", "refine", "generate-video"]),
-  label: z86.string(),
-  prompt: z86.string().optional(),
-  modelId: z86.string().optional(),
-  presetId: z86.string().optional(),
-  presetName: z86.string().optional(),
-  refineFactor: z86.number().finite().optional(),
-  sourceRole: z86.enum(["primary", "end-frame"]).optional(),
+  sketchGuidance: z87.record(z87.string(), JsonValue).optional(),
+  sourceCameraHeading: z87.number().finite().optional()
+});
+var PluginAIInspirationWorkflowOperation = z87.object({
+  type: z87.enum(["generate-image", "refine", "generate-video"]),
+  label: z87.string(),
+  prompt: z87.string().optional(),
+  modelId: z87.string().optional(),
+  presetId: z87.string().optional(),
+  presetName: z87.string().optional(),
+  refineFactor: z87.number().finite().optional(),
+  sourceRole: z87.enum(["primary", "end-frame"]).optional(),
   video: PluginAIInspirationWorkflowVideoConfig.optional(),
   generationInput: PluginAIInspirationGenerationInputSnapshot.optional()
 });
-var PluginAIInspirationWorkflowNode = z86.object({
-  id: z86.string(),
-  shapeId: z86.string(),
-  assetId: z86.string().optional(),
+var PluginAIInspirationWorkflowNode = z87.object({
+  id: z87.string(),
+  shapeId: z87.string(),
+  assetId: z87.string().optional(),
   kind: PluginAIInspirationOutputKind,
-  state: z86.string(),
+  state: z87.string(),
   runState: PluginAIInspirationWorkflowRunState.optional(),
-  staleReason: z86.string().optional(),
-  incomingEdgeIds: z86.array(z86.string()),
-  outgoingEdgeIds: z86.array(z86.string()),
-  createdAt: z86.number(),
-  updatedAt: z86.number()
-});
-var PluginAIInspirationWorkflowEdge = z86.object({
-  id: z86.string(),
-  sourceNodeId: z86.string(),
-  targetNodeId: z86.string(),
-  arrowShapeId: z86.string().optional(),
+  staleReason: z87.string().optional(),
+  incomingEdgeIds: z87.array(z87.string()),
+  outgoingEdgeIds: z87.array(z87.string()),
+  createdAt: z87.number(),
+  updatedAt: z87.number()
+});
+var PluginAIInspirationWorkflowEdge = z87.object({
+  id: z87.string(),
+  sourceNodeId: z87.string(),
+  targetNodeId: z87.string(),
+  arrowShapeId: z87.string().optional(),
   operation: PluginAIInspirationWorkflowOperation,
-  state: z86.string(),
+  state: z87.string(),
   runState: PluginAIInspirationWorkflowRunState.optional(),
-  staleReason: z86.string().optional(),
-  supersededByEdgeId: z86.string().optional(),
-  createdAt: z86.number(),
-  updatedAt: z86.number()
-});
-var PluginAIInspirationWorkflow = z86.object({
-  id: z86.string(),
-  rootNodeIds: z86.array(z86.string()),
-  nodeIds: z86.array(z86.string()),
-  edgeIds: z86.array(z86.string()),
-  nodes: z86.record(z86.string(), PluginAIInspirationWorkflowNode),
-  edges: z86.record(z86.string(), PluginAIInspirationWorkflowEdge),
-  createdAt: z86.number(),
-  updatedAt: z86.number()
-});
-var PluginAIInspirationGetWorkflowForShapeArgs = z86.object({
-  shapeId: z86.string().min(1)
-});
-var PluginAIInspirationGetWorkflowForShapeResult = z86.object({
+  staleReason: z87.string().optional(),
+  supersededByEdgeId: z87.string().optional(),
+  createdAt: z87.number(),
+  updatedAt: z87.number()
+});
+var PluginAIInspirationWorkflow = z87.object({
+  id: z87.string(),
+  rootNodeIds: z87.array(z87.string()),
+  nodeIds: z87.array(z87.string()),
+  edgeIds: z87.array(z87.string()),
+  nodes: z87.record(z87.string(), PluginAIInspirationWorkflowNode),
+  edges: z87.record(z87.string(), PluginAIInspirationWorkflowEdge),
+  createdAt: z87.number(),
+  updatedAt: z87.number()
+});
+var PluginAIInspirationGetWorkflowForShapeArgs = z87.object({
+  shapeId: z87.string().min(1)
+});
+var PluginAIInspirationGetWorkflowForShapeResult = z87.object({
   workflow: PluginAIInspirationWorkflow.nullable(),
   node: PluginAIInspirationWorkflowNode.nullable()
 });
-var PluginAIInspirationRerunPlanResult = z86.discriminatedUnion(
+var PluginAIInspirationRerunPlanResult = z87.discriminatedUnion(
   "status",
   [
-    z86.object({
-      status: z86.literal("ready"),
-      workflowId: z86.string(),
+    z87.object({
+      status: z87.literal("ready"),
+      workflowId: z87.string(),
       sourceNode: PluginAIInspirationWorkflowNode,
-      edgeIds: z86.array(z86.string()),
-      edges: z86.array(PluginAIInspirationWorkflowEdge),
-      recipe: z86.lazy(() => PluginAIInspirationRecipe),
-      needsEndFrame: z86.boolean(),
-      defaultEndFrameShapeId: z86.string().nullable()
+      edgeIds: z87.array(z87.string()),
+      edges: z87.array(PluginAIInspirationWorkflowEdge),
+      recipe: z87.lazy(() => PluginAIInspirationRecipe),
+      needsEndFrame: z87.boolean(),
+      defaultEndFrameShapeId: z87.string().nullable()
     }),
-    z86.object({
-      status: z86.literal("unavailable"),
-      reason: z86.enum([
+    z87.object({
+      status: z87.literal("unavailable"),
+      reason: z87.enum([
         "not-in-workflow",
         "source-only",
         "running",
@@ -5164,47 +5218,47 @@ var PluginAIInspirationRerunPlanResult = z86.discriminatedUnion(
     })
   ]
 );
-var PluginAIInspirationRerunSelectedBranchArgs = z86.object({
-  shapeId: z86.string().min(1),
-  endFrameShapeId: z86.string().optional(),
+var PluginAIInspirationRerunSelectedBranchArgs = z87.object({
+  shapeId: z87.string().min(1),
+  endFrameShapeId: z87.string().optional(),
   runMode: PluginAIInspirationRunMode.optional()
 });
-var PluginAIInspirationRecipeSlot = z86.object({
-  id: z86.string(),
-  type: z86.enum(["source-image", "end-frame"]),
-  label: z86.string(),
-  required: z86.boolean()
+var PluginAIInspirationRecipeSlot = z87.object({
+  id: z87.string(),
+  type: z87.enum(["source-image", "end-frame"]),
+  label: z87.string(),
+  required: z87.boolean()
 });
-var PluginAIInspirationRecipeStep = z86.object({
-  id: z86.string(),
+var PluginAIInspirationRecipeStep = z87.object({
+  id: z87.string(),
   operation: PluginAIInspirationWorkflowOperation,
-  outputKind: z86.enum(["image", "video"])
+  outputKind: z87.enum(["image", "video"])
 });
-var PluginAIInspirationRecipeDraft = z86.object({
-  name: z86.string(),
-  summary: z86.string(),
-  slots: z86.array(PluginAIInspirationRecipeSlot),
-  steps: z86.array(PluginAIInspirationRecipeStep).min(1).max(20),
-  outputKind: z86.enum(["image", "video"]),
-  thumbnailUrl: z86.string().optional()
+var PluginAIInspirationRecipeDraft = z87.object({
+  name: z87.string(),
+  summary: z87.string(),
+  slots: z87.array(PluginAIInspirationRecipeSlot),
+  steps: z87.array(PluginAIInspirationRecipeStep).min(1).max(20),
+  outputKind: z87.enum(["image", "video"]),
+  thumbnailUrl: z87.string().optional()
 });
 var PluginAIInspirationRecipe = PluginAIInspirationRecipeDraft.extend({
-  version: z86.literal(1),
-  id: z86.string(),
-  fingerprint: z86.string().optional(),
-  createdAt: z86.number(),
-  updatedAt: z86.number()
+  version: z87.literal(1),
+  id: z87.string(),
+  fingerprint: z87.string().optional(),
+  createdAt: z87.number(),
+  updatedAt: z87.number()
 });
-var PluginAIInspirationExtractionResult = z86.discriminatedUnion(
+var PluginAIInspirationExtractionResult = z87.discriminatedUnion(
   "status",
   [
-    z86.object({
-      status: z86.literal("ready"),
+    z87.object({
+      status: z87.literal("ready"),
       draft: PluginAIInspirationRecipeDraft
     }),
-    z86.object({
-      status: z86.literal("unavailable"),
-      reason: z86.enum([
+    z87.object({
+      status: z87.literal("unavailable"),
+      reason: z87.enum([
         "not-in-workflow",
         "source-only",
         "missing-workflow",
@@ -5215,38 +5269,38 @@ var PluginAIInspirationExtractionResult = z86.discriminatedUnion(
     })
   ]
 );
-var PluginAIInspirationListRecipesResult = z86.object({
-  recipes: z86.array(PluginAIInspirationRecipe)
+var PluginAIInspirationListRecipesResult = z87.object({
+  recipes: z87.array(PluginAIInspirationRecipe)
 });
-var PluginAIInspirationSaveRecipeArgs = z86.object({
+var PluginAIInspirationSaveRecipeArgs = z87.object({
   draft: PluginAIInspirationRecipeDraft,
-  name: z86.string().min(1)
+  name: z87.string().min(1)
 });
-var PluginAIInspirationSaveRecipeResult = z86.discriminatedUnion(
+var PluginAIInspirationSaveRecipeResult = z87.discriminatedUnion(
   "status",
   [
-    z86.object({ status: z86.literal("saved"), recipe: PluginAIInspirationRecipe }),
-    z86.object({
-      status: z86.literal("duplicate"),
+    z87.object({ status: z87.literal("saved"), recipe: PluginAIInspirationRecipe }),
+    z87.object({
+      status: z87.literal("duplicate"),
       recipe: PluginAIInspirationRecipe
     }),
-    z86.object({ status: z86.literal("invalid-name"), recipe: z86.null() }),
-    z86.object({ status: z86.literal("failed"), recipe: z86.null() })
+    z87.object({ status: z87.literal("invalid-name"), recipe: z87.null() }),
+    z87.object({ status: z87.literal("failed"), recipe: z87.null() })
   ]
 );
-var PluginAIInspirationDeleteRecipeArgs = z86.object({
-  recipeId: z86.string().min(1)
+var PluginAIInspirationDeleteRecipeArgs = z87.object({
+  recipeId: z87.string().min(1)
 });
-var PluginAIInspirationDeleteRecipeResult = z86.object({
-  deleted: z86.boolean()
+var PluginAIInspirationDeleteRecipeResult = z87.object({
+  deleted: z87.boolean()
 });
-var PluginAIInspirationExtractRecipeFromShapeArgs = z86.object({
-  shapeId: z86.string().min(1)
+var PluginAIInspirationExtractRecipeFromShapeArgs = z87.object({
+  shapeId: z87.string().min(1)
 });
-var PluginAIInspirationRunRecipeArgs = z86.object({
-  recipeId: z86.string().optional(),
+var PluginAIInspirationRunRecipeArgs = z87.object({
+  recipeId: z87.string().optional(),
   recipe: PluginAIInspirationRecipe.optional(),
-  slotShapeIds: z86.record(z86.string(), z86.string()),
+  slotShapeIds: z87.record(z87.string(), z87.string()),
   runMode: PluginAIInspirationRunMode.optional()
 });
 var PluginPresentationAIInspirationApi = class {
@@ -5255,26 +5309,26 @@ var PluginPresentationAIInspirationApi = class {
 };
 
 // src/api/presentation/export.ts
-import * as z87 from "zod";
-var PluginPresentationExportFormat = z87.enum(["pdf", "png", "jpg"]);
-var PluginPresentationExportResolution = z87.object({
-  width: z87.number().positive(),
-  height: z87.number().positive()
+import * as z88 from "zod";
+var PluginPresentationExportFormat = z88.enum(["pdf", "png", "jpg"]);
+var PluginPresentationExportResolution = z88.object({
+  width: z88.number().positive(),
+  height: z88.number().positive()
 });
-var PluginPresentationExportArgs = z87.object({
+var PluginPresentationExportArgs = z88.object({
   format: PluginPresentationExportFormat,
-  sheetIds: z87.array(z87.string()).optional(),
-  combine: z87.boolean().optional(),
+  sheetIds: z88.array(z88.string()).optional(),
+  combine: z88.boolean().optional(),
   resolution: PluginPresentationExportResolution.optional(),
-  fileName: z87.string().optional()
+  fileName: z88.string().optional()
 });
-var PluginPresentationExportFile = z87.object({
-  fileName: z87.string(),
-  mimeType: z87.string(),
-  dataBase64: z87.string()
+var PluginPresentationExportFile = z88.object({
+  fileName: z88.string(),
+  mimeType: z88.string(),
+  dataBase64: z88.string()
 });
-var PluginPresentationExportResult = z87.object({
-  files: z87.array(PluginPresentationExportFile)
+var PluginPresentationExportResult = z88.object({
+  files: z88.array(PluginPresentationExportFile)
 });
 
 // src/api/presentation/index.ts
@@ -5290,38 +5344,38 @@ var PluginAnalysisSunpathApi = class {
 };
 
 // src/api/analysis/shadows.ts
-import * as z88 from "zod";
+import * as z89 from "zod";
 var PluginAnalysisShadowsApi = class {
   constructor() {
   }
 };
-var PluginAnalysisShadowsEnableOptions = z88.object({
-  dateTime: z88.string().optional()
+var PluginAnalysisShadowsEnableOptions = z89.object({
+  dateTime: z89.string().optional()
 });
-var PluginAnalysisShadowsSetDateTimeArgs = z88.object({
-  dateTime: z88.string()
+var PluginAnalysisShadowsSetDateTimeArgs = z89.object({
+  dateTime: z89.string()
 });
-var PluginAnalysisShadowsDateTimeResult = z88.string();
+var PluginAnalysisShadowsDateTimeResult = z89.string();
 
 // src/api/analysis/sunlightHours.ts
-import * as z89 from "zod";
+import * as z90 from "zod";
 var PluginAnalysisSunlightHoursApi = class {
   constructor() {
   }
 };
-var PluginAnalysisComputeResult = z89.object({
-  success: z89.boolean(),
-  error: z89.string().optional()
+var PluginAnalysisComputeResult = z90.object({
+  success: z90.boolean(),
+  error: z90.string().optional()
 });
-var PluginAnalysisJobStatus = z89.enum([
+var PluginAnalysisJobStatus = z90.enum([
   "running",
   "active",
   "inactive"
 ]);
-var PluginAnalysisJobState = z89.object({
+var PluginAnalysisJobState = z90.object({
   status: PluginAnalysisJobStatus,
-  startDate: z89.string(),
-  endDate: z89.string()
+  startDate: z90.string(),
+  endDate: z90.string()
 });
 var PluginAnalysisJobStateResult = PluginAnalysisJobState.nullable();
 
@@ -5332,7 +5386,7 @@ var PluginAnalysisIlluminanceApi = class {
 };
 
 // src/api/analysis/heatmaps.ts
-import * as z90 from "zod";
+import * as z91 from "zod";
 var PluginAnalysisHeatmapsApi = class {
   constructor() {
   }
@@ -5341,149 +5395,149 @@ var PluginAnalysisHeatmapOverlaysApi = class {
   constructor() {
   }
 };
-var PluginAnalysisHeatmapSpaceEntry = z90.object({
+var PluginAnalysisHeatmapSpaceEntry = z91.object({
   space: ComponentHandle,
-  value: z90.number().finite()
+  value: z91.number().finite()
 });
-var PluginAnalysisHeatmapGridCell = z90.object({
+var PluginAnalysisHeatmapGridCell = z91.object({
   position: Vec3Components,
-  value: z90.number().finite(),
-  meta: z90.unknown().optional()
-});
-var HexColor = z90.string().regex(/^#?[0-9a-fA-F]{6}$/, 'expected a 6-digit hex colour like "#0000ff"');
-var PluginAnalysisHeatmapFieldCell = z90.union([
-  z90.object({
-    polygon: z90.array(Vec3Components).min(3),
-    value: z90.number().finite(),
-    meta: z90.unknown().optional()
+  value: z91.number().finite(),
+  meta: z91.unknown().optional()
+});
+var HexColor = z91.string().regex(/^#?[0-9a-fA-F]{6}$/, 'expected a 6-digit hex colour like "#0000ff"');
+var PluginAnalysisHeatmapFieldCell = z91.union([
+  z91.object({
+    polygon: z91.array(Vec3Components).min(3),
+    value: z91.number().finite(),
+    meta: z91.unknown().optional()
   }),
-  z90.object({
-    vertices: z90.array(Vec3Components).min(3),
-    indices: z90.array(z90.number().int().nonnegative()).min(3),
-    value: z90.number().finite(),
-    meta: z90.unknown().optional()
+  z91.object({
+    vertices: z91.array(Vec3Components).min(3),
+    indices: z91.array(z91.number().int().nonnegative()).min(3),
+    value: z91.number().finite(),
+    meta: z91.unknown().optional()
   })
 ]);
-var PluginAnalysisHeatmapScale = z90.discriminatedUnion("type", [
-  z90.object({
-    type: z90.literal("bands"),
-    count: z90.number().int().min(2).max(64).optional()
+var PluginAnalysisHeatmapScale = z91.discriminatedUnion("type", [
+  z91.object({
+    type: z91.literal("bands"),
+    count: z91.number().int().min(2).max(64).optional()
   }),
-  z90.object({
-    type: z90.literal("threshold"),
-    threshold: z90.number().finite(),
+  z91.object({
+    type: z91.literal("threshold"),
+    threshold: z91.number().finite(),
     passColor: HexColor.optional(),
     failColor: HexColor.optional(),
-    passLabel: z90.string().optional(),
-    failLabel: z90.string().optional()
+    passLabel: z91.string().optional(),
+    failLabel: z91.string().optional()
   }),
-  z90.object({
-    type: z90.literal("categorical"),
-    classes: z90.array(
-      z90.object({
-        value: z90.number().finite(),
-        label: z90.string(),
+  z91.object({
+    type: z91.literal("categorical"),
+    classes: z91.array(
+      z91.object({
+        value: z91.number().finite(),
+        label: z91.string(),
         color: HexColor
       })
     ).min(1)
   })
 ]);
-var PluginAnalysisHeatmapOptions = z90.object({
-  name: z90.string().min(1).max(64).optional(),
-  title: z90.string().optional(),
-  unit: z90.string().optional(),
-  min: z90.number().finite().optional(),
-  max: z90.number().finite().optional(),
-  colors: z90.array(HexColor).min(1).optional(),
+var PluginAnalysisHeatmapOptions = z91.object({
+  name: z91.string().min(1).max(64).optional(),
+  title: z91.string().optional(),
+  unit: z91.string().optional(),
+  min: z91.number().finite().optional(),
+  max: z91.number().finite().optional(),
+  colors: z91.array(HexColor).min(1).optional(),
   scale: PluginAnalysisHeatmapScale.optional(),
-  hover: z90.boolean().optional()
+  hover: z91.boolean().optional()
 });
-var PluginAnalysisHeatmapsRenderResult = z90.object({
-  success: z90.literal(true)
+var PluginAnalysisHeatmapsRenderResult = z91.object({
+  success: z91.literal(true)
 });
-var PluginAnalysisHeatmapOverlayInfo = z90.object({
-  name: z90.string(),
-  visible: z90.boolean(),
-  kind: z90.enum(["spaces", "grid", "surfaceGrid", "field"])
+var PluginAnalysisHeatmapOverlayInfo = z91.object({
+  name: z91.string(),
+  visible: z91.boolean(),
+  kind: z91.enum(["spaces", "grid", "surfaceGrid", "field"])
 });
-var PluginAnalysisHeatmapOverlaysListResult = z90.object({
-  overlays: z90.array(PluginAnalysisHeatmapOverlayInfo)
+var PluginAnalysisHeatmapOverlaysListResult = z91.object({
+  overlays: z91.array(PluginAnalysisHeatmapOverlayInfo)
 });
 
 // src/api/analysis/weather.ts
-import * as z91 from "zod";
+import * as z92 from "zod";
 var PluginAnalysisWeatherApi = class {
   constructor() {
   }
 };
-var PluginWeatherSelectionMethod = z91.enum([
+var PluginWeatherSelectionMethod = z92.enum([
   "nearest-station",
   "user-upload",
   "project-override"
 ]);
-var PluginWeatherSourceMeta = z91.object({
-  weatherFileId: z91.string(),
-  station: z91.string(),
-  sourceId: z91.string(),
-  distanceKm: z91.number().nullable(),
+var PluginWeatherSourceMeta = z92.object({
+  weatherFileId: z92.string(),
+  station: z92.string(),
+  sourceId: z92.string(),
+  distanceKm: z92.number().nullable(),
   selectionMethod: PluginWeatherSelectionMethod,
-  checksum: z91.string(),
-  windReferenceHeightM: z91.number()
-});
-var PluginWeatherRow = z91.object({
-  timestamp: z91.string(),
-  utcOffsetMinutes: z91.number(),
-  dryBulbC: z91.number(),
-  relativeHumidityPercent: z91.number(),
-  windSpeedMps: z91.number(),
-  ghiWm2: z91.number(),
-  dniWm2: z91.number(),
-  dhiWm2: z91.number(),
-  flags: z91.array(z91.string())
-});
-var PluginWeatherGetSeriesArgs = z91.object({
-  startDate: z91.string(),
-  endDate: z91.string(),
-  interval: z91.enum(["hourly"]).optional(),
-  cursor: z91.string().optional()
-});
-var PluginWeatherSeriesResult = z91.object({
+  checksum: z92.string(),
+  windReferenceHeightM: z92.number()
+});
+var PluginWeatherRow = z92.object({
+  timestamp: z92.string(),
+  utcOffsetMinutes: z92.number(),
+  dryBulbC: z92.number(),
+  relativeHumidityPercent: z92.number(),
+  windSpeedMps: z92.number(),
+  ghiWm2: z92.number(),
+  dniWm2: z92.number(),
+  dhiWm2: z92.number(),
+  flags: z92.array(z92.string())
+});
+var PluginWeatherGetSeriesArgs = z92.object({
+  startDate: z92.string(),
+  endDate: z92.string(),
+  interval: z92.enum(["hourly"]).optional(),
+  cursor: z92.string().optional()
+});
+var PluginWeatherSeriesResult = z92.object({
   source: PluginWeatherSourceMeta,
-  rows: z91.array(PluginWeatherRow),
-  nextCursor: z91.string().nullable(),
-  warnings: z91.array(z91.string()).optional()
+  rows: z92.array(PluginWeatherRow),
+  nextCursor: z92.string().nullable(),
+  warnings: z92.array(z92.string()).optional()
 });
 
 // src/api/analysis/solar.ts
-import * as z92 from "zod";
+import * as z93 from "zod";
 var PluginAnalysisSolarApi = class {
   constructor() {
   }
 };
-var PluginSolarRunStatus = z92.enum([
+var PluginSolarRunStatus = z93.enum([
   "running",
   "complete",
   "cancelled",
   "failed"
 ]);
-var PluginSolarSampleMode = z92.enum(["instant", "range"]);
-var PluginSolarUnits = z92.enum(["W/m2", "kWh/m2"]);
-var PluginSolarHourlyArtifact = z92.object({
-  url: z92.string(),
-  format: z92.enum(["parquet", "csv-gz"]),
-  expiresAt: z92.string()
-});
-var PluginSolarSamplePoint = z92.object({
-  id: z92.string(),
-  position: z92.tuple([z92.number(), z92.number(), z92.number()]),
-  normal: z92.tuple([z92.number(), z92.number(), z92.number()]).optional()
-});
-var PluginSolarSampleGridArgs = z92.object({
-  points: z92.array(PluginSolarSamplePoint),
-  dateTime: z92.string().optional(),
-  startDate: z92.string().optional(),
-  endDate: z92.string().optional(),
-  includeHourlyArtifact: z92.boolean().optional()
+var PluginSolarSampleMode = z93.enum(["instant", "range"]);
+var PluginSolarUnits = z93.enum(["W/m2", "kWh/m2"]);
+var PluginSolarHourlyArtifact = z93.object({
+  url: z93.string(),
+  format: z93.enum(["parquet", "csv-gz"]),
+  expiresAt: z93.string()
+});
+var PluginSolarSamplePoint = z93.object({
+  id: z93.string(),
+  position: z93.tuple([z93.number(), z93.number(), z93.number()]),
+  normal: z93.tuple([z93.number(), z93.number(), z93.number()]).optional()
+});
+var PluginSolarSampleGridArgs = z93.object({
+  points: z93.array(PluginSolarSamplePoint),
+  dateTime: z93.string().optional(),
+  startDate: z93.string().optional(),
+  endDate: z93.string().optional(),
+  includeHourlyArtifact: z93.boolean().optional()
 }).superRefine((a, ctx) => {
   const hasInstant = a.dateTime !== void 0;
   const hasStart = a.startDate !== void 0;
@@ -5491,73 +5545,73 @@ var PluginSolarSampleGridArgs = z92.object({
   const hasRange = hasStart || hasEnd;
   if (hasInstant === hasRange) {
     ctx.addIssue({
-      code: z92.ZodIssueCode.custom,
+      code: z93.ZodIssueCode.custom,
       message: "provide exactly one timing mode: dateTime (instant), or startDate+endDate (range)"
     });
   }
   if (hasRange && !(hasStart && hasEnd)) {
     ctx.addIssue({
-      code: z92.ZodIssueCode.custom,
+      code: z93.ZodIssueCode.custom,
       message: "range mode requires both startDate and endDate"
     });
   }
 });
-var PluginSolarSampleResult = z92.object({
-  id: z92.string(),
-  directSunVisible: z92.boolean(),
-  shadeFraction: z92.number(),
-  directIrradiance: z92.number().optional(),
-  diffuseIrradiance: z92.number().optional(),
-  totalIrradiance: z92.number().optional()
+var PluginSolarSampleResult = z93.object({
+  id: z93.string(),
+  directSunVisible: z93.boolean(),
+  shadeFraction: z93.number(),
+  directIrradiance: z93.number().optional(),
+  diffuseIrradiance: z93.number().optional(),
+  totalIrradiance: z93.number().optional()
 });
-var PluginSolarSampleGridResult = z92.object({
+var PluginSolarSampleGridResult = z93.object({
   status: PluginSolarRunStatus,
   mode: PluginSolarSampleMode,
-  coordinateSystem: z92.literal("world-plan-space"),
-  modelRevision: z92.string(),
-  inputHash: z92.string(),
+  coordinateSystem: z93.literal("world-plan-space"),
+  modelRevision: z93.string(),
+  inputHash: z93.string(),
   units: PluginSolarUnits,
-  sunUpHours: z92.number(),
+  sunUpHours: z93.number(),
   weather: PluginWeatherSourceMeta.nullable(),
-  weatherQuality: z92.array(z92.string()),
-  results: z92.array(PluginSolarSampleResult),
+  weatherQuality: z93.array(z93.string()),
+  results: z93.array(PluginSolarSampleResult),
   hourlyArtifact: PluginSolarHourlyArtifact.nullable(),
-  nextCursor: z92.string().nullable()
+  nextCursor: z93.string().nullable()
 });
 
 // src/api/analysis/daylight.ts
-import * as z93 from "zod";
+import * as z94 from "zod";
 var PluginAnalysisDaylightApi = class {
   constructor() {
   }
 };
-var PluginDaylightMetric = z93.enum(["ASE", "sDA"]);
-var PluginDaylightRunStatus = z93.enum([
+var PluginDaylightMetric = z94.enum(["ASE", "sDA"]);
+var PluginDaylightRunStatus = z94.enum([
   "running",
   "complete",
   "cancelled",
   "failed"
 ]);
-var PluginDaylightGrid = z93.object({
-  spacingM: z93.number(),
-  workplaneHeightM: z93.number(),
-  boundaryOffsetM: z93.number()
+var PluginDaylightGrid = z94.object({
+  spacingM: z94.number(),
+  workplaneHeightM: z94.number(),
+  boundaryOffsetM: z94.number()
 });
-var PluginDaylightSchedule = z93.object({
-  startHour: z93.number(),
-  endHour: z93.number()
+var PluginDaylightSchedule = z94.object({
+  startHour: z94.number(),
+  endHour: z94.number()
 });
-var PluginDaylightOpaqueOptics = z93.object({
-  reflectance: z93.number().min(0).max(1)
+var PluginDaylightOpaqueOptics = z94.object({
+  reflectance: z94.number().min(0).max(1)
 });
-var PluginDaylightGlazingOptics = z93.object({
-  transmittance: z93.number().min(0).max(1)
+var PluginDaylightGlazingOptics = z94.object({
+  transmittance: z94.number().min(0).max(1)
 });
-var PluginDaylightMaterialOptics = z93.union([
+var PluginDaylightMaterialOptics = z94.union([
   PluginDaylightOpaqueOptics,
   PluginDaylightGlazingOptics
 ]);
-var PluginDaylightCategoryDefaults = z93.object({
+var PluginDaylightCategoryDefaults = z94.object({
   wall: PluginDaylightOpaqueOptics.optional(),
   ceiling: PluginDaylightOpaqueOptics.optional(),
   floor: PluginDaylightOpaqueOptics.optional(),
@@ -5565,81 +5619,81 @@ var PluginDaylightCategoryDefaults = z93.object({
   glazing: PluginDaylightGlazingOptics.optional(),
   context: PluginDaylightOpaqueOptics.optional()
 });
-var PluginDaylightBlindsOptics = z93.object({
-  transmittance: z93.number().min(0).max(1)
+var PluginDaylightBlindsOptics = z94.object({
+  transmittance: z94.number().min(0).max(1)
 });
-var PluginDaylightOptics = z93.object({
-  materials: z93.record(z93.string(), PluginDaylightMaterialOptics).optional(),
+var PluginDaylightOptics = z94.object({
+  materials: z94.record(z94.string(), PluginDaylightMaterialOptics).optional(),
   categories: PluginDaylightCategoryDefaults.optional(),
   blinds: PluginDaylightBlindsOptics.optional()
 });
-var PluginDaylightComputeArgs = z93.object({
-  standard: z93.literal("IES-LM-83-23"),
-  metrics: z93.array(PluginDaylightMetric).min(1),
+var PluginDaylightComputeArgs = z94.object({
+  standard: z94.literal("IES-LM-83-23"),
+  metrics: z94.array(PluginDaylightMetric).min(1),
   schedule: PluginDaylightSchedule.optional(),
   grid: PluginDaylightGrid,
   optics: PluginDaylightOptics.optional()
 });
-var PluginDaylightPollArgs = z93.object({
-  runId: z93.string(),
-  cursor: z93.string().optional()
-});
-var PluginDaylightSensorRecord = z93.object({
-  sensorId: z93.string(),
-  position: z93.tuple([z93.number(), z93.number(), z93.number()]),
-  spaceId: z93.string(),
-  storeyId: z93.string(),
-  areaWeightM2: z93.number(),
-  occupiedHours: z93.number(),
-  directSunHoursAtOrAbove1000Lux: z93.number().optional(),
-  aseFail: z93.boolean().optional(),
-  da300Percent: z93.number().optional(),
-  sdaPass: z93.boolean().optional()
-});
-var PluginDaylightAggregateScope = z93.enum([
+var PluginDaylightPollArgs = z94.object({
+  runId: z94.string(),
+  cursor: z94.string().optional()
+});
+var PluginDaylightSensorRecord = z94.object({
+  sensorId: z94.string(),
+  position: z94.tuple([z94.number(), z94.number(), z94.number()]),
+  spaceId: z94.string(),
+  storeyId: z94.string(),
+  areaWeightM2: z94.number(),
+  occupiedHours: z94.number(),
+  directSunHoursAtOrAbove1000Lux: z94.number().optional(),
+  aseFail: z94.boolean().optional(),
+  da300Percent: z94.number().optional(),
+  sdaPass: z94.boolean().optional()
+});
+var PluginDaylightAggregateScope = z94.enum([
   "project",
   "storey",
   "space"
 ]);
-var PluginDaylightAggregate = z93.object({
+var PluginDaylightAggregate = z94.object({
   scope: PluginDaylightAggregateScope,
-  id: z93.string().nullable(),
-  analysisAreaM2: z93.number(),
-  asePercent: z93.number().optional(),
-  sdaPercent: z93.number().optional()
-});
-var PluginDaylightProvenance = z93.object({
-  engine: z93.string(),
-  engineVersion: z93.string(),
-  standardProfile: z93.string(),
-  thresholds: z93.object({ aseLux: z93.number(), aseHours: z93.number() }).passthrough(),
+  id: z94.string().nullable(),
+  analysisAreaM2: z94.number(),
+  asePercent: z94.number().optional(),
+  sdaPercent: z94.number().optional()
+});
+var PluginDaylightProvenance = z94.object({
+  engine: z94.string(),
+  engineVersion: z94.string(),
+  standardProfile: z94.string(),
+  thresholds: z94.object({ aseLux: z94.number(), aseHours: z94.number() }).passthrough(),
   weather: PluginWeatherSourceMeta.nullable(),
-  occupancySchedule: z93.object({ id: z93.string(), hoursPerYear: z93.number() }).passthrough(),
+  occupancySchedule: z94.object({ id: z94.string(), hoursPerYear: z94.number() }).passthrough(),
   grid: PluginDaylightGrid,
-  location: z93.object({
-    latitude: z93.number(),
-    longitude: z93.number(),
-    timezone: z93.string(),
-    trueNorthDeg: z93.number()
+  location: z94.object({
+    latitude: z94.number(),
+    longitude: z94.number(),
+    timezone: z94.string(),
+    trueNorthDeg: z94.number()
   }).passthrough(),
-  surfaceReflectances: z93.record(z93.string(), z93.number()),
-  modelRevision: z93.string(),
-  inputHash: z93.string(),
-  warnings: z93.array(z93.string()),
-  excludedSpaces: z93.array(
-    z93.object({ spaceId: z93.string(), reason: z93.string() })
+  surfaceReflectances: z94.record(z94.string(), z94.number()),
+  modelRevision: z94.string(),
+  inputHash: z94.string(),
+  warnings: z94.array(z94.string()),
+  excludedSpaces: z94.array(
+    z94.object({ spaceId: z94.string(), reason: z94.string() })
   ),
-  failedGeometry: z93.array(
-    z93.object({ componentId: z93.string(), reason: z93.string() })
+  failedGeometry: z94.array(
+    z94.object({ componentId: z94.string(), reason: z94.string() })
   )
 }).partial().passthrough();
-var PluginDaylightResults = z93.object({
+var PluginDaylightResults = z94.object({
   status: PluginDaylightRunStatus,
-  runId: z93.string().optional(),
-  sensors: z93.array(PluginDaylightSensorRecord),
-  aggregates: z93.array(PluginDaylightAggregate),
+  runId: z94.string().optional(),
+  sensors: z94.array(PluginDaylightSensorRecord),
+  aggregates: z94.array(PluginDaylightAggregate),
   provenance: PluginDaylightProvenance,
-  nextCursor: z93.string().nullable()
+  nextCursor: z94.string().nullable()
 });
 
 // src/api/analysis/index.ts
@@ -5649,7 +5703,7 @@ var PluginAnalysisApi = class {
 };
 
 // src/api/workspace/index.ts
-import * as z94 from "zod";
+import * as z95 from "zod";
 var PluginWorkspaceApi = class {
   constructor() {
   }
@@ -5662,68 +5716,68 @@ var PluginWorkspaceTeamsApi = class {
   constructor() {
   }
 };
-var PluginProjectRef = z94.object({
-  id: z94.string(),
-  name: z94.string(),
-  teamId: z94.string().optional(),
-  createdAt: z94.string().optional(),
-  modifiedAt: z94.string().optional()
+var PluginProjectRef = z95.object({
+  id: z95.string(),
+  name: z95.string(),
+  teamId: z95.string().optional(),
+  createdAt: z95.string().optional(),
+  modifiedAt: z95.string().optional()
 });
-var PluginTeamRef = z94.object({
-  id: z94.string(),
-  name: z94.string(),
-  role: z94.string().optional()
+var PluginTeamRef = z95.object({
+  id: z95.string(),
+  name: z95.string(),
+  role: z95.string().optional()
 });
-var PluginTeamMemberRef = z94.object({
-  id: z94.string(),
-  name: z94.string(),
-  email: z94.string().optional(),
-  role: z94.string().optional()
+var PluginTeamMemberRef = z95.object({
+  id: z95.string(),
+  name: z95.string(),
+  email: z95.string().optional(),
+  role: z95.string().optional()
 });
-var PluginWorkspaceProjectsCreateArgs = z94.object({
-  name: z94.string(),
-  unit: z94.string().optional(),
-  teamId: z94.string().optional()
+var PluginWorkspaceProjectsCreateArgs = z95.object({
+  name: z95.string(),
+  unit: z95.string().optional(),
+  teamId: z95.string().optional()
 });
-var PluginWorkspaceProjectsCreateResult = z94.object({
-  projectId: z94.string()
+var PluginWorkspaceProjectsCreateResult = z95.object({
+  projectId: z95.string()
 });
-var PluginWorkspaceProjectsCopyArgs = z94.object({
-  name: z94.string(),
-  teamId: z94.string().optional()
+var PluginWorkspaceProjectsCopyArgs = z95.object({
+  name: z95.string(),
+  teamId: z95.string().optional()
 });
-var PluginWorkspaceProjectsCopyResult = z94.object({
-  projectId: z94.string()
+var PluginWorkspaceProjectsCopyResult = z95.object({
+  projectId: z95.string()
 });
-var PluginWorkspaceProjectsListArgs = z94.object({
-  teamId: z94.string().optional()
+var PluginWorkspaceProjectsListArgs = z95.object({
+  teamId: z95.string().optional()
 });
-var PluginWorkspaceProjectsListResult = z94.object({
-  projects: z94.array(PluginProjectRef)
+var PluginWorkspaceProjectsListResult = z95.object({
+  projects: z95.array(PluginProjectRef)
 });
-var PluginWorkspaceProjectsGetArgs = z94.object({
-  projectId: z94.string()
+var PluginWorkspaceProjectsGetArgs = z95.object({
+  projectId: z95.string()
 });
 var PluginWorkspaceProjectsGetResult = PluginProjectRef.nullable();
-var PluginWorkspaceProjectsRenameArgs = z94.object({
-  projectId: z94.string(),
-  name: z94.string()
+var PluginWorkspaceProjectsRenameArgs = z95.object({
+  projectId: z95.string(),
+  name: z95.string()
 });
-var PluginWorkspaceProjectsRenameResult = z94.object({
-  projectId: z94.string()
+var PluginWorkspaceProjectsRenameResult = z95.object({
+  projectId: z95.string()
 });
-var PluginWorkspaceTeamsListResult = z94.object({
-  teams: z94.array(PluginTeamRef)
+var PluginWorkspaceTeamsListResult = z95.object({
+  teams: z95.array(PluginTeamRef)
 });
-var PluginWorkspaceTeamsGetArgs = z94.object({
-  teamId: z94.string()
+var PluginWorkspaceTeamsGetArgs = z95.object({
+  teamId: z95.string()
 });
 var PluginWorkspaceTeamsGetResult = PluginTeamRef.nullable();
-var PluginWorkspaceTeamsListMembersArgs = z94.object({
-  teamId: z94.string()
+var PluginWorkspaceTeamsListMembersArgs = z95.object({
+  teamId: z95.string()
 });
-var PluginWorkspaceTeamsListMembersResult = z94.object({
-  members: z94.array(PluginTeamMemberRef)
+var PluginWorkspaceTeamsListMembersResult = z95.object({
+  members: z95.array(PluginTeamMemberRef)
 });
 
 // src/api/index.ts
@@ -5828,8 +5882,8 @@ function isPluginErrorCode(value) {
 var ERROR_ENVELOPE_VERSION = 1;
 function isErrorEnvelope(value) {
   if (typeof value !== "object" || value === null) return false;
-  const record7 = value;
-  return record7.envelopeVersion === ERROR_ENVELOPE_VERSION && typeof record7.code === "string" && typeof record7.message === "string" && typeof record7.errorId === "string";
+  const record8 = value;
+  return record8.envelopeVersion === ERROR_ENVELOPE_VERSION && typeof record8.code === "string" && typeof record8.message === "string" && typeof record8.errorId === "string";
 }
 var idCounter = 0;
 function newErrorId(prefix = "") {
@@ -6289,6 +6343,14 @@ export {
   PluginDesignEraseApi,
   PluginDesignEraseEdgeArgs,
   PluginDesignEraseEdgeResult,
+  PluginDesignFamilyApi,
+  PluginDesignFamilyCreateArgs,
+  PluginDesignFamilyDeleteArgs,
+  PluginDesignFamilyFlexArgs,
+  PluginDesignFamilyGetParametersArgs,
+  PluginDesignFamilyPlaceArgs,
+  PluginDesignFamilyPrepareArgs,
+  PluginDesignFamilySetParametersArgs,
   PluginDesignFurnitureApi,
   PluginDesignFurnitureExistsArgs,
   PluginDesignFurnitureGetCatalogItemArgs,
@@ -6385,6 +6447,8 @@ export {
   PluginExecutionError,
   PluginExportModelArgs,
   PluginFaceMaterial,
+  PluginFamilyBundleSchema,
+  PluginFamilySnapshotOption,
   PluginFurnitureCatalogItem,
   PluginFurnitureDimensionUpdates,
   PluginFurnitureDimensions,